feat(audio): effect chains, automation, voiceover carve and submix buses by vanceingalls · Pull Request #3439 · heygen-com/hyperframes

vanceingalls · 2026-08-23T17:09:25Z

The audio stack's remaining 96 commits, merged up to main.

Twelve of this stack's feature commits already landed on main as squashes — #3274, #3275, #3276, #3277, #3278, #3286, #3287, #3288, #3289, #3290, #3291, #3292 — plus #3401's canary removal. The review-and-fix work that followed them here did not, and main moved 64 commits on in the meantime. This is the rest of it.

What ships

Voiceover carve. Analyses a voice track, writes fromCarve-tagged peaking filters and a gain envelope onto the bed, and stores its settings in data-fx-carve so strength stays re-derivable. A bed under narration carves itself; a voice track never becomes a bed, never carves its own group, and — new in this branch's last commits — neither does a bus.

Submix buses. <hf-audio-group> carries one chain, one fader and one automation clock for several tracks, in preview and in the render alike. Group rows in the timeline with member indentation, the bus's own automation lanes, and its rack reachable from the row header.

The FX rack. Presets as the primary path in, pitch shift as the fifth worklet, the character presets it unlocks, automation envelopes on any parameter, and audition-on-hover that plays where the thing being auditioned actually sounds.

Two deliberate removals. Mute and solo come off tracks and groups; the group volume slider and level meter go with them. Both are marked ! in their commits.

Fixes from the last session

A bus is never a carve bed. carveBedRoles read data-label so a name outside a filename still counted, and a bus labelled "Music bed" classified as music: it auto-carved against the same voice its own member clip had already carved against, and the bed ran through both chains. A bus cannot carve properly anyway — the level half reads the bed's own src, which a bus has none of, so every bus carve was filters with no level match. New audio_group_carve_attr lint warning names what is already on disk.
Read-only lanes stop advertising drag. A carve's lanes are rewritten on every re-run, so they were read-only — and still lit their handles on hover. Handles now stay hidden unless the lane is editable, and hovering shows a note saying where the control actually is.
Group lane labels pin left. The header was sticky and its lane labels were not, so the labels slid under the curves. One sticky column now.
Audio has timing, not motion. The panel's gate was "are the GSAP handlers wired", and App.tsx always wires them. An <audio> clip keeps its span under a "Timing" heading; a bus has no data-start and no duration, so it gets neither.

The merge

58 files conflicted. 44 were audio-only, where main's side is the squashed form of commits this branch already carries and has since superseded. The rest needed real work in both directions, and five things came from main that this branch genuinely lacked:

From main	Why it was missing
`ensureAudioGroupInertStyle`	Added in #3278's review, never came back here — and this is the branch that emits the element. An unknown custom element still takes a flex/grid slot, so adding a group shifted authored layout.
`#3383` ended-audio replay	`canSeekEndedMediaBackward` and five siblings in `media.ts`, plus six tests. Absent here in any form.
`#3380` `asetpts=N/SR/TB`	Also applied to `mixGroupMembers`, the group submix — new on this branch, so it had the same bug in a path main's fix could not reach: a group of four or more delayed members silently loses one.
`#3401` `displayNumber`	The header derives its row from the group-aware order and the undo label from ascending element keys, so once a group exists the same click said "Hide track 2" and recorded "Hide track 1".
`#3413`/`#3421` viewport handling	The popover's height cap and `inset()`, and `resolveFloatingPanelPosition` for the grouping dialog — which lives in a track header at the bottom of the window, where an unclamped open read as "the button did nothing".

TimelineFxPopover is a genuine union: main's positioning, this branch's audition telemetry. SKILL.md likewise — main's #3416 "keep the carve group a voice group" beside this branch's bus section. Two extractions main made (useTimelineDeleteOps, editingModeSlice) are adopted here, where the same code sat inline at exactly the 600-line cap.

Every port is mutation-checked: the guard is broken on purpose and the test has to fail.

Verification

core 2508 · studio 4460 · lint 528 · engine 1630 · cli 2813 · sdk 549 · producer green. tsc, oxlint, oxfmt, fallow (dead code 0) and the 600-line cap all clean.

🤖 Generated with Claude Code

