Skip to content

Commit df29fa7

Browse files
feat(studio): revamps Studio + improves code quality (#2291)
* feat(studio): glue API coexistence layer for the NLE swap What: extends 21 glue files so the OLD timeline/canvas engine and the NEW NLE components type-check side by side: playerStore (multi-select setters, zoom pin, snap toggle, non-reactive scale scratch), drag-state types gain optional NLE fields, timelineLayout/timelineAssetDrop/timelineEditingHelpers/ timelineEditing/timelineElementHelpers/studioHelpers/assetHelpers gain the NLE exports, DomEditOverlay + gestures + AssetContextMenu + Timeline props gain optional callbacks/params, contexts gain *Optional hooks, and TimelineEditCallbacks.onMoveElements becomes a bivariant method accepting both engines' change shapes. patchDocumentRootDuration's test rides along. Why: this is the keystone that dissolves the old "welded glue" problem — every symbol the NLE components need is ADDED next to what the old engine still uses, so the engine components and the swaps can land as separate reviewable PRs. How: 15 authored intermediate files (main content + additive symbols; no behavior changes — new fields optional, new callbacks unused until wired) plus 6 files whose final content is already purely additive. New exports without consumers yet carry TEMP(studio-dnd) ignoreExports entries, removed by the app-shell swap. Test plan: tsc --noEmit in studio + studio-server (verifies BOTH engines compile); bunx vitest run (full suite green incl. the 6 new patchDocumentRootDuration tests); fallow audit clean. * feat(studio): timeline interaction hooks and lanes component (unwired) What: the timeline-side wiring layer, unwired: TimelineLanes (the lane renderer driving drag/resize/marquee), timelineMarquee (+tests), useTimelineStackingSync, useTimelineGeometry, useTimelineEditPinning, useTimelineEditingDrops. Why: everything between the pure drag math and <Timeline> itself; the timeline-glue swap PR then only rewires Timeline/TimelineCanvas onto these. How: new files, tsc-clean against the coexistence layer. Unwired components carry TEMP(studio-dnd) entry registrations, removed at the app-shell swap. Test plan: bunx vitest run timelineMarquee.test.ts; tsc --noEmit; fallow audit clean. * feat(studio): NLE shell assembly (unwired) What: EditorShell (the full editor layout replacing NLELayout + StudioPreviewArea), TimelinePane (timeline host with sub-comp rebasing) and useTimelineEditCallbacks (the callback bag bridging store edits to the timeline), all unwired. Why: the shell that App swaps to in the final step; reviewing it standalone keeps that swap PR small. How: new files against the coexistence layer; TEMP(studio-dnd) entries until App mounts EditorShell in the app-shell swap. Test plan: tsc --noEmit; bunx vitest run (suite unchanged); fallow audit clean. * feat(studio): timeline glue swap — Timeline/TimelineCanvas onto the NLE engine What: flips the timeline glue to its final form (23 files): Timeline and TimelineCanvas rebuilt on TimelineLanes/TimelineOverlays, useTimelineClipDrag drives preview/commit through the new drag engine, range selection goes multi-select, playback loop moves to useTimelinePlayerLoop. Deletes the 9 old-engine files this orphans (group drag, marquee selection, snap targets, layer gutter, selection overlays + their suites) — each is compile- or gate-forced by this swap, verified by probe. Why: second swap step; timeline-only, canvas and App untouched. How: modified files to final content + forced deletions. playerStore/timelineEditing/timelineCallbacks stay at their coexistence form until the app swap (the old App still runs on them). Test plan: tsc --noEmit; bunx vitest run (full suite); fallow audit clean. * feat(studio): clip thumbnail modules What: ImageThumbnail (+tests) and thumbnailUtils (+tests) — frame decode with SVG/AVIF format fallbacks and rounded-corner clipping — plus VideoThumbnail updates. Why: the decode layer for timeline clip thumbnails, ahead of the visual refresh that renders them. How: new modules + one modified file; purely presentational. Test plan: bunx vitest run on both test files; tsc --noEmit; fallow audit clean. * feat(studio): assets/blocks panel behaviors + preview helpers What: blocks tab install flow, right-panel and global drag-overlay polish, music beat analysis and clip-content rendering hooks, and the preview-helper utilities backing asset preview. Why: completes the studio NLE stack on top of the visual refresh. How: modified files only (kept as one PR: splitting further would produce sub-150-LOC fragments of interdependent panel glue). Test plan: bunx vitest run studioPreviewHelpers/studioUrlState suites; tsc --noEmit; fallow audit clean. * fix(studio): restore timeline playback loop * fix(studio): restore missing GSAP helpers module * refactor(studio): split timeline GSAP helpers * style(studio): keep timeline helper under size limit * fix(studio): restore timeline overlays module * fix(studio): remove stale GSAP import * fix(studio): restore canonical timeline dependencies * style(studio): format restored timeline helpers * style(studio): satisfy helper line limit * fix(studio): repair rebuilt timeline integration * feat(studio): complete rebuilt NLE cutover * fix(studio): guard project and timeline race boundaries * fix(studio): preserve graded resize and crop geometry * fix(studio): log resize/rotate commit failures, move anchor accumulator to resize-local * fix(studio): treat duration-0 tweens as static holds and settle resize position before persist Instant holds (to()/fromTo() with duration 0) were classified as animated tweens by every commit route, so resizing or rotating them converted the hold into a corrupt duration-0 keyframes tween (new value at 0%, old at 100%) that GSAP drops; panel edits appended a losing set. A shared isInstantHold() now routes them through the static replace-in-place path, and percentage math guards zero-duration windows. Separately, anchored-corner resizes painted 3-5 frames at the new size but old position while the offset persist round-tripped the server. The commit path now applies the corrected GSAP position synchronously before awaiting the offset persist, mirroring the scale route's settle. * feat(studio): gesture-transaction seam with commit observability Introduce runGestureTransaction — one owner for a gesture commit's settle -> persist -> record lifecycle. It settles the live DOM synchronously before any async persist, folds every mutation into one undo entry via a per-transaction coalesceKey, restores pre-gesture state exactly once on failure, and asserts (dev console) + reports (PostHog: commit_transaction / commit_invariant_violation / commit_transaction_failed) that a persist never changes pixels. The box-size resize path is migrated onto it; the ad hoc per-route coalesceKey/reload handling is removed. Extract the resize draft-rect math into resizeDraft.ts to keep the gesture-handler file under the size cap. Also: keep url_hash telemetry to the route slug only (drop the query string, which carried the user's selected element id/selector), and gate the [hf-resize] diagnostics behind localStorage hf-resize-debug so they ship as opt-in tracing rather than console noise. * fix(studio): transaction owns the undo label The coalesced history entry took the last sub-mutation's label, so a resize surfaced as "Move layer" (the offset persist) in undo/redo. The seam now stamps tx.label on every wrapped mutation, so the folded entry reads as the gesture. * fix(studio): atomic static size/position commits (no data loss) Static resize/position holds updated an existing set via delete+add — two undo entries, and a delete that succeeded before a failed add lost the hold on disk. Use one in-place update-properties mutation when a set exists (one undo entry, no partial-failure window). The keyframed-hold heal that can't be expressed as a property update now adds before it deletes, so any single failure leaves a recoverable duplicate, never a lost hold. Transaction-owned commits are tracked via a WeakSet so the heal path never double-wraps an already-wrapped gesture. * fix(core): restore timed-clip visibility after a forced timeline rebind __hfForceTimelineRebind force-rendered the re-registered timeline but never re-ran the per-[data-start] visibility pass, so after undo or soft reload every clip rendered regardless of its time window until a full page reload. Extract the visibility loop into syncTimedElementVisibility and call it from both syncMediaForCurrentState (unchanged) and the rebind. * fix(studio): atomic z-order/keyframe/split commits, one undo entry each Three edit-commit paths hardened onto the one-transaction invariant: - Z-order reorder (useElementLifecycleOps): N per-element writes now fold into one undo entry (coalesceMs Infinity) and, on a failed persist, restore already-written files to disk so no partial reorder survives. - Enable-keyframes (useEnableKeyframes/useGsapKeyframeOps): the intermediate convert phase no longer full-reloads the preview (skipReload), killing the black-flash remount; convert + edit share one coalesce key = one undo entry. - Razor split-all (useRazorSplit): snapshot before the batch and restore on any failure, so a mid-batch error never leaves un-revertable partial splits. Shared file-history helpers (RecordEditInput, DomEditCommitBaseParams, readProjectFileContent, restoreFilesToOriginal) dedupe the rollback/commit logic across these paths. Commit options thread as one partial object rather than field-by-field. Test setup extracted into colocated helpers. * fix(studio): fold multi-step edits into one undo entry; guard text revert - Gesture recording (useGestureCommit): the per-property-group commits now share one coalesce key and only the last reloads, so a recording is one undo entry and one preview reload instead of up to four. - Delete selected keyframes (deleteSelectedKeyframes, split out of timelineEditingHelpers): N removals fold into one coalesced undo entry with a single reload. - Text-field commit (useDomEditTextCommits): commitDomTextFields now uses the same version-guarded revert as handleDomTextCommit, so a stale failed commit can no longer stomp a newer successful one. * feat(studio): batch a gesture's mutations into one atomic server write A transaction that emits N mutations previously did N sequential POSTs, each rewriting the file and soft-reloading — the root of the multi-phase persist window. Add a gsap-mutations-batch endpoint that validates every mutation up front, applies them in one in-memory rewrite chain, and writes the file once (all-or-nothing: an invalid entry rejects the whole batch, no partial write). The seam buffers a transaction's commits and, when more than one targets the same file, dispatches a single batch — one write, one history entry, one reload. The batch capability rides on the existing commit-function reference; no option fields are threaded through callers. * fix(studio): soften off-canvas indicator outline to 30% opacity The dashed off-canvas selection outline at 60% was noisy with many protruding elements on screen; drop the resting opacity to 30% (hover still restores full opacity so it stays discoverable). * fix(studio): drop off-canvas indicator outline to 10% opacity Follow-up to the 30% softening — 10% resting opacity reads much calmer with many protruding elements; hover still restores full opacity. * fix(studio): gate [hf-commit] console traces to dev only The start/settled/persisted/restore lifecycle traces logged on every gesture commit in all environments — console noise for end users. Route them through a dev-only traceCommit helper (matching the pixel-violation error's existing DEV gate). The commit_* PostHog events stay always on; they are the production observability, the console lines are a dev aid. * fix(studio): count actual reloads, not softReload requests, in commit telemetry A resize's size and offset persists both request softReload; the seam counted each request, so a batched gesture reported reload_count 2 even though the batch is one write and one reload. Compute the count from what dispatchBufferedCommits actually did — one for a batch, the request count for the sequential fallback. * fix(studio): rotate hover + off-canvas overlays with the element; flicker-free crop - Hover overlay applied the element's rotation only to the selection chrome, not the hover box; it now rotates about center like the selection, via a shared orientedGroupAwareOverlayRect router (one owner for rotation-aware overlay geometry across hover/selection/off-canvas). - Off-canvas indicator was axis-aligned; it now rotates with the element and inverse-rotates the canvas-exclusion clip into the element's local frame, so the protruding-sliver clip stays correct for rotated elements. - Crop commit re-lifted the element only in the commit's .then(), so one frame painted the cropped state (the flicker). Re-lift synchronously right after onStyleCommit (which applies the clip before its first await), so the cropped state never paints; the persisted file value is unchanged. * fix(studio): address code-review findings across the commit-hardening campaign Correctness (would ship green, bite under latency): - Enable-keyframes phase 2 now carries coalesceMs: Infinity, so the convert folds into one undo entry instead of splitting past the 300ms default. - The SDK keyframe persist path forwards coalesceMs (CutoverOptions gains the field); multi-keyframe delete and convert coalesce correctly when SDK-routed. - Razor split-all's rollback is guarded so a failing restore can't swallow the error toast that tells the user the split failed. Simplification (single source of truth / no dead flexibility): - Decompose resolveResizeDraftRect (drops a fallow-ignore suppression). - Delegate the third readProjectFileContent copy to the shared helper. - Inline setPatchFromUpdateProperties (its only caller passes one mutation). - One toSdkPersistOptions translates gesture overrides to SDK options. - Bundle the reorder-rollback deps into one object (was 7-9 positional args). - Dedupe the 'last group reloads' ternary; type gesture options as CommitMutationOptions; drop a Map+array wrapper around a single write. * feat(studio): atomic z-order reorder via batch patch-element endpoint Z-order reorder issued N per-element inline-style patches (one server write each), so a mid-chain failure could leave a partial reorder on disk. Add a patch-elements-batch endpoint that validates every patch, folds them over the file in one in-memory rewrite, and writes once (all-or-nothing; unsafe input rejects with no write). The reorder now sends one batch per source file and records one undo entry. Because a failed atomic write persists nothing, the interim disk-write-back rollback (restoreReorderedFile / restoreFulfilledReorderFiles / ReorderRollbackDeps) is deleted — failure rolls back only live DOM/store state. Closes the last disk-atomicity gap. * fix(studio): razor-split undo no longer silently no-ops The split clone was written to disk without a data-hf-id, so the split endpoint recorded that unstamped HTML as the undo entry's afterHash. The next reloadPreview() ran the preview route's ensureHfIds write-back, which minted a fresh id and persisted DIFFERENT bytes — so at undo time the disk hash no longer matched afterHash and editHistory's content-mismatch guard silently refused the undo (no write, no network, no error). Stamp the split output via ensureHfIds in splitElementInHtml before it is written/returned, so the preview write-back is a no-op and the recorded afterHash always equals the final on-disk bytes. Fixes at the source rather than relaxing the mismatch guard. Corrects the stale comment that credited forceReloadSdkSession. * feat(studio): closed-hand grab cursor on the rotate handle The rotate handle used the default arrow cursor; show a grabbing (closed-hand) cursor on hover to signal it's grabbed and dragged to rotate. * fix(studio): dropping a dragged element over another no longer selects it A moved drag's release fired the box click, which re-selected whatever now sat under the pointer via the hover cache — so dropping an element over a higher-z one selected the drop target instead of keeping the dragged element selected. The drag-move branch now suppresses the next box click, mirroring the resize branch. * fix(studio): group drag is one undo entry, not one per element Dragging a multi-selected group committed each member's position write as its own undo entry, so reverting took N Cmd+Z presses. Force a shared coalesceKey (infinite window) across every member's commit so they fold into a single undo entry, like the other multi-step commit paths. * fix(studio): undo of a split no longer leaves a ghost clip in the timeline The file and the composition iframe revert correctly on undo, but the timeline panel kept a ghost node for the split clone. The element-merge that repopulates the timeline preserves elements the fresh scan dropped — intended for enriched sub-composition children a bare DOM re-scan misses, but it also preserved a genuinely-removed TOP-LEVEL element (the split clone after undo), leaving a phantom clip. Restrict the preserve to elements with a compositionSrc (the enriched sub-comp children); a top-level element missing from the fresh scan was truly removed. --------- Co-authored-by: ukimsanov <[email protected]>
1 parent 9940503 commit df29fa7

228 files changed

Lines changed: 18761 additions & 7319 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎.fallowrc.jsonc‎

Lines changed: 51 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@
4444
// Keyframe UI components — wired dynamically via EaseCurveSection/MotionPanel.
4545
"packages/studio/src/components/editor/KeyframeDiamond.tsx",
4646
"packages/studio/src/components/editor/SpringEaseEditor.tsx",
47-
// NLE notice — rendered conditionally via NLELayout when timeline is first shown.
47+
// NLE notice — rendered conditionally via NLEContext/EditorShell when timeline is first shown.
4848
"packages/studio/src/components/nle/TimelineEditorNotice.tsx",
4949
// Zoom hook extracted for downstream razor-blade PRs (#1330, #1331).
5050
"packages/studio/src/player/components/useTimelineZoom.ts",
@@ -53,9 +53,6 @@
5353
"packages/studio/src/hooks/gsapTargetCache.ts",
5454
// Preview helper consumed dynamically from the studio iframe bridge.
5555
"packages/studio/src/hooks/gsapRuntimePreview.ts",
56-
// TEMP(studio-dnd): shipped unwired ahead of the NLE integration;
57-
// the app-shell swap PR (studio-dnd/pr22) wires the consumers and removes this block.
58-
"packages/studio/src/components/editor/CanvasContextMenu.tsx",
5956
],
6057
"ignorePatterns": [
6158
"docs/**",
@@ -93,10 +90,52 @@
9390
"packages/cli/src/cloud/_gen/**",
9491
],
9592
"ignoreExports": [
96-
// TEMP(studio-dnd): consumers land later in the stack; removed by studio-dnd/pr22.
93+
// Part of useTimelineEditing's inferred public return type; consumers invoke
94+
// handleTimelineGroupResize without importing the change type directly.
9795
{
98-
"file": "packages/studio/src/components/editor/canvasContextMenuZOrder.ts",
99-
"exports": ["readEffectiveZIndex"],
96+
"file": "packages/studio/src/hooks/useTimelineGroupEditing.ts",
97+
"exports": ["TimelineGroupResizeChange"],
98+
},
99+
{
100+
"file": "packages/studio/src/player/components/timelineGroupEditing.ts",
101+
"exports": [
102+
"buildTimelineGroupResizeMembers",
103+
"resolveTimelineGroupResizeChanges",
104+
"applyTimelineGroupResizePreview",
105+
],
106+
},
107+
{
108+
"file": "packages/studio/src/player/components/timelineEditing.ts",
109+
"exports": [
110+
"selectTimelineElementsInMarquee",
111+
"TimelineGroupResizeEdge",
112+
"TimelineGroupTimingMember",
113+
],
114+
},
115+
{
116+
"file": "packages/studio/src/player/lib/timelineElementHelpers.ts",
117+
"exports": ["furthestClipEndFromDocument", "furthestClipEndFromSource"],
118+
},
119+
{
120+
"file": "packages/studio/src/components/sidebar/AssetContextMenu.tsx",
121+
"exports": ["DeleteConfirm"],
122+
},
123+
{
124+
"file": "packages/studio/src/utils/timelineAssetDrop.ts",
125+
"exports": [
126+
"setCompositionDurationToContent",
127+
"extendCompositionDurationIfNeeded",
128+
"fitTimelineAssetGeometry",
129+
"resolveTimelineAssetCompositionSize",
130+
],
131+
},
132+
{
133+
"file": "packages/studio/src/components/sidebar/assetHelpers.ts",
134+
"exports": ["truncateMiddle", "formatDuration"],
135+
},
136+
{
137+
"file": "packages/studio/src/utils/studioHelpers.ts",
138+
"exports": ["resolveDroppedAssetDimensions"],
100139
},
101140
// drawElementService is the bottom of the fast-capture Graphite stack
102141
// (#1917): its consumers (frameCapture in #1919) land two PRs upstack, so
@@ -320,6 +359,11 @@
320359
// and attribute tag-patchers; only the PatchOperation type gained two
321360
// optional fields here, but the line shift makes fallow re-flag them.
322361
"packages/studio/src/utils/sourcePatcher.ts",
362+
// useGsapSelectionHandlers.ts: pre-existing parallel structure with
363+
// useDomEditWiring.ts (thin useCallback wrappers guarding on selection);
364+
// only gained two optional pass-through parameters here, but the line
365+
// shift makes fallow re-flag the pre-existing clone.
366+
"packages/studio/src/hooks/useGsapSelectionHandlers.ts",
323367
// gsapParser.ts: recast/babel GSAP writer — intentional duplication between
324368
// recast and acorn parallel implementations (pre-existing, moved from core).
325369
"packages/parsers/src/gsapParser.ts",
@@ -441,13 +485,6 @@
441485
// complexity pre-dates the computed-timeline work. Exempted at file level
442486
// rather than refactored as scope creep.
443487
"ignore": [
444-
// TEMP(studio-dnd): coexistence-window complexity flare (inherited/CRAP-no-coverage);
445-
// removed by studio-dnd/pr22 when the final config lands.
446-
"packages/studio/src/player/hooks/useTimelineSyncCallbacks.ts",
447-
"packages/studio/src/components/editor/CanvasContextMenu.tsx",
448-
"packages/studio/src/components/editor/canvasContextMenuZOrder.test.ts",
449-
"packages/studio/src/player/components/timelineCollision.test.ts",
450-
"packages/studio/src/player/components/timelineStackingSync.test.ts",
451488
// sourcePatcher.ts: resolveSourceFile / splitInlineStyleDeclarations /
452489
// patch*InTag pre-date this PR; only the PatchOperation type gained two
453490
// optional fields, but the line-shift fingerprint re-flags the inherited
@@ -587,14 +624,12 @@
587624
"packages/studio/src/components/editor/Transform3DCube.tsx",
588625
"packages/studio/src/components/LintModal.tsx",
589626
"packages/studio/src/components/MediaPreview.tsx",
590-
"packages/studio/src/components/nle/NLELayout.tsx",
591627
"packages/studio/src/components/nle/NLEPreview.tsx",
592628
"packages/studio/src/components/sidebar/AudioRow.tsx",
593629
"packages/studio/src/components/sidebar/BlocksTab.tsx",
594630
"packages/studio/src/components/sidebar/CompositionsTab.tsx",
595631
"packages/studio/src/components/sidebar/LeftSidebar.tsx",
596632
"packages/studio/src/components/storyboard/StoryboardLoaded.tsx",
597-
"packages/studio/src/components/StudioPreviewArea.tsx",
598633
"packages/studio/src/components/StudioRightPanel.tsx",
599634
"packages/studio/src/components/StudioToast.tsx",
600635
"packages/studio/src/components/ui/Tooltip.tsx",

‎packages/core/src/runtime/init.test.ts‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1564,6 +1564,36 @@ describe("initSandboxRuntimeModular", () => {
15641564
expect(seekTimes[seekTimes.length - 1]).toBe(0);
15651565
});
15661566

1567+
it("restores timed element visibility after a forced timeline rebind", () => {
1568+
document.body.innerHTML = `
1569+
<div data-composition-id="root" data-root="true" data-duration="30" data-width="1920" data-height="1080">
1570+
<div class="clip" id="clip-expired" data-start="0" data-duration="15.234"></div>
1571+
<div class="clip" id="clip-future" data-start="20.83" data-duration="3"></div>
1572+
<div class="clip" id="clip-control" data-start="10" data-duration="10"></div>
1573+
</div>
1574+
`;
1575+
const clipExpired = document.querySelector<HTMLElement>("#clip-expired");
1576+
const clipFuture = document.querySelector<HTMLElement>("#clip-future");
1577+
const clipControl = document.querySelector<HTMLElement>("#clip-control");
1578+
window.__timelines = { root: createMockTimeline(30) };
1579+
1580+
initSandboxRuntimeModular();
1581+
window.__player?.seek(16.2);
1582+
1583+
expect(clipExpired?.style.visibility).toBe("hidden");
1584+
expect(clipFuture?.style.visibility).toBe("hidden");
1585+
expect(clipControl?.style.visibility).toBe("visible");
1586+
1587+
if (clipExpired) clipExpired.style.visibility = "visible";
1588+
if (clipFuture) clipFuture.style.visibility = "visible";
1589+
1590+
window.__hfForceTimelineRebind?.();
1591+
1592+
expect(clipExpired?.style.visibility).toBe("hidden");
1593+
expect(clipFuture?.style.visibility).toBe("hidden");
1594+
expect(clipControl?.style.visibility).toBe("visible");
1595+
});
1596+
15671597
it("onSetMuted preserves authored muted attribute on video elements", () => {
15681598
const root = document.createElement("div");
15691599
root.setAttribute("data-composition-id", "root");

‎packages/core/src/runtime/init.ts‎

Lines changed: 60 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -1334,6 +1334,7 @@ export function initSandboxRuntimeModular(): void {
13341334
(window as Window & { __hfForceTimelineRebind?: () => void }).__hfForceTimelineRebind = () => {
13351335
childrenBound = false;
13361336
bindRootTimelineIfAvailable();
1337+
syncTimedElementVisibility(state.currentTime);
13371338
};
13381339

13391340
const emitRootStageLayoutDiagnostics = () => {
@@ -1691,6 +1692,64 @@ export function initSandboxRuntimeModular(): void {
16911692
const dataHiddenDisplayRestores = new WeakMap<HTMLElement, string>();
16921693
const dataHiddenDisplayNodes = new WeakSet<HTMLElement>();
16931694

1695+
const syncTimedElementVisibility = (currentTime: number) => {
1696+
const visibilityNodes = Array.from(document.querySelectorAll("[data-start]"));
1697+
const rootComp = resolveRootCompositionElement();
1698+
for (const rawNode of visibilityNodes) {
1699+
if (!(rawNode instanceof HTMLElement)) continue;
1700+
1701+
if (rawNode.hasAttribute("data-hidden")) {
1702+
if (!dataHiddenDisplayNodes.has(rawNode)) {
1703+
dataHiddenDisplayRestores.set(rawNode, rawNode.style.getPropertyValue("display"));
1704+
dataHiddenDisplayNodes.add(rawNode);
1705+
}
1706+
rawNode.style.display = "none";
1707+
if (rawNode instanceof HTMLVideoElement || rawNode instanceof HTMLImageElement) {
1708+
colorGradingRuntime?.setSourceVisibility(rawNode, false);
1709+
}
1710+
continue;
1711+
}
1712+
1713+
if (dataHiddenDisplayNodes.has(rawNode)) {
1714+
const previousDisplay = dataHiddenDisplayRestores.get(rawNode);
1715+
if (previousDisplay) {
1716+
rawNode.style.display = previousDisplay;
1717+
} else {
1718+
rawNode.style.removeProperty("display");
1719+
}
1720+
dataHiddenDisplayRestores.delete(rawNode);
1721+
dataHiddenDisplayNodes.delete(rawNode);
1722+
}
1723+
1724+
let isVisibleNow = isTimedElementVisibleAt(rawNode, currentTime);
1725+
// Descendants must not override a hidden ancestor clip. CSS visibility can
1726+
// otherwise leak child pixels through inactive scenes because a descendant
1727+
// with visibility:visible escapes an ancestor's visibility:hidden.
1728+
if (isVisibleNow) {
1729+
let ancestor = rawNode.parentElement;
1730+
while (ancestor) {
1731+
if (ancestor === rootComp) break;
1732+
if (ancestor instanceof HTMLElement && ancestor.hasAttribute("data-start")) {
1733+
if (!isTimedElementVisibleAt(ancestor, currentTime)) {
1734+
isVisibleNow = false;
1735+
break;
1736+
}
1737+
}
1738+
ancestor = ancestor.parentElement;
1739+
}
1740+
}
1741+
rawNode.style.visibility = isVisibleNow ? "visible" : "hidden";
1742+
if (rawNode instanceof HTMLVideoElement || rawNode instanceof HTMLImageElement) {
1743+
colorGradingRuntime?.setSourceVisibility(rawNode, isVisibleNow);
1744+
}
1745+
if (isVisibleNow) {
1746+
if (isTimedClipInFlow(rawNode)) rawNode.style.removeProperty("display");
1747+
} else if (isTimedClipInFlow(rawNode) && isTimedClipLeaf(rawNode)) {
1748+
rawNode.style.display = "none";
1749+
}
1750+
}
1751+
};
1752+
16941753
const syncMediaForCurrentState = () => {
16951754
const resolveMediaCompositionContext = (element: HTMLVideoElement | HTMLAudioElement) => {
16961755
const compositionRoot = element.closest("[data-composition-id]");
@@ -1773,61 +1832,7 @@ export function initSandboxRuntimeModular(): void {
17731832
},
17741833
});
17751834
}
1776-
const visibilityNodes = Array.from(document.querySelectorAll("[data-start]"));
1777-
const rootComp = resolveRootCompositionElement();
1778-
for (const rawNode of visibilityNodes) {
1779-
if (!(rawNode instanceof HTMLElement)) continue;
1780-
1781-
if (rawNode.hasAttribute("data-hidden")) {
1782-
if (!dataHiddenDisplayNodes.has(rawNode)) {
1783-
dataHiddenDisplayRestores.set(rawNode, rawNode.style.getPropertyValue("display"));
1784-
dataHiddenDisplayNodes.add(rawNode);
1785-
}
1786-
rawNode.style.display = "none";
1787-
if (rawNode instanceof HTMLVideoElement || rawNode instanceof HTMLImageElement) {
1788-
colorGradingRuntime?.setSourceVisibility(rawNode, false);
1789-
}
1790-
continue;
1791-
}
1792-
1793-
if (dataHiddenDisplayNodes.has(rawNode)) {
1794-
const previousDisplay = dataHiddenDisplayRestores.get(rawNode);
1795-
if (previousDisplay) {
1796-
rawNode.style.display = previousDisplay;
1797-
} else {
1798-
rawNode.style.removeProperty("display");
1799-
}
1800-
dataHiddenDisplayRestores.delete(rawNode);
1801-
dataHiddenDisplayNodes.delete(rawNode);
1802-
}
1803-
1804-
let isVisibleNow = isTimedElementVisibleAt(rawNode, state.currentTime);
1805-
// Descendants must not override a hidden ancestor clip. CSS visibility can
1806-
// otherwise leak child pixels through inactive scenes because a descendant
1807-
// with visibility:visible escapes an ancestor's visibility:hidden.
1808-
if (isVisibleNow) {
1809-
let ancestor = rawNode.parentElement;
1810-
while (ancestor) {
1811-
if (ancestor === rootComp) break;
1812-
if (ancestor instanceof HTMLElement && ancestor.hasAttribute("data-start")) {
1813-
if (!isTimedElementVisibleAt(ancestor, state.currentTime)) {
1814-
isVisibleNow = false;
1815-
break;
1816-
}
1817-
}
1818-
ancestor = ancestor.parentElement;
1819-
}
1820-
}
1821-
rawNode.style.visibility = isVisibleNow ? "visible" : "hidden";
1822-
if (rawNode instanceof HTMLVideoElement || rawNode instanceof HTMLImageElement) {
1823-
colorGradingRuntime?.setSourceVisibility(rawNode, isVisibleNow);
1824-
}
1825-
if (isVisibleNow) {
1826-
if (isTimedClipInFlow(rawNode)) rawNode.style.removeProperty("display");
1827-
} else if (isTimedClipInFlow(rawNode) && isTimedClipLeaf(rawNode)) {
1828-
rawNode.style.display = "none";
1829-
}
1830-
}
1835+
syncTimedElementVisibility(state.currentTime);
18311836
};
18321837

18331838
const postState = (force: boolean) => {

‎packages/studio-server/src/helpers/sourceMutation.ts‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import { parseHTML } from "linkedom";
22
import postcss from "postcss";
33
import selectorParser from "postcss-selector-parser";
44
import { isAllowedHtmlAttribute, isSafeAttributeValue } from "@hyperframes/core/html-attr-safety";
5+
import { ensureHfIds } from "@hyperframes/parsers/hf-ids";
56
import { parseStyleDecls, patchStyleAttrString } from "./sourceStyleMutation.js";
67

78
export interface SourceMutationTarget {
@@ -349,8 +350,11 @@ export function splitElementInHtml(
349350
el.parentElement!.appendChild(clone);
350351
}
351352

353+
const html = wrappedFragment ? document.body.innerHTML || "" : document.toString();
352354
return {
353-
html: wrappedFragment ? document.body.innerHTML || "" : document.toString(),
355+
// The split owns its new nodes' stable ids. Leaving the clone unstamped makes
356+
// the next preview request persist different bytes after history is recorded.
357+
html: ensureHfIds(html),
354358
matched: true,
355359
newId,
356360
};

‎packages/studio-server/src/helpers/sourceMutationSplitAndGroup.test.ts‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,8 +12,11 @@ describe("splitElementInHtml — hfId clone isolation", () => {
1212
const { html, matched } = splitElementInHtml(source, { id: "clip1" }, 5, "clip2");
1313

1414
expect(matched).toBe(true);
15+
const { document } = parseHTML(html);
1516
const occurrences = (html.match(/data-hf-id="hf-abc123"/g) ?? []).length;
1617
expect(occurrences).toBe(1);
18+
expect(document.getElementById("clip2")?.getAttribute("data-hf-id")).toMatch(/^hf-/);
19+
expect(document.getElementById("clip2")?.getAttribute("data-hf-id")).not.toBe("hf-abc123");
1720
});
1821
});
1922

0 commit comments

Comments
 (0)