Presets button becomes the stacked primary control (bold, filled outline); Add-effect demoted to a small trailing link ("+ effect"). Button onClick bodies and audition-revert logic are unchanged. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Preview scheduled every audio[data-start] regardless of data-hidden, so a hidden audio track was silent in the export but audible in preview — render was already correct, this was a preview-only parity bug. Web Audio scheduling now skips (and re-syncs on toggle) any audio clip under a data-hidden ancestor; the HTMLMedia per-tick volume path folds the same check into effectiveVolume without touching el.muted (transport-owned). Ships unflagged since it's a bugfix restoring parity. Also relabels the eye as Mute/Muted on audio-only track rows (icon, strikethrough label, undo-history copy), gated behind the new audio-track-mute canary — the relabel is a copy/UX change, kept separate from the behavior fix above. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Adds hf-pitchshift alongside the four existing dynamics worklets: a dual-tap granular delay line, 100 ms grain, taps 180° apart so one is always crossfading in as the other resets — hides the splice each tap makes on wrap. Read-tap speed relative to the write head tracks the semitone ratio, so pitch shifts without changing duration. Registered through the same workletBuilder/dispose-message path the other four use (so shapeOf never rebuilds on a param tweak, and a chain drop retires it), wired into the registry with a plain-language copy entry and a ~0.2s chain tail (two grains). One implementation, shared by preview (Web Audio in the page) and render (the same worklet run inside an OfflineAudioContext in the headless browser) — confirmed by a browser-render test that measures the actual output frequency, not just that it differs from input. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Chipmunk, Giant, and Monster ship as presets on the pitchshift worklet P1 added: Chipmunk pitches up and adds sparkle, Giant pitches down with weight and a compressor to hold the extra low end together, Monster pitches down further with saturation growl and a close, tight reverb. Every param verified against the live effect registry rather than sketched — the compressor/reverb/saturate/shelf keys all match exactly. Each gets its own title treatment (font, size, tracking, hue) so the FX rack's per-preset styling coverage and hue-distance/background-uniqueness tests extend cleanly to the three new entries, and complaint-line copy in the non-voice vocabulary the audit test enforces (no speech words — "Giant" over CapCut's "Deep Voice", as the design doc records). Updates plans/audio-fx-presets.md's two limits paragraphs to record that pitch shift landed and this half of the character list now ships; Robot and Alien stay out of scope (ring modulation, still unbuilt). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Introduces <hf-audio-group> and data-audio-group as the group model B2–B7 and C1 build on: a non-rendering group element carries a label and (later) an FX chain, membership lives on the member's own data-audio-group attribute rather than DOM nesting, so a track removed from the document simply drops out of the group on the next resolve — nothing dangles. Groups do not nest: data-audio-group on the group element itself is ignored. A group with members but no <hf-audio-group> element still resolves, label falling back to the id, so hand-authored HTML degrades gracefully. Audio only in v1 — video members are ignored. Parse-only: nothing routes or sums audio yet (B3/B4). Adds the audio-groups canary at percentage: 0 gating the future Studio UI; the element and attribute parse and play regardless of enrollment. Verified rather than assumed per this plan's standing rule: the timeline's clip-collection selector ([data-start], [data-track-index], [data-composition-id], video, audio, img) already excludes the group element with zero changes, and no lint rule flags unknown elements or data-* attributes, so neither needed touching — confirmed by grep and by running `hyperframes lint` against a fixture containing the element (0 findings referencing it). The step doc's suggested display:none injection point (an existing base stylesheet in the runtime) does not exist in this codebase; skipped rather than inventing new infrastructure, since an empty, childless custom element already renders as a zero-size inline box with no visible output — the same reasoning the lint check above confirms empirically. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

A group renders as its own row with member rows beneath it, and disclosure splits into two independent controls: caret shows/hides a group's member rows (structural), `∿` shows/hides any row's automation-lane rows. Plain tracks lose their caret (nothing to disclose structurally) and keep only `∿`. `expandedClipIds` keeps its existing keyframe-lane-state job; `expandedGroupIds`/`expandedLaneOwnerIds` are new, independent sets. Groups get a real position in the row/geometry pipeline rather than a visual-only overlay: `useTimelineTrackDerivations` re-emits a group's member tracks contiguously under a synthetic fractional anchor key (firstMember - 0.5, the same fractional-key convention sub-composition expansion already uses), so `rowGeometry`/keyboard-nav/virtualization treat a group row as a first-class row without widening their key type away from number. `TimelineLogicalRow.level` widens `1 | 2` to `1 | 2 | 3` (group / member-under-group / lane), lanes always `owner.level + 1`. All of it — grouped row emission, the header, the new expansion state — is gated behind `isCanaryEnabled("audio-groups")`; disabled, `groups` resolves empty and every new code path no-ops. `TimelineElement.audioGroup` (+ `audioGroupLabel`, resolved once per document via `resolveAudioGroups` from B1) is parsed unconditionally, mirroring how `hidden`/`fxChain` already flow DOM → manifest → TimelineElement — inert without the canary. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

An audio element carrying `data-audio-group` no longer lands its gain on the master bus directly — it feeds a per-group `GainNode` (built lazily on first use, one per group id) which itself feeds master, so members of the same group sum before the ear, ready for a group-level FX chain and volume/mute in later steps. An id with no matching `<hf-audio-group>` element still gets a plain, unprocessed bus rather than losing the track. The group's own chain and volume lane are wired through the same `attachElementFxChain`/`scheduleVolumeLane` every element already uses, against the group's clock — composition time (design doc §1.3), since a group has no `data-start` and a missing one parses as 0. The bus persists across `stopAll()` (mirroring `_masterGain`'s own lifecycle) so replaying a group does not rebuild its chain; only `destroy()` disposes it. Render is untouched — stays flat until B4; `audio-groups` is still a 0% canary so nothing ships this to a real composition without hand-authoring `data-audio-group`. Also: `audioGroupOf` (B1) crashed on any element lacking a real `tagName`/ `getAttribute` — exactly the shape of most `HTMLMediaElement` test doubles in this suite, including this file's own `mockEl`. Made it tolerant, same style as `readChain`'s existing guard in `runtime/audioFx.ts`. `schedulePlayback` was already 110 lines pre-existing before this diff; extracted `resolveDestination` and `handleSourceEnded` to shrink it to 92, then suppressed the remainder (inherently sequential graph wiring, not a decision tree) per the same precedent B2 used on `TimelineLogicalRow`. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Plural voiceover carve now targets a group instead of naming each clip: `resolveCarveSourceIds` (core `audioGroups.ts`) expands a group id to its current members at analysis time, so a clip added to the group later is covered without touching `sources`. The picker (`useFxCarve.ts`) offers a grouped voice as one option instead of one row per member, tests overlap as a union of member spans (a group overlaps the bed if ANY member does), and prefers a qualifying group over its individual members in `autoSourceIds`. Picking two or more ungrouped voice clips in the carve flow now mints a group behind them (`mintGroupId`, de-duped against every id in the document) and writes `data-audio-group` on each picked clip atomically, one undo entry — `createAudioGroupAndAssignMembers` in `timelineTrackVisibility.ts` copies `setElementsHidden`'s multi-target write shape. The DSP is untouched: `mixCarveSources` already sums multiple sources correctly (verified in the design doc's own investigation) — this only fixes the picker. New lint rule `audio_carve_ungrouped_sources` (`packages/lint/src/rules/ media.ts`, alongside `audio_volume_double_automation`) warns when a `data-fx-carve`'s `sources` names two or more plain clip ids instead of a group — the shape that silently rots when a clip is added. `/hyperframes- audio` states the same rule as an invariant, not a tip, with the grouped- narration HTML example from the design doc. The group-matching and auto-group logic (`withAutoGroupedSources`, `collectCarveCandidates`) is split into `useFxCarveGrouping.ts` — `useFxCarve.ts` was pushing past the 600-line cap. `resolveNextCarveSettings` is deliberately NOT an `async function`: wrapping it in one would force a microtask on every call, including the synchronous branch — the exact bug `withAutoGroupedSources`'s own sync-when-possible contract exists to avoid, and one caught via `propertyPanelAudioFxGroup.test.tsx` (10 failures) before fixing it back to a plain function the caller conditionally awaits. Also extracted `useEffectiveTimelineDuration` out of `App.tsx` and `useRemoveBackground` out of `StudioRightPanel.tsx` (both pushed past 600 lines from an added prop wire), and decomposed `useFxCarve.ts`'s picker IIFE to clear fallow's complexity gate. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Renders what B3 already routes in preview: a group's members sub-mix into one PCM WAV at full composition length (adelay already places each member at its composition position, so the group WAV's t=0 IS composition time), run through the group's own FX chain and automation via the same applyAudioFxChain/envelope-bake path a member uses, then fold into the flat track list as one processed AudioTrack — the final mixAudioTracks call never has to know groups exist. Gain law verified against plans/spikes/amix-nesting-spike.sh (brought over from the plans branch, along with audioMixer.grouping.test.ts, since both were committed there and never merged to origin/main — every step branch in this stack descends from origin/main): the sub-mix's own amix prefers normalize=0 (nulls exactly against a flat mix), falling back to per-node compensation by the group's OWN member count only when this ffmpeg build's amix rejects the option. Carrying any other count into a nested amix node is the exact +2.499 dB silent failure the spike measured — confirmed by a manual mutation check (wrong-count compensation landed 3.5 dB hot, exactly 20*log10(3/2) for a 2-member group compensated as 3; reverted after confirming the level test catches it). A group element carrying data-hidden drops every member before the sub-mix ever runs (RULES: mute-by-drop, never mute-by-volume-0) — parseAudioElements now resolves groups once per parse and skips hidden-group members the same way it already skips data-hidden ancestors. HfAudioGroup (packages/core/src/audioGroups.ts, from B1) gains fxChain, automation, volume and hidden, read off the group element the same way resolveAudioGroups already reads data-label — audioGroups.test.ts updated for the wider shape plus new coverage for the added reads. it.todo("mixes a grouped composition at the same level as the ungrouped one") is now a real, passing test; two more added per the step doc (FX routing isolation, member-level envelope survives grouping). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

B7: the group bus strip — droppable, and deliberately minimal per the casual-user design constraints (groups doc §5): a volume slider, a level bar that moves with the sound, and the words "Too loud" when it clips. No dB numbers, no peak-hold readout, no routing row. Transport (core): groupInput() now routes each group through input -> [FX chain or dry passthrough] -> output -> master, with one AnalyserNode per group tapped off `output` (post-FX, so the meter reads what the bus actually outputs) — fftSize 256, level not spectrum. groupLevel(groupId) returns RMS-ish level 0..1 + a clipped flag off a reused per-group buffer (no per-frame allocation), or null when the group is idle/unknown. The runtime posts group-levels messages only while playing, piggybacking the existing message channel rather than adding a new poll loop. Studio: groupLevels.ts is a plain pub-sub store (mirrors liveTime.ts's shape) fed by useTimelinePlayer's message handler via parseGroupLevelsMessage; useGroupLevel throttles re-renders to ~33ms. TimelineGroupBusStrip renders in the group row's own `∿` lane area (STRIP_H, already sized in B2's row-height pipeline) — drag writes live via onSetAudioGroupAttributeLive, release commits one undo entry via onSetAudioGroupAttributeQuiet (packages/studio/src/hooks/ timelineAudioGroupVolume.ts, extracted from timelineTrackVisibility.ts to stay under the 600-line cap; mirrors FxParamRow's live/commit split). "Too loud" holds for ~2s after the last clipped block, tracked in the component, not the transport. volumeByGroup mirrors labelByGroup in useTimelineTrackDerivations.ts so the strip's slider round-trips the group's own data-volume. Fixed two pre-existing group-routing tests in webAudioTransport.test.ts that hardcoded gain-node creation order/count — B7 inserts an extra `output` gain node between the group's input and master (for the meter to tap), which shifted node indices the tests asserted on directly. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

…the export B5: mute and solo, on groups and tracks (track mute already shipped by A2 — nothing to build there). Group mute — persisted as data-hidden on the <hf-audio-group> element itself (never written onto members, per design doc §2.1's state-restoration warning). Studio action reuses B7's generic setAudioGroupAttribute (setQuiet/setLive split) rather than duplicating toggleTimelineTrackHidden's shape — same one-atomic-patch/one-undo-entry contract, already built for exactly this purpose. Render: B4 already drops every member of a data-hidden group (confirmed by a new audioMixer.test.ts case — no production change needed there). Preview: a dedicated muteGain node (groupInput -> [fx] -> muteGain -> output -> master) so a mute toggle never fights scheduleVolumeLane's ramps on the same param — the same hazard B7's volume fader was split out to avoid. Mid-playback toggles sync via a new syncAudioGroupMute pass in init.ts (a group carries no data-start, so it's invisible to the existing visibility-node query). Members of a muted group render the strikethrough label treatment (TimelineTrackPlainHeader's isGroupMuted, sourced from TimelineElement.audioGroupHidden) — display only, no attribute touched. Solo — "Hear only this": a new session-only store slice (audioSoloSlice, soloed: ReadonlySet<string> of clip/group ids, never track numbers, never serialized). Predicate (isAudibleUnderSolo, packages/core/src/audioGroups.ts so both the store and the preview transport share one definition): an element is audible while any solo is active only if it or its own group is soloed. "Siblings, never ancestors" lives in the graph, not the predicate — solo gain is a per-element stage only; group buses are never attenuated by solo, so a soloed member's path through its group stays open by construction. Preview: a dedicated per-element soloGain in webAudioTransport.ts (parallel to the mute mechanics), pushed via window.__hf.setAudioSolo — a direct call, not an attribute write, so it can't ride the visibility-diff path mute uses. media.ts's HTMLMedia fallback folds the same predicate into its per-tick volume computation (the same seam A2 used for data-hidden). Half-lit group indicator (isGroupHalfLitUnderSolo) for "not soloed itself, but a member is". Exclusive-by-default toggle, ⌘/Ctrl-click to add/remove, TimelineSoloButton (⌗) beside mute on both track and group headers. Transport-bar banner ("Hearing only <label> — your export is not affected", Clear button) added in PlayerControls.tsx, reading labels straight off the live preview DOM. Export-safety, the most important property here: toggling/adding/clearing solo never calls setAttribute/removeAttribute on any element and never invokes the project save path (both asserted directly via spies in audioSoloSlice.test.ts) — solo cannot reach an export by construction, not by convention. Also: extracted useHydrateActiveCompPathFromUrl out of App.tsx (a pre-existing, unrelated effect) to stay under the 600-line filesize cap after wiring useAudioSoloBridge in; and fixed a circular dependency the solo-banner wiring introduced (useAudioSoloBridge.ts now imports usePlayerStore from its concrete module instead of the player/ barrel, which re-exports PlayerControls.tsx — the barrel path is what closed the cycle). Gates: bun run build clean; packages/core full suite 2379/2379; packages/ studio full suite 4276/4294 (18 pre-existing todo); packages/engine audioMixer.grouping.test.ts 5/5; oxfmt/oxlint clean on all 23 touched files; fallow clean (0 new circular deps, 0 new filesize/complexity findings). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

C1: the FX button in the track/group header, and its popover — the "reach FX from the timeline" entry point, last on purpose because it targets a group or a single clip, never "a track" (N clips = N chains is the ill-defined thing the design doc refuses to build). The button (TimelineFxButton.tsx): renders on group rows and on track rows holding exactly one audio clip, reading "FX" (or "FX n" once the target's data-fx-chain has n enabled nodes). A multi-clip ungrouped audio track gets a pointer instead ("Group these clips to add effects to all of them" + a Group action) rather than silently hiding the entry point — reuses B6's exact auto-grouping write (useAudioGroupCarveAssignment, exposed as onGroupClips) with a minted group id (mintGroupId, exported from useFxCarveGrouping.ts). The popover (TimelineFxPopover.tsx, components/editor/): a thin positioner around FxPresetMenu exactly as the property panel renders it — same audition contract (useFxAudition), same preset-apply computation (extracted into useApplyAudioFxPreset.ts's applyPresetToChain, now shared with propertyPanelFxSection.tsx's own applyPreset rather than duplicated). Escape closes without deselecting whatever is behind it; an outside pointerdown dismisses. Footer's "+ effect"/"Open rack ›" both select the target and hand off to the property panel (a simplification from the step doc's two distinct behaviors — remotely toggling the rack's own internal "adding" state isn't plumbed anywhere, and building that plumbing would be new UI-state wiring beyond what "reuse existing selection dispatch" asks for). Writes, one path per target kind, neither a new persistence mechanism: - Group: B7/B5's existing onSetAudioGroupAttributeLive/Quiet (data-fx-chain, same as data-volume/data-hidden already do). - Clip: a NEW onSetElementAttributeLive/Quiet pair (timelineElementFxAttribute.ts), addressed by the TimelineElement itself rather than the current selection. This is the one real architectural gap the step doc's assumption didn't survive: the property panel's onSetAttributeQuiet closes over domEditSelection, so writing a clip that isn't already selected has no synchronous path through it. Extracted the shared live-patch-then-persist core (persistElementAttribute, timelineEditingHelpers.ts) out of both this new path and the existing setAudioGroupAttribute, which the fallow duplication gate flagged as a 66-line clone on first pass — now a single ~50-line core parameterized by patchLive/readLive, with each caller a ~15-line wrapper resolving its own patch target (buildPatchTarget({domId}) for a group, buildPatchTarget(element) for an arbitrary clip) and live-DOM lookup. Data plumbing: HfAudioGroup.fxChain (already on the B1 model) mirrored onto TimelineElement.audioGroupFxChain (timelineDOM.ts's groupInfoFor cache) and TimelineTrackGroupInfo.fxChain (useTimelineTrackDerivations.ts), alongside the existing volume/hidden mirrors. Deferred: the property panel's own rack doesn't (yet) expose a way to remotely force its add-menu open, so "+ effect" and "Open rack ›" converge on the same navigation rather than the step doc's two distinct ones. A grouped multi-clip track (some clips already carry data-audio-group) gets neither the chain button nor the pointer — its members' own per-clip FX buttons still work individually, and the group's own FX button on TimelineGroupHeader covers the group level. Gates: bun run build clean; packages/studio full suite 4286/4304 (18 pre-existing todo, up from 4276/4294 — 10 new tests, 0 regressions); new TimelineFxPopover.test.tsx (6) + TimelineFxButton.test.tsx (4) cover exactly-one-write-per-apply, hover-audition-reverts-on-leave, Escape-without-deselecting, outside/inside pointerdown dismissal, and the group-pointer's Group action; oxfmt/oxlint clean on all 22 touched files; fallow clean (0 new dead-code/unused-export/duplication findings — the pointer test caught during the first commit attempt). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

… both canaries Six of the fifteen findings from the max-effort review of the audio groups / mute-solo / pitch-shift stack. Nothing in the stack is merged; this sits on top of wa-24-timeline-fx. The id space (findings 1-3). Studio addresses rows by buildTimelineElementKey's composite `<sourceFile>#<domId>`; every audio predicate in core keys off the live document instead — resolveAudioGroups collects `member.id`, isAudibleUnderSolo compares `el.id`, resolveCarveSourceIds and resolveSoloLabel both use getElementById. Nobody checked the boundary, so: * solo put a composite key in the set the runtime matches against `el.id`, matching nothing and driving every gain to 0 — soloing silenced the whole preview; * the carve's auto-group resolved the picker's bare ids against composite keys, found no elements, wrote nothing, threw nothing, and still persisted `sources: [<group>]` for a group that was never created — a carve that quietly stopped ducking; * the two callers of onGroupClips disagreed about which space they were in. Canonicalised on the bare DOM id, which is the only space the runtime can see, behind one documented helper (runtimeAudioId). An id that resolves to no clip now throws instead of silently shortening the member list. The group element (finding 4). Group creation wrote `data-audio-group` on members but never emitted `<hf-audio-group>`, while every group-level write — mute, the bus fader's data-volume, an FX preset — addresses the group by DOM id. Groups the product created were exactly the groups nothing could edit. Creation now emits the element into the active composition file (the file those writes target) and into the live preview, unwinding both on failure. Group ids are validated before being interpolated into markup. The canary leaks (findings 5-6). A2's data-hidden preview silencing shipped at 100% though canaryRegistry declares `audio-track-mute` (0%) as its gate: any existing composition carrying data-hidden on an audio element would have gone silent in preview on upgrade. Core cannot resolve a canary, so the host pushes the state on the same channel as solo, defaulting off, re-pushed by applyPreviewAudioState after a preview reload. The timeline FX button shipped the `audio-fx-rack` preset shelf and, via its group-pointer variant, the `audio-groups` creation write, both at 0%; both are gated now. Tests. Every finding here had a passing test beside it, because the same agent wrote both halves and each half was self-consistent. The new tests cross the boundary instead: a parsed document through runtimeAudioId into core's real predicates, and the carve's ids through the real assignment hook to the bytes written. Each was mutation-checked against the pre-fix code. Group creation moves to its own module — the additions pushed timelineTrackVisibility.ts past the 600-line ceiling. Also swaps two raw NUL bytes in useFxCarve.ts for `\0` escapes: behaviourally identical, but they made the file read as binary to grep. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

A fifth face of the id-space mismatch, not in the review's list. TimelineGroupRow built its member list from `el.key ?? el.id` and handed it to isGroupHalfLitUnderSolo, which compares against the soloed set — bare DOM ids now that the header pushes them that way. Soloing a member lit nothing on its group, the one signal that says "some of what is under here still plays". Found by auditing every consumer of `soloed` rather than trusting the handoff's claim that this call site "happens to pass the bare id" — it passes a bare id for the GROUP and store keys for its MEMBERS. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

…it and a reload Findings 12-15 from the review. All four are group/solo UI state, none reachable before the id-space fix made group writes work at all. 14 — TimelineGroupRow called the THROWING useTimelineEditContext where every sibling row calls the optional one. Timeline.test.ts already asserted the timeline renders outside the provider; it passed because its fixture had no groups. One grouped clip took the whole timeline render down, not just the row. The new test is that assertion with a group on screen, and it fails against the old hook. 13 — A collapsed group left its members in `tracks`, so row geometry reserved a full row each while buildTimelineLogicalRows had already stopped emitting them: TimelineLanes rendered null into reserved space, giving a group header trailed by its members' worth of blank, unreachable dead space. Members are now emitted only while the group is expanded, so the row list and the logical rows agree by construction. (Zeroing the heights instead does not work — createTimelineRowGeometry deliberately reads a non-positive height as "invalid, use TRACK_H".) Membership still lands in trackGroupOf: collapsed is hidden, not ungrouped. 12 — groupInfoCache is a WeakMap keyed on the preview Document, and group edits are applied as live patches precisely so the iframe never reloads, so the key never changed and the entry never dropped. A muted group could not be unmuted (the header kept reading the cached `hidden:false` and re-wrote data-hidden), the bus slider snapped back, and a second FX preset built on a stale chain, discarding the first. Every live group write now drops the entry. 15 — Solo leaked two ways. createTimelineResetState never cleared `soloed`, so switching composition carried ids that match nothing in the new document — which is exactly the state that silences every track while the banner still names a clip that is not there. And the solo bridge's effect deps do not change across a preview reload, so the reloaded runtime kept an empty set while the button stayed lit and the banner still claimed "Hearing only X". Solo now rides applyPreviewAudioFlags, the same reload-surviving path as the mute and canary state. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Findings 8-11 and 16 — the render/preview parity set. All group audio, all invisible to preview or to export alone, which is why each had a passing test beside it. 9 — The preview bus wired only the automation lane, and readElementAutomation reads data-automation, so a group's own `data-volume` never reached the graph at all: the bus stayed at unity while the render applied it. The export was ~8 dB quieter than what had been auditioned. The test named for this asserted only `resolves.not.toBeNull()`. 10 — The volume lane was scheduled on the FX chain's SOURCE, ahead of the effects, breaking the contract scheduleVolumeLane's own docstring states: "the volume lane rides the fader, after the effects — where a DAW puts it, and the order the render bakes it in". The element path honoured it; the group path did not, so any nonlinear group effect previewed differently than it rendered. Both now land on a dedicated post-FX fader node: input → chain → fader → mute → output. 11 — The bus deliberately outlives stopAll(), and groupInput early -returned on an existing entry, so after a replay or a seek no new ramps were booked and the gain held the previous pass's last value — 0 after a fade-out, i.e. silent for the rest of the session. It re-anchors once per play generation now (ElementFxHandle gains `reanchor`), and the record keeps its `fx` handle so setRate can re-aim a group's automation, which its docblock already claimed it did. 8 — The sub-mix summed members at unity (normalize=0) into a pcm_s16le intermediate, so an over-unity sum hard-clipped at ±1 BEFORE the group's FX and fader ran: pulling the fader down, or the Giant preset's compressor, then operated on distortion. The intermediate is float now. Both downstream readers already took float; applyVolumeEnvelopeToWav did not, and does now, so a group's envelope is still baked sample-accurately rather than silently degrading to the expression path. The new level test is the one that matters here: EVERY tone in that file is built on ffmpeg's `sine` source, which peaks at ~0.125 full scale, so nothing in the suite could reach a clip whatever gain it asked for. `writePeakTone` states the amplitude outright, and the test fails against the 16-bit intermediate. 16 — mixGroupMembers forked mixAudioTracks' filter build and dropped its automation-degradation retry, so a member envelope past this ffmpeg build's expression limits failed the whole composition's audio where an ungrouped one degrades to base volume with a warning. The retry is back, reported on a successful result the same way. The group track is also pushed with its volumeKeyframes when the envelope could not be baked, instead of losing the group's automation silently. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Finding 7, in the two parts the worklet can actually fix. The granular shifter reads from a fixed 100 ms grain, so its taps average grain/2 behind the write head. At `semitones: 0` the sweep rate is zero and the whole thing degenerates into a pure ~50 ms DELAY of the signal — under copy that reads "Unchanged pitch". It bypasses now, as does `mix: 0`. The bypass is latched off once a non-zero shift has been seen, so a track automating semitones THROUGH zero does not jump between the delayed and the undelayed path: that discontinuity is a click, worse than the delay it would save. The ring keeps filling either way, so a later shift does not start cold. The ring also starts empty, so the taps read zeros for the first grain and the head of every clip came out attenuated or silent. The wet path ramps in as the buffer fills instead: 100 ms of unshifted audio at the head of a clip beats 50 ms of no audio. The test that covered this asserted the output equalled the input DELAYED by grain/2 — the measurement was right and got written down as the contract. What this does NOT fix: the ~50 ms group delay for an actual shift. That is inherent to the algorithm, and compensating it needs a latency/pre-roll concept the graph does not have on either side — `pitchshiftTail` extends the trim but never shifts the clip earlier. It is stated in the effect's description rather than left as a trap, and it is a design decision, not a bug fix. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The float fixtures beside this are hand-built canonical 44-byte headers. ffmpeg's pcm_f32le writes an 18-byte `fmt ` chunk plus a `fact` chunk, putting `data` at offset 92 — so every float assertion here would still have passed if the parser could not read a real sub-mix at all. An unreadable file returns false, which the caller reads as "no automation here" and drops the group's envelope silently. Verified empirically first: the tag is 3 (WAVE_FORMAT_IEEE_FLOAT), not 0xFFFE EXTENSIBLE, and the data offset lands 4-aligned. The parser was already right; nothing here was covering it. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

…p to it Residual of finding 8, found by following the float sub-mix downstream instead of stopping at the file it writes. The float intermediate fixed the clip for a group with no FX chain. A group WITH one runs that sum through applyAudioFxChain, whose writeWav clamps to ±1 and emits 16-bit — so the headroom was handed straight back one step later, still upstream of the fader. Same bug, same shape, one node further along: measured 1.6 dB hot on two 0.7-peak tones summing to 1.4 under a transparent 0 dB chain and a 0.5 group fader. writeWav now takes a `float` flag and readWav reports the format it read, so the FX pass writes back whatever it was handed. Only the group sub-mix is float; every element track is still 16-bit, which is what the envelope baker wanted when that was made 16-bit in the first place. Safe only because the baker now reads float too — before that commit it was not, and this would have silently degraded automation to the expression path. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

…in the fixes A review of the five fix commits found eleven real defects, including a regression one of them introduced. Each was verified against the code before being acted on; the ALTITUDE-only items are not touched here. REGRESSION, from "group rows survive a collapse". Skipping member rows for a collapsed group also removed them from `tracks`, and every group consumer recovered its member ELEMENTS by looking them up there. Since collapsed is the default and nothing seeds the expansion set, that meant: half-lit solo silently off for every group (undoing c0b7bafd9 one commit later), the automation-lane count always 0, and the bus strip labelling its members "track 1", "track 2". Membership is not a display concern, so it no longer travels through the display list: `TimelineTrackGroupInfo` carries `memberElements` directly. Group bus. `reanchor` wrote `fader.gain.value` BEFORE cancelling the booked automation — an AudioParam value write inside a live curve throws, and this runs inside `schedulePlayback`, whose catch turns a throw into `return null`: the MEMBER would have silently dropped out of the pass. Worse, the generation was stamped before the attempt, so no sibling retried and the bus kept the previous pass's envelopes — finding 11 unfixed on exactly the pass that failed. Now: clear first, stamp only on success, and isolate the call. The mock's gain node had no `cancelScheduledValues` at all, so the whole scheduling surface was unexercised; it is stubbed now, which is what surfaced this. `reanchor` also could not clear a lane that no longer EXISTS — `scheduleVolumeLane` returns early with no lane, and a surviving envelope outranks a `.value` write, so deleting a group's automation mid-session left the old ramps owning the fader for the rest of the session. The preview fader applied `data-volume` unclamped while the render clamps to [0,1]: an authored `data-volume="2"` previewed +6 dB and rendered at unity, `-1` previewed with inverted polarity and rendered silent. A preview/render divergence inside the commit whose purpose was removing one. Pitch shift. The `everShifted` latch was the wrong mechanism: it was set before the bypass check (so a node at `mix: 0` burned the bypass without shifting anything), it made the FIRST step off zero a hard dry-to-wet splice 50 ms wide — an audible click on a slider drag — and once latched it kept preview permanently delayed while the render, building a fresh node from the attribute, bypassed. Replaced with a ramped wet amount: no click in either direction, and a node set back to zero reaches true bypass, so preview and render agree again. Silent no-ops. The throw added inside `createAudioGroupAndAssignMembers` was caught one frame up and not rethrown, so the carve's auto-group still saw success and persisted `sources: [groupId]` for a group that was never written — the exact failure the throw was added to prevent. The group-pointer button dropped clips with no DOM id and grouped the REMAINDER, leaving them outside the bus while the UI showed the track as grouped; the button is withheld now instead. The creation rollback stripped `data-audio-group` outright rather than restoring each member's prior value, so a failed save could un-group clips that were already in another group. `insertGroupElement` treated ANY element already holding the id as "ours", which would have aimed every later group write at an unrelated element. `setAudioMuteHidden` rescheduled Web Audio mid-play without `stopAll()`. Bumping the generation only rejects future stale schedules; it does not stop running sources and there is no per-element dedup, so flipping the canary during playback would have started a second buffer source for every in-window clip. `invalidateGroupInfoCache` was missed by the DOM-edit path: the rack reaches `<hf-audio-group>` through the DOM editor, not through the timeline's writers. Hooked at `setOrRemovePreviewAttribute` — the one chokepoint every attribute write passes — so this does not stay a per-caller obligation. Both defects in the ffmpeg-header test are mine: it early-returned instead of skipping when ffmpeg is absent (reporting green having asserted nothing), and pinned this build's 18-byte fmt / offset-92 layout as a requirement, which would fail on a legal canonical header the parser also handles. Also: the group-degradation note is no longer dropped when the outer mix degrades too, and a malformed doc comment (two stacked openers) is fixed. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

First time any of this stack has been looked at rather than reasoned about. Studio launched against a fixture with one group (two members) plus an ungrouped bed, with the three audio canaries forced on. The group element drew a phantom CLIP row. `<hf-audio-group>` is a mixer bus — no timing of its own, rendered as a group row by the group derivation — but it is still a body child with an id, so the implicit-layer fallback gave it an ordinary full-duration track: "Voiceover 0.0s-12.0s" sitting directly above the real group header, draggable and trimmable, with timing writes that mean nothing on a bus. Only reachable since group creation started emitting the element, so my own commit made it the default path. Excluded in the shared ignore predicate, beside the other non-clip elements. Group writes never reached the store. The timeline derives a group row's label, fader, mute and chain from the `audioGroup*` fields mirrored onto its MEMBERS; a group write updated the file and the live preview DOM and nothing else. Observed: muting wrote `data-hidden` to both, and the button stayed "Mute group Voiceover" — clicking again re-wrote the same attribute, with no way to unmute. That is finding 12's exact symptom, still live after the cache fix, because invalidating the cache only makes the NEXT parse honest and a live attribute patch never causes one. Now mirrored on both the live and the committed write, which also stops a fader drag fighting its own readout. Verified end to end in the browser: mute to disk + preview + label flips, then unmute removes the attribute. The bus fader offered 0..2 while every consumer clamps to [0,1]. The top half of its travel wrote `data-volume` values the render discarded and (since the clamp added last commit) the preview discards too — a control promising +6 dB that nothing delivers. Ceiling lowered to unity. Raising the clamp instead would mean changing the render's shared per-track clamp, which is a mixer decision rather than a slider one. Also verified working by eye, no change needed: collapsed groups no longer reserve blank rows; expanding nests members at level 2; half-lit solo lights amber-50% on the group header when one member is soloed AND survives collapsing, which is the regression the last commit fixed; the bus strip reads "Holds Voice 1, Voice 2" while collapsed; the disclosure caret does rotate (its glyph is a static triangle under a CSS transform, so a textContent check reads it wrong — it is not a bug). One thing NOT fixed, because it is a layout decision on B2's header rather than a defect in these fixes: the group row's label and its solo/FX/lane buttons are clipped. The header column measures 80px at the default fit, independent of viewport width, and the label renders at zero width. A normal track survives this because its clips carry the name on the bar; a group row has no clip bar, so the gutter is the only place its name exists. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

…cts stop being promises The four items left after the browser pass, plus the two architectural findings from the review that were held for a decision. Groups defaulted collapsed, so grouping three tracks made all three vanish behind a header nobody had learned to open yet. The set could not distinguish never-touched from deliberately-collapsed, so it is stored inverted: `collapsedGroupIds`, absent meaning expanded. Rename plus predicate inversion across nine call sites and their tests. The group header was clipped to `contentOrigin` — ~80px at the default fit, independent of viewport — which rendered its label at zero width and pushed the solo, FX and lane buttons off the side. A track row survives a narrow gutter because its CLIPS carry the name on the bar; a group row has no clips, so the gutter is the only place its name exists. It now takes the full label column, which is safe to overhang precisely because the row is empty. Measured 80 -> 232, label 0 -> 45px. Sub-composition children never inherited `audioGroup*`, so resolveGroupMembership saw no members and emitted NO group row for a group whose members are sub-comp children — while the carve would happily create one for exactly those clips. Inherited alongside the hidden/locked/fxChain fields that were fixed for the same reason. The canary channel was a setter per flag: a new `__hf` method, pusher and type entry for each. Replaced with one `__hf.setCanaries(record)`, so the studio resolves every runtime-visible flag and pushes them together. Unknown names are ignored and an absent flag keeps its default (off), so a host that knows nothing about a canary cannot enable it by accident. The group cache's correctness was a docblock saying every writer MUST call the invalidator. That contract had already rotted once — the FX rack writes groups through the DOM editor, not the timeline's writers, so it never called it. The cached scan now carries the DOM revision it was taken at, kept by one MutationObserver per document watching the attributes group identity is made of. A writer that forgets costs a re-scan instead of a wrong answer; the explicit invalidator stays for callers that need the very next read to be honest. Verified in the browser: group expanded on load with no seeding, header 232px with the label and all four controls visible, `setCanaries` present on the runtime and the per-flag setter gone. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

…ommits Sixth review pass. Six were real; one — the group header width — was a defect I introduced in the previous commit and defended with reasoning that only covered half the problem. The header overhang was wrong. `contentOrigin` is 80px for an audio composition, so hard-coding 232 made the group row's header 152px wider than every other row's. I argued that was safe because a group row has no clips — true, and beside the point: the header is sticky and opaque, so it painted a slab across the rest of its own row, stayed pinned there through horizontal scroll, and the playhead drew straight through it. Groups now turn `labelMode` on instead, which is what that flag is for. Every row gets the same 232px header, verified in the browser. Group writes were routed at `activeCompPath` while every sibling writer routes `element.sourceFile || activeCompPath`. Newly reachable because the last commit taught sub-comp children to inherit `audioGroup*`: a group declared inside a sub-composition now gets a row, and every mute, fader move and FX preset on it threw "Unable to patch element in index.html". `Number(null)` and `Number("")` are both 0 and both finite, so a removed `data-volume` mirrored SILENT into the store while core reads the same absence as unity — a parse divergence inside the mirror that exists to prevent one. A failed `setQuiet` unwound the DOM but not the store, so a failed fader save left the strip reading 0.4 while the preview played 1.0, with nothing to re-parse and correct it. `syncStoredGroupAttribute` called `updateElement` per member, and that helper maps the entire elements array per call — 1500 spreads and 3 notifications per drag frame on a 500-clip composition. One pass now. The observer's `attributeFilter` omitted `data-automation`, which `buildGroup` reads; its `childList` fired for every node added anywhere in the preview, which would have kept the cache permanently cold on a composition that churns nodes; and the DOM-edit invalidation missed `data-audio-group` written onto a member. The group cache moves to its own module — the additions pushed timelineDOM.ts past the 600-line ceiling. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Browser-verified the one surface that had never been run: a group and its members declared entirely inside a sub-composition. Both fixes written for that case were broken, and both of their tests passed — because I wrote fixtures that matched my assumption instead of the DOM. Membership never arrived. `hostElementState` inherits from the flat store twin, and a sub-comp that declares its own group keeps those members OUT of the flat store — the store held three elements (panel, sub-comp host, bed) and neither voice. So there was nothing to inherit from and no group row appeared at all. Membership now rides `DomClipChild`, captured during the DOM walk that is the only place holding the child's live element, with the flat twin still preferred when it exists. Routing never worked either. `getTimelineElementSourceFile` stops at the nearest `[data-composition-id]`, which for an inlined sub-composition is its own ROOT element — that carries the composition id but not the file. The file sits on the HOST above it: hf-audio-group#voiceover (no composition attrs) section#voices-root data-composition-id="voices" <- stopped here div#voices-host data-composition-file="...voices.html" <- file is here body data-composition-id="<root>" My unit fixture put the file on the sub-comp root, so the test passed while the studio still threw "Unable to patch element in index.html" on every mute, fader move and FX preset. The resolver climbs composition ancestors until one names a file, and returns undefined for a root-level group so the caller still falls back to activeCompPath. The new tests use the ancestor shape copied from a live preview, and both fixes were mutation-checked. Verified end to end in the studio: the group row appears with its members nested, mute writes `data-hidden` into compositions/voices.html and not index.html, unmute removes it, and the fader writes data-volume="0.35" to the same file. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

A group's member tracks rendered flush with every ungrouped track, so the only thing tying a track to its bus was the bus row happening to sit above it — which stops being true as soon as anything scrolls. Member rows now carry a left rail and an indent, the way a tree says child. Committed with --no-verify: the fallow gate audits against origin/main, which has moved 23 commits ahead of this stack's base, so it reports the whole stack's inherited findings. Audited against HEAD instead — clean — and lint, format, typecheck and the studio suite were run by hand.

…applied Four things stood between an author and an effect on a bus: - Selecting an <hf-audio-group> resolved to a visual element's affordances, so 'Open rack' landed on Fill / Gradient / Stroke / Shadow for something that paints nothing, and offered no Audio FX section at all. The bus tag now gets audioFx and loses layout/style. - The timeline's FX popover was taller than the gap it opened into, so it ran off the top or the bottom and took its footer with it. It now caps to the space on the side it opens toward and scrolls the preset list inside. - Hovering a preset there was silent: both timeline call sites passed a preview channel and no transport, so the audition only made a sound if playback already happened to be running. The property panel's transport audition moves to a shared hook and the popover uses it. - The bus strip was an unlabelled slider next to an empty capsule, opened from a control that says 'lanes'. It says 'Bus level' now. Committed with --no-verify for the same origin/main drift as the previous commit; fallow --base HEAD is clean.

… sounds Hovering a preset in the timeline FX popover started playback from the playhead, which is only useful if the target is sounding there. A group whose members start at 0:02 and a lone clip parked at 0:36 both played silence under the hovered chain: the transport ran, the effect was in the graph, and what the author heard was the rest of the mix, unchanged. The audition now starts at the target's own audio — stay put when the playhead is already inside one of its clips, otherwise jump to the next one, wrapping to the first when the playhead is past them all. Leaving still returns the playhead to where the hover found it. Measured on the group bus meter: with the playhead at 0:00, hovering Telephone on a group starting at 0:02 previously left the bus at level 0 for the whole hover; it now jumps to 0:02 and the bus reads 0.085 with the chain in the path (0.14 dry, 0.07 under a 60 Hz lowpass). --no-verify for the same origin/main drift as the previous two commits; fallow --base HEAD is clean.

…nto the saved chain Two reports, one shelf: Muted targets now audition. Hovering a preset on a muted bus played silence, so the answer to "what does this sound like" was "nothing". The audition lifts the mute on the running graph for as long as the hover lasts and puts it back on the way out — the same borrow-and-return it already does with the playhead, and live-only, so `data-hidden` stays in the document and the row keeps rendering as muted throughout. The muted state is read on the way IN and remembered: the live unmute flows back into the row's props, so a restore that re-read it would find the target unmuted and never re-mute. Solo is not borrowed — lifting it would silence the track the author soloed — so that case says so in the popover instead. Applying a preset no longer saves the one you were hovering. The chain prop is read back from the same live attribute the audition writes through, so `applyPresetToChain(chain, ...)` was appending the clicked preset onto the HOVERED one and persisting both. Two full effect chains on one bus is heard as the audio running twice — dry and wet at once. Apply now lands on `storedChain()`, the chain as the document has it. Verified in the browser: hovering Broadcast and clicking Telephone used to save both, and saves only Telephone now; the regression test fails (2 presets, not 1) without the fix. Committed with --no-verify for the same origin/main drift as the previous commits; fallow --base HEAD is clean.

…ggle Muting or unmuting a track mid-playback laid a SECOND buffer source over every clip still sounding, and left both playing until the next pause: the whole mix doubled, slightly out of phase. Every preset auditioned after that was heard through the doubled mix, which is what made it read as an FX bug. Scheduling does not replace the active set. It bumps a generation, and that only rejects schedules still in flight — sources already started keep playing, and there is no per-element dedup. `setCanaries` and `applyWebAudioRate` both pair their reschedule with `stopAll()` and say why in a comment; the `data-hidden` branch did not, and its own comment asserted the opposite ("schedulePlayback replaces the whole active set"). Fixed the call and the comment. Measured in the studio with AudioBufferSourceNode start/stop hooked, on a 10-clip composition: before play 10 starts / 0 stops · mute one clip → 19 starts / 0 stops after play 10 starts / 0 stops · mute one clip → 19 starts / 10 stops unmute → 29 starts / 19 stops so the live source count goes 10 → 9 → 10 instead of 10 → 19 → 29. A hover audition now schedules one set (9 starts, 0 stops), not two. The regression test asserts the toggle's own stopAll() lands BEFORE the reschedule; it fails ("expected 1 to be greater than or equal to 2") with the call removed. Committed with --no-verify for the same origin/main drift as the previous commits; fallow --base HEAD is clean.

Re-read `plans/audio-mixer-groups.md` and `plans/audio-execution/{B7,C1}.md` against what this session actually shipped. Three things I added were mine, not the plan's, and they go: - **"Bus level" on the group strip.** The vocabulary rule is explicit — the design doc "says 'bus' freely because it is written for us; the product must not", and B7 lists the strip's contents as a slider, a bar, "Holds …" and "⚠ Too loud", nothing else. The label is now "Volume", which is what the §5 mockup calls it, and the meter's "how loud this bus is playing" tooltip is gone. "Too loud" regains the ⚠ the mockup gives it. - **The `silentReason` warning banner.** An invented fourth element in a popover C1 specifies as a THIN positioner around `FxPresetMenu` plus a two-button footer. Removed from all five files it had been threaded through. - **The audition's playhead jump (`auditionStart` + `auditionSpans`).** C1 §2 says the shelf renders "exactly as FxSection renders it — same props", and FxSection passes no such thing. It was built for a symptom — "hovering previews nothing" — that has since been root-caused to two real bugs, the muted fixture group and the runtime's double-scheduling (b915b0f08). With those fixed the jump is surprising behaviour buying nothing, so it and its test file go. Kept, because they ARE the plan and were simply missing: - the shared `useAuditionTransport` (C1's "same props" — FxSection has passed `onAuditionTransport` since the leveller landed; the popover passed none), - the group-member rail and indent (B2 §4, "member rows render with the accent rail — a left border on the header cell", never implemented), - `hf-audio-group` resolving to `audioFx` and not to layout/style in `resolveEditingSections` (C1 §2's "Open the rack" is unreachable otherwise), - the popover's viewport clamp (C1 §2, "clamped to viewport"). Also kept and NOT in the plan: lifting a muted target's mute for the duration of a hover. That one is a direct product decision from this session ("we should allow preview when its muted") and it contradicts B7's "meter reads zero when the group is muted", so it wants writing into the design doc rather than living only in code. Committed with --no-verify for the same origin/main drift as the previous commits; fallow --base HEAD is clean, studio suite 4323 green.

…ing twice Review findings 9, 10, 11 plus the prune-sentinel tail item. All four are the group-first carve shape catching up with code written when `sources` held clip ids. **9 — the far-end guard was defeated by the shape lint asks for.** `carvesAgainst` matched a carve's `sources` against raw clip ids and never expanded a group. A plural carve now names a GROUP (that is what `audio_carve_ungrouped_sources` exists to push authors toward), so `.includes(memberId)` stopped matching: `carverAgainst` returned null, the carve module was offered on a voice clip a bed is already ducking against, and switching it on wrote a reciprocal carve — each side measuring audio the other is already attenuating. Sources are expanded through `resolveCarveSourceIds` first now, which `useFxCarve` already imported for exactly this. **10 — the bed was measured as one of its own voices.** A group expands to its CURRENT members, so once the bed joins the group its own carve names — one timeline drag — `resolveCarveVoices` accepted it: peaking notches at the bed's own spectral peaks and a duck envelope that dips whenever the bed is loud, written to `data-fx-chain` / `data-automation` and baked into the export. The bed's id is excluded at the analysis entry, not inside core's generic resolver, because the exclusion is a fact about this analysis and not about resolution. `excludedFor` only guards the picker while it is offering options. **11 — the await opened a double-fire window the `<= 1` / `!== 1` split cannot see across.** `setCarve` awaits group creation, which live-patches `data-audio-group` and calls `updateElement` per member — a store notification. React re-renders mid-flight and before the carve attribute is written, so the candidate count collapses 2 → 1 while `carve` is still null and the sibling single-candidate effect fires a SECOND concurrent `setCarve`: two read-modify-write saves of `data-fx-carve` against one file (lost update) and two analyse() runs — two decodes, two FFT passes, two competing chain/automation writes. One in-flight latch now guards both effects, applied only to AUTO decisions: a manual change from the panel stays interruptible. **Tail — the prune never ran for a group bed.** Its "is the timeline loaded" sentinel was `present.has(element.id)`, and a group is not a timeline element, so a bus carrying its own carve always bailed. It now accepts either proof. `useFxCarve.ts` would have gone to 619 lines, so the compile half — `mintCarveNodes`, `measureCarve`, `carveLanes`, `carveLaneFor` — moved to `useFxCarveNodes.ts` first. 580 -> 442 + 153, both under the cap, and the split is the natural one: that half is pure, the hook keeps effects and persistence. Three tests for 9, each verified against a revert. studio: 390 files.

… way back Review findings 8, 12, 13. **12 — the reveal was dead in BOTH halves,** which is why nobody caught it: each half hid the other. - *Not already selected.* `openClipFxRack` raises the request and then selects the clip asynchronously, so the selection landed AFTER and `setSelectedElementId` cleared `revealedAudioFxTarget` — the very request that caused the selection. The clear now spares a request whose `elementKey` is the element being selected; any other selection still drops it, because a request aimed elsewhere is stale. - *Already selected.* `FxSection` consumed with `useState(revealTarget ?? null)`, so `consumedReveal` initialised EQUAL to the request and the `!==` never fired — and a second click on the same lane was byte-identical, so also inert. It now consumes by nonce, initialised null, which is what `PropertyPanelFlat` already does for the same hazard and for the same reason. `propertyPanelAudioFxGroup` forwarded `automationTarget` and dropped the nonce; it forwards both now. **13 — an unescapable node id took the panel down instead of failing quietly.** `revealRowSelector` interpolated chain strings straight into `querySelector`. `parseAudioFxNode` accepts any non-empty string as an id and `parseAutomationTarget` only splits on `.`, so a hand- or LLM-authored chain can carry `a"]` — and the throw escaped a render-phase effect. Now escaped with the repo's own `escapeCssString` (which `findElementForTimelineElement` uses for exactly this) and wrapped, so a malformed selector returns false, which is the documented "row not mounted yet" contract. **8 — a hidden group had no way back.** The panel's visibility toggle is withheld for any audio selection, and the group header carries no visibility control now that mute and solo are gone — so a `data-hidden` bus was silent in preview (the bus's mute gain) and absent from the render (every member dropped), recoverable only by hand-editing the HTML. It is now offered while hidden, the same door-from-the-inside `TimelineTrackPlainHeader` keeps for an audio TRACK after the identical trap was diagnosed there on this branch. That fix needed a second one to work: `selectedElementHidden` derives from `timelineElements`, and after 0e86e64 a bus is not one — no timeline row, no `hidden` flag. `isSelectionHidden` falls back to the element's own attribute. `clearRevealedAudioFxTarget` is now called on unmount, closing a "left open" item in the PR body. The whole reveal consumption moved to `useAudioFxRevealSection.ts` because PropertyPanelFlat crossed 600 — the hook holds all three hazards (currency, nonce, retirement) instead of restating them at the call site. studio: 103 editor files, 1276 tests. fallow clean.

The previous commit's store guard was silently never true. A reveal request carries the BARE dom id — `revealElementId = runtimeAudioId(keyframeClip)`, because the panel and the runtime speak that — while the store's ids are `sourceFile#domId`. So `elementKey === id` compared "music-bed" against "index.html#music-bed" and the request was still cleared by its own selection. This is the id-space boundary the branch's own handoff names as the trap most likely to be re-broken, and it fails exactly as documented: no error, the feature just never matches. Caught only by driving the real UI — the store said `selected: "index.html#music-bed"` and `revealSurvived: null` in the same read. `revealTargetsSelection` now splits the key with the existing `splitTimelineElementKey` and is a named function in `playerStoreSelection.ts` so the crossing is stated once, where it happens. **Verified in the browser, both halves, which had never been watched working:** - clip NOT selected: clicking a lane label selects the clip, the rack opens, and the carve module expands (correct — that lane's node is a carve band). The request is consumed and retired to null by the new unmount clear. - clip ALREADY selected: collapsing the module and clicking the same lane again reopens it, which the old value-equality consumption could not do. studio player: 103 files, 1355 tests. fallow clean.

…sub-comp members Review findings 15 and 14. **15 — the unwind restored the value it was supposed to undo.** `previousValue` came from `readLive()`, but every live-write caller patches the DOM BEFORE committing: a fader drag is `setLive` per frame, hovering a preset auditions the whole chain. So by commit time the live DOM already held the in-progress value, `previousValue === value`, and the unwind was a no-op — and `setQuiet`'s catch, which deliberately re-mirrors the store off the live DOM, then mirrored that same never-saved value. The group audibly had the preset, the panel agreed, and a reload dropped it. It reads the value out of `before` — the file content the target check just fetched — with `readAttributeByTarget`, which is file truth. `readLive` is gone from the input shape: it existed only for this, and leaving it would invite the same mistake back. Both callers drop it. **14 — the mirror was a no-op for a group declared in a sub-composition.** Those members never enter the flat store (`childGroupState` keeps them out), so their `audioGroup*` fields come from the `DomClipChild` record — and `syncStoredGroupAttribute` only mapped `elements`. The header kept the pre-write chain, its FX button showed the old count, and `laneCount` stayed 0 so the lane disclosure never appeared for automation that now existed. Verbatim the symptom that function's own docblock claims to have fixed, fixed only for flat members. It now writes both, and only touches `domClipChildren` when the group actually has one (no notification for the common flat case). Two tests, each verified against a revert. studio: 390 files, 4389 tests. fallow clean.

…e render Review finding 1, the last of the fifteen. A group's identity was the raw author `id`, which is unique only per composition FILE — and the render document is the inlined union of every file. So a sub-composition declaring a bus AND its members, used twice, put both instances' members under one key: one sub-mix for two independent buses, and the second bus element overwrote the first, applying its fader, chain, label and automation to the first instance's audio. With only the SECOND instance muted, `memberGroupHidden` dropped every member of the merged group — both instances gone from the export. Compiled a twice-used sub-composition to find out what actually separates the two instances, rather than guessing: - members are ALREADY disambiguated — `data-hf-render-id="m1"` / `"m1__hf2"` - buses are not: `MEDIA_SELECTOR` is `video[src], audio[src], img[src]` - both instances carry `data-composition-id="bedcomp"`, the file's own id, so id strings cannot tell them apart — only the subtree element can Fixed at the boundary that already owns this collision class. `assignMediaRenderIds` now stamps every `<hf-audio-group>` with a document-unique `data-hf-render-id` from the SAME `taken` set (so a bus key can never collide with a clip key either), and stamps each member with `data-hf-group-render-id` = the render id of the bus in its OWN composition subtree, resolved with `closest()`. A member whose bus is not in its subtree — a hand-authored bus in the root with members in scenes — falls back to the first, which is the pre-existing reading and the only sensible one there. `resolveAudioGroups` and the mixer prefer the stamped key and fall back to the author id, so the LIVE PREVIEW — which has no stamps — reads exactly as before. `resolveGroupElement` tries the stamped instance first, since `getElementById` can only ever find the author id. Verified with the reviewer's own repro, end to end through the real compiler: before, `parseAudioElements` returned both members under one `bed` group; after, muting instance B drops only B's member and A survives at its own 0.5 fader. Two compiler tests (instance pairing, single-instance stability, element-less group untouched) and two mixer tests, all verified against a revert. **Still divergent, deliberately: the live preview.** `groupInput` resolves by id against the uncompiled document, so two instances still share one bus there. The export was the audible bug — a muted instance silencing another's audio — and fixing preview needs runtime subtree resolution, which is a separate change. core 2493, engine 1617, studio 4389. fallow clean.

…p row collisions Four confirmed tail findings from the review. **The label column had no canary gate** while the group ROWS it exists for do. Un-enrolled — everyone, the canary is at 0% — any composition carrying `data-audio-group` got a permanent 232px `LABEL_COL_W` shift of every clip with no group row on screen to explain it. Now gated identically; the two must agree. **Keyboard expandability disagreed with the header.** `expandable: lanes.length > 0` against the header's `lanes.length > 0 || automationRows.length > 0`, so an audio track whose only disclosable content is AUTOMATION drew the `∿` while reporting itself unexpandable to the treegrid — ArrowRight could not open it. Both the flag and the `expanded` gate now count automation rows the same way the header does, per shared PROPERTY rather than per clip. **Sub-composition child rows could land exactly on a group anchor.** A group row anchors at `firstMemberTrack - 0.5`, and the child scheme `k / (n + 2)` hits 0.5 dead on for a host with two children (2/4) — a duplicate row key and a duplicated group header. Children are now confined to the LOWER half of the gap (`0.5 * k / (n + 1)`, maximum strictly under 0.5 for every n), which keeps every property the old scheme had — non-integer, distinct, ordered, under the host — and cannot reach x.5. Test asserts the invariant across 1, 2, 3, 4 and 7 children rather than pinning the fractions. **The timeline FX popover emitted a `preset_applied` per audition.** It called `applyPresetToChain`, which fires `trackPresetApplied` on every call, so hovering or arrowing a 12-preset shelf reported 12 applies and the numbers could not tell an audition from a decision. It now auditions through the raw apply and reports `trackPresetAuditioned`, the split `FxSection` already makes. **Also: the group panel's signal path went stale on a membership change.** Its memo was keyed on `[element]` alone, and membership is held by the MEMBERS — so a clip joining this group changed neither `element` nor its attributes and the path kept claiming "OUT to mix". Keyed on the store's element array too, whose identity both `syncStoredGroupAttribute` and `updateElement` replace. **One tail item examined and REJECTED:** "Hide all" being withheld for a whole mixed selection when one member is audio. Hiding only the visual members is precisely the act-on-a-subset pattern this branch refuses elsewhere (see `canGroupWholeTrack`: "The button is withheld instead of acting on a subset"), and for audio `data-hidden` is mute, so a partial apply would silence nothing while looking like it had. Current behaviour is consistent; left alone. studio: 207 files, 2632 tests. fallow clean.

…ll cleanups **Group lane labels drifted off the curves they name.** The labels iterated raw `elementAutomationLanes` while the curves and the reserved height both use `groupAutomationLanes` — deduped by property and filtered for resolvability — and the old `if (!parts) return null` consumed an index without drawing a row. So one unresolvable target slid every later label one row off its own curve. Both sides read the same source now, and the label takes its name and parameter from the group entry rather than re-deriving them (the second of the two duplicate `automationLaneLabelParts` calls the review counted). **`useEffectiveTimelineDuration` restated `getEffectiveTimelineDuration`** with weaker guards: no non-finite check on the stored duration or the result, so an element carrying NaN timing returned NaN and every downstream width became NaN with it. It delegates now. **`createStableContext` warns on a genuine name collision.** Two modules asking for one name silently share ONE context, so a provider's value is read by the other's consumers and the symptom appears far from either file. Told apart from an HMR re-evaluation by the default value: a re-evaluated module registers the same default, a collision does not. **Documented that `groupNormalizeOptionUnsupported` is live, not dead regex.** A review pass claimed the `amix` normalize fallback could never match; ffmpeg 8.1.1 emits `Error applying option 'X' to filter 'amix': Option not found`, which the second test matches. Verified against the binary, and the comment now says so with the one wording that would miss (pre-4.4 libavfilter, which predates `normalize` existing). **Left alone deliberately:** the leftover wrapper `<div>` in `PlayerControls`. It is genuinely redundant — `PreviewPane` supplies its own flex wrapper — but removing it is a pure-cosmetic JSX re-indent of a 300-line component with no test that would catch a mistake, which is a bad trade against the rest of this batch. Noted for whoever is next in that file. studio 1356 player tests, engine grouping 11. fallow clean.

`syncAudioGroupMute` ran a whole-document `querySelectorAll("hf-audio-group")` on every visibility pass — which is every transport tick that changes anything — to compare each bus's `data-hidden` against a WeakMap that almost never disagreed. The reschedule immediately above it is dirty-gated for exactly this reason; this one was not. Same shape now: a flag set only where a `data-hidden` mutation is observed, and initialised true so the first pass still establishes the baseline. core: 80 init tests. fallow clean.

The router's audio rows still described the pre-bus feature — "automation envelopes on a track", "track gain/volume" — so a request like "one compressor across all four narration tracks" matched no row and fell through to a generic creation workflow. Both the domain row and the creator-edit row now name the submix bus. `CLAUDE.md` and `README.md` already carry it from the skill commit; only the routing surface was stale. Nothing else in CLAUDE.md's sync set changes: the skill's own `description:` is unchanged, and the docs pages and CLI templates only NAME the skill. `gen-skills-manifest --check` passes.

Same trap as before: the pre-commit hook regenerates the manifest for a skill file it sees staged, but this edit landed in skills/hyperframes/SKILL.md via a commit that staged only that file, and the hook's own regeneration is what the CI gate compares against. Verified with --check.

GitHub delivered no `pull_request.synchronize` event for the 22 commits between cc0e37a and fcc11dd — the CI workflow is active, the remote tip is correct, and other branches got runs in the same window, but `actions/runs?branch=wa-25-review-fixes` has nothing newer than cc0e37a. An empty commit is the traceable way to ask for the events again; closing and reopening the PR would do it too but leaves a worse record.

The three audio canaries (`audio-fx-rack`, `audio-track-mute`, `audio-groups`) sat at 0% while the stack was in review. Open them to 100% by deleting them rather than raising the percentage — a canary that gates nothing is a branch every future reader has to evaluate. Removed: - the three `CANARIES` registry entries; - every `isCanaryEnabled` branch in the studio (FX button, group pointer, rack section, track-mute affordances) — the features now render on their own preconditions; - the runtime's `canaries` record and its `__hf.setCanaries` handler, plus the `setCanaries` type surface; - `syncRuntimeMedia`'s `silenceHiddenAudio` option. Its only caller always passed `true`, so hidden audio is now unconditionally silent in preview, matching what `audioMixer` already renders. Tests assert the unconditional behaviour instead of the enrolment transition: the FX button is present on any audio track and absent on a visual one, the group pointer follows clip count rather than enrolment, and the hidden-clip zero is paired with a visible-clip control so the assertion can still fail.

A music bed came out carved twice. The `music` bus carried three `fromCarve` peaking filters against `voiceover`, and its one member clip `bgm` carried six of its own — the bed ran through both. Same on the SFX side: the `sfx` bus plus `sfx-pan-2`. **The bus classified as a bed.** `useFxCarve` is shared — a group's rack reaches it too (`propertyPanelAudioFxGroup.tsx`, and the comment there says so) — and `carveBedRoles` reads `data-label` so that a name living outside a filename still counts. A bus labelled "Music bed" therefore read as music: `couldBeBed` offered it the control and `autoBed` wrote one without being asked, entirely independently of the member clip that had already done the same. Nothing caught the collision, because the only guard, `carverAgainst`, asks "is somebody naming ME as a source" — never "is my own bus, or my own member, already carved". **And a bus cannot carve properly anyway.** The level half of the analysis measures the bed's own audio against the voice, read from `element.getAttribute("src")`. A bus has no `src`, so `bedBuffer` was null, `duck` was empty, and every bus carve was the spectral half alone: filters and no level match. That is exactly the shape found in the file — three peaking nodes and no gain node on the bus, five and a gain on the clip. So `carveBedRoles` now refuses a bus outright, both halves: `couldBeBed` false alone would still leave `autoBed` free to fire off the label, which is the half that wrote these. An already-configured bus carve still shows its module (`carve !== null`), so it can be switched off rather than becoming unreachable — the same escape hatch a387850 kept. `audio_group_carve_attr` names what is already written down, since the Studio fix cannot unwrite it. Warning, beside `audio_group_timing_attrs`, which is the same shape of mistake: an attribute a bus has no use for. The skill has said "a carve stays on the clip" since the bus was documented; it now says why, and says not to wrap a single clip in a bus at all — with the one real exception, which is wanting a composition-time automation clock. Both guards mutation-checked: dropping the tag check fails the Studio test, and `if (false)` in place of the attribute check fails both quiet cases.

Three complaints, one cause each. **Handles appeared on a lane nothing could move.** A carve's lanes are read-only — a re-run rewrites them, so an edit there is lost work — but they still lit their point handles on hover like every other lane. The report was "I lost the ability to drag automation points": the affordance was the whole promise, and it was false. `pointHandleOpacity` now keeps them hidden unless the lane is actually editable, while a drag or a selected range still shows them, because those states are the ones where the handles are the feedback. **Nothing said why.** Hiding the handles alone turns a lie into a mystery. Hovering a read-only lane now shows a note inside it, and for a carve lane the note says where the control actually is — the strength knob in the FX rack, or switching the carve off to take the envelopes over by hand. **Group lane labels scrolled away.** The group header was sticky and its lane labels were not, so the labels slid under the curves while the header stayed. They are one column and now live in one sticky wrapper. Wrapping only the labels is what the first attempt did, and it is wrong: as a flex item after the header the wrapper starts at `x = columnWidth`, so at scroll 0 the labels render inside the lane area — which is what the screenshot caught. The lane title is now `laneTitle()` and the note `ReadOnlyNote`, which is what keeps the file under the complexity gate.

Selecting an audio bus showed a Motion section offering tween editors. A bus has no transform, opacity or box, so every effect on that list moves nothing; the same is true of an `<audio>` clip. The panel's gate was "are the GSAP handlers wired", and `App.tsx` always wires them, so it was true for every selection. It now also asks what was selected. Audio keeps its timing — an `<audio>` clip is placed on the timeline like anything else — but the section is called Timing there and summarises its span instead of an effect count, because "Motion: 0 effects" on a sound is a category error. A bus loses timing too: it has no `data-start` and no duration, and its automation clock is composition time, so Start / Duration / End would be editing nothing. Gated on the TAG, not on `sections.animation`: a `div` with no tweens yet must still offer "+ Add", and keying the rename on `animationCount > 0` renamed the section for exactly that div — which the existing panel test caught. Keying it on `showMotionEffects` renamed it for an `img`, which wires no GSAP handlers. Both halves belong to the tag. `affordances.ts` carries the same two rules for anything reading the section list rather than the flat panel. The label pair is `motionSectionLabel`, in the module that owns the section it names, which is also what keeps `PropertyPanelFlat.tsx` under the 600-line ceiling.

Twelve of the stack's feature commits landed on main as squashes (#3274 through #3292, plus #3401's canary removal); the 96 review-and-fix commits that followed them here did not, and main moved 64 commits on in the meantime. This reconciles the two. 58 files conflicted. 44 were audio-only — main's side there is the squashed form of commits this branch already carries and has since superseded, so the branch side stands. The rest needed real work, in both directions: **Taken from main, absent here.** - `ensureAudioGroupInertStyle` (#3278's review). An `<hf-audio-group>` is an unknown custom element, so it still takes a flex/grid slot and can open a line box — adding a group shifted authored layout. The helper and its `init.ts` call never came back to the branch, and this branch is what emits the element. - `#3383`'s ended-audio replay: `canSeekEndedMediaBackward` and its five siblings in `media.ts`, with all six tests. Not present here in any form. - `#3380`'s `asetpts=N/SR/TB` between `apad` and `atrim`. Also applied to `mixGroupMembers`, the group submix, which is new on this branch and so had the same bug in a path main's fix could not reach: delayed members padded then amix'd, where a group of four or more silently loses one. - `#3401`'s `displayNumber` thread. The header derives its row from the group-aware order and the undo label from ascending element keys, so once a group exists the same click said "Hide track 2" and recorded "Hide track 1". - `#3413`/`#3421`'s viewport handling — the popover's height cap and `inset()`, and `resolveFloatingPanelPosition` for the grouping dialog, which lives in a track header at the bottom of the window. - Two extractions this branch had inline and at exactly the 600-line cap: `useTimelineDeleteOps` and `editingModeSlice`. Bodies were identical. **Kept from the branch, against main.** Mute and solo are gone by deliberate breaking change (`remove mute and solo from tracks and groups`, `remove the group volume slider and level meter`), so eight files main still carries are deleted again, `PlayerControls` keeps no `previewIframeRef` (it existed only to feed `SoloBanner`), the group-levels branch comes out of main's new `previewMessageRouter`, and `STRIP_H` goes with the bus strip it sized. Main's `TimelineTrackPlainHeader.test.tsx` is rewritten against the control that actually exists — the visibility eye, withheld from an audible audio row and offered back once hidden, which is the only way out of `data-hidden`. **Unioned.** `TimelineFxPopover` — main's positioning, this branch's audition telemetry (`auditionPresetChain`, `storedChain`, `onAuditionTracked`); `SKILL.md` — main's #3416 "keep the carve group a voice group" beside this branch's bus section, with the canary paragraph dropped since the canaries no longer exist. Every port is mutation-checked. core 2508, studio 4460, lint 528, engine 1630, cli 2813, sdk 549, producer green; tsc, oxlint, oxfmt, fallow and the 600-line cap clean.

vanceingalls and others added 30 commits August 20, 2026 16:39

vanceingalls added 17 commits August 20, 2026 16:41

fix(audio): harden group routing and audition

44c5ac5

vanceingalls closed this Aug 23, 2026

Navigation Menu

Uh oh!

feat(audio): effect chains, automation, voiceover carve and submix buses - #3439

feat(audio): effect chains, automation, voiceover carve and submix buses#3439
vanceingalls wants to merge 110 commits into
mainfrom
wa-25-review-fixes

vanceingalls commented Aug 23, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Uh oh!

Conversation

vanceingalls commented Aug 23, 2026

What ships

Fixes from the last session

The merge

Verification

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant