@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/studio/index.d.ts

@@ -0,0 +1,4296 @@
+export { Button, ButtonSize, ButtonVariant, ContextMenu, HyperframesLoader, HyperframesLoaderProps, HyperframesLogo, IconButton, Input, InputProps, Menu, MenuItem, MenuItemTone, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuShortcut, NumberField, NumberFieldProps, Popover, PopupPreviewState, PreviewState, Select, SelectOption, SelectProps, Slider, SliderProps, Tab, TabPanel, Tabs, TabsList, Toggle, ToggleProps, Tooltip, buttonBase, buttonSizes, buttonVariants, cn, fieldBase, fieldText, popupSurface } from './ui.js';
+import * as react from 'react';
+import { RefObject, MutableRefObject, ReactNode, DragEventHandler, ComponentProps, RefCallback, MouseEvent, CSSProperties, UIEvent, PointerEvent } from 'react';
+import { RuntimeTimelineClipIdentity, HyperframePickerElementInfo } from '@hyperframes/core';
+import { GsapAnimation, ParsedGsap, PropertyGroupName } from '@hyperframes/core/gsap-parser';
+import { GsapAnimation as GsapAnimation$1, ArcPathSegment } from '@hyperframes/parsers/gsap-parser';
+import { Composition } from '@hyperframes/sdk';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as zustand from 'zustand';
+import { StoreApi } from 'zustand';
+export { Player } from './player.js';
+import { MusicBeatAnalysis } from '@hyperframes/core/beats';
+import * as _hyperframes_parsers from '@hyperframes/parsers';
+import { CanvasResolution } from '@hyperframes/parsers';
+export { SeamTransitionFrameSource, SeamTransitionLoopHandle, SeamTransitionLoopOptions, playSeamTransitionLoop } from '@hyperframes/shader-transitions';
+import '@base-ui/react/tabs';
+import 'node_modules/cn/dist/types';
+import '@base-ui/react/context-menu';
+import '@base-ui/react/menu';
+import '@base-ui/react/popover';
+
+interface ShortcutHint {
+    key: string;
+    label: string;
+}
+interface ShortcutSection {
+    title: string;
+    hints: readonly ShortcutHint[];
+}
+/** What PlayerControls' shortcuts panel lists unless an embedder passes its own sections. */
+declare const DEFAULT_SHORTCUT_SECTIONS: readonly ShortcutSection[];
+
+interface PlayerControlsProps {
+    onTogglePlay: () => void;
+    onSeek: (time: number) => void;
+    disabled?: boolean;
+    isFullscreen?: boolean;
+    onToggleFullscreen?: () => void;
+    /** Replaces the shortcuts panel's list, e.g. DEFAULT_SHORTCUT_SECTIONS with entries dropped or relabelled. */
+    shortcutSections?: readonly ShortcutSection[];
+}
+declare const PlayerControls: react.NamedExoticComponent<PlayerControlsProps>;
+
+declare function TimelineRulerPart(): react_jsx_runtime.JSX.Element;
+
+interface UserBeat {
+    time: number;
+    strength: number;
+}
+interface BeatEditState {
+    /** Music src these edits apply to; edits reset when the src changes. */
+    src: string;
+    /** Beats the user added (audio-file coords). */
+    added: UserBeat[];
+    /** Audio-file times of detected beats the user removed. */
+    removed: number[];
+}
+
+/**
+ * Shared type definitions for the timeline playback subsystem.
+ * Kept in a separate module so adapter, DOM, and hook modules can all import
+ * from here without creating circular dependencies.
+ */
+
+interface ClipManifestClip extends RuntimeTimelineClipIdentity {
+    zIndex?: number;
+    stackingContextId?: string | null;
+    compositionAncestors?: string[];
+    playbackStart?: number;
+    playbackRate?: number;
+}
+
+type TimelineTimeDisplayMode = "time" | "frame";
+
+interface AnimationKeyframeTarget {
+    animationId: string;
+    tweenPercentage: number;
+}
+
+/** Minimal keyframe cache types — mirrors GsapKeyframesData without pulling in Node-only gsap-parser. */
+interface KeyframeCacheEntry {
+    format: string;
+    keyframes: Array<{
+        percentage: number;
+        /** Original tween-relative percentage (server mutations need this, not the clip-relative `percentage`). */
+        tweenPercentage?: number;
+        /** Which property group the source tween belongs to (position, scale, rotation, visual, etc.). */
+        propertyGroup?: string;
+        /** Source tween id — lets the inline clip-row ease button target a specific segment. */
+        animationId?: string;
+        properties: Record<string, number | string>;
+        ease?: string;
+        /** Source animation/keyframe targets that collide at this clip percentage. */
+        collidingAnimationTargets?: AnimationKeyframeTarget[];
+    }>;
+    ease?: string;
+    easeEach?: string;
+}
+interface FocusedEaseSegment {
+    animationId: string;
+    collidingAnimationTargets?: AnimationKeyframeTarget[];
+    tweenPercentage: number;
+    elementId: string;
+    projectId: string | null;
+    sessionEpoch: number;
+    nonce: number;
+}
+type FocusedEaseSegmentTarget = Omit<FocusedEaseSegment, "projectId" | "sessionEpoch" | "nonce">;
+/**
+ * A request to reveal one automated parameter in the audio FX rack.
+ *
+ * `elementKey` is the timeline element whose rack it belongs to — a group's own
+ * id for a group lane, the clip's key otherwise — so the panel can refuse a
+ * request aimed at something it is not showing.
+ */
+interface RevealedAudioFxTarget {
+    elementKey: string;
+    /** The lane's own `fx.<node>.<param>` / `volume` target. */
+    automationTarget: string;
+    projectId: string | null;
+    sessionEpoch: number;
+    nonce: number;
+}
+type RevealedAudioFxTargetRequest = Omit<RevealedAudioFxTarget, "projectId" | "sessionEpoch" | "nonce">;
+interface KeyframeSlice {
+    /** Selected collapsed (`element:pct`) or expanded (`element:group:animation:clipPct`) diamonds. */
+    selectedKeyframes: Set<string>;
+    toggleSelectedKeyframe: (key: string) => void;
+    clearSelectedKeyframes: () => void;
+    /** Clips whose keyframe property lanes are expanded in the timeline. */
+    expandedClipIds: Set<string>;
+    toggleClipExpanded: (id: string) => void;
+    setClipExpanded: (id: string, expanded: boolean) => void;
+    /** Union-expand clips (keyframed clips are expanded by default on load). */
+    expandClips: (ids: readonly string[]) => void;
+    /**
+     * Groups whose member rows the caret has HIDDEN (structural, not lanes).
+     *
+     * Inverted deliberately. As an expanded-set, "not in the set" could not tell
+     * never-touched from deliberately-collapsed, so every group defaulted to
+     * collapsed — and since nothing seeds the set on create, grouping three
+     * tracks made all three vanish behind a header the user had not yet learned
+     * to open. Groups are expanded until someone closes one.
+     */
+    collapsedGroupIds: Set<string>;
+    toggleGroupExpanded: (id: string) => void;
+    /** Rows (clip id or group id) whose automation-lane rows the `∿` button opened. */
+    expandedLaneOwnerIds: Set<string>;
+    toggleLaneOwnerExpanded: (id: string) => void;
+    /**
+     * Project/session/element-scoped request. Its nonce is monotonic across store
+     * resets so a stale consumer can never collide with a later request.
+     */
+    focusedEaseSegment: FocusedEaseSegment | null;
+    focusedEaseRequestNonce: number;
+    setFocusedEaseSegment: (target: FocusedEaseSegmentTarget) => void;
+    clearFocusedEaseSegment: (nonce: number) => void;
+    /**
+     * "Show me this automated parameter in the rack" — raised by clicking an
+     * automation lane's label in the timeline, consumed by the property panel.
+     *
+     * Session-stamped and nonce-guarded exactly like `focusedEaseSegment`: a
+     * request outlives the click, so one made against a different project or
+     * before a reload must not reopen a rack on whatever is mounted later.
+     */
+    revealedAudioFxTarget: RevealedAudioFxTarget | null;
+    revealedAudioFxNonce: number;
+    setRevealedAudioFxTarget: (target: RevealedAudioFxTargetRequest) => void;
+    clearRevealedAudioFxTarget: (nonce: number) => void;
+    /** Keyframe data per element id, populated from parsed GSAP animations. */
+    keyframeCache: Map<string, KeyframeCacheEntry>;
+    /** Unmerged source tweens per element; expanded property lanes read this, never keyframeCache. */
+    gsapAnimations: Map<string, GsapAnimation[]>;
+    setGsapAnimations: (elementId: string, animations: GsapAnimation[] | undefined) => void;
+    setKeyframeCache: (elementId: string, data: KeyframeCacheEntry | undefined) => void;
+}
+
+/**
+ * The active selection box on one automation lane.
+ *
+ * A store slice, not lane-local state, for the same reason keyframe selection
+ * is one: Delete/copy/paste handlers and the shape menu live outside the lane
+ * component and need to read it. Ephemeral by construction — nothing
+ * serializes store state, and the selection must never survive into a render.
+ */
+
+interface AutomationSelection {
+    /** TimelineElement key (key ?? id) of the clip that owns the lane. */
+    elementKey: string;
+    /** Lane target: "volume" or "fx.<nodeId>.<param>". */
+    target: string;
+    /** Clip-local seconds; always t0 <= t1 (ordered on write). */
+    t0: number;
+    t1: number;
+    /**
+     * The box's value bounds, in the parameter's own units; always v0 <= v1.
+     *
+     * What makes the selection a box rather than a time span: a point is caught
+     * only if it falls inside both axes. Span operations — copy, paste, shape
+     * insert, simplify — still read t0/t1 alone, because they act on the envelope
+     * over a stretch of time rather than on a set of breakpoints.
+     */
+    v0: number;
+    v1: number;
+}
+interface AutomationSelectionSlice {
+    automationSelection: AutomationSelection | null;
+    setAutomationSelection: (sel: AutomationSelection) => void;
+    clearAutomationSelection: () => void;
+}
+
+/**
+ * The two editing-mode toggles the timeline toolbar owns.
+ *
+ * A store slice rather than toolbar-local state because both are read far from
+ * where they are set: the motion-path arm is consumed by the canvas click
+ * handler and published by MotionPathOverlay, and the auto-keyframe flag
+ * decides what a drag/resize/rotate does inside the edit commit path.
+ *
+ * `motionPathArmed` is also cleared by playerStore on selection change — arming
+ * survives neither a new element nor a project switch, so those resets stay
+ * with the state they clear alongside.
+ */
+
+interface EditingModeSlice {
+    /** Motion-path "set destination" mode. Armed from the preview toolbar
+     *  (replaces the old double-click-on-canvas UX); while armed, one canvas
+     *  click places the new path's destination. */
+    motionPathArmed: boolean;
+    setMotionPathArmed: (armed: boolean) => void;
+    /** Published by MotionPathOverlay so the toolbar shows the button only when
+     *  the selected element can actually take a path. */
+    motionPathCreateAvailable: boolean;
+    setMotionPathCreateAvailable: (available: boolean) => void;
+    /** Global toggle for the "Add keyframe" diamond in the timeline toolbar
+     *  (#1808). When false, a manual drag/resize/rotate edit on an element that
+     *  already has a live tween shifts every keyframe by the edit's delta
+     *  (preserving the animation's shape) instead of inserting/updating a
+     *  keyframe at the playhead. */
+    autoKeyframeEnabled: boolean;
+    setAutoKeyframeEnabled: (enabled: boolean) => void;
+}
+
+interface TimelineFocusRequest {
+    id: string;
+    projectId: string | null;
+    sessionEpoch: number;
+    nonce: number;
+}
+
+type ThumbnailMode = "adaptive" | "hidden";
+
+interface ThumbnailSlice {
+    thumbnailMode: ThumbnailMode;
+    /** Monotonic identity, per composition path, for persisted content shown by mounted thumbnails. */
+    thumbnailRevisions: Readonly<Record<string, number>>;
+    setThumbnailMode: (mode: ThumbnailMode) => void;
+    /** `null` moves every composition, e.g. after a root or asset change. */
+    bumpThumbnailRevisions: (compositions: readonly string[] | null) => void;
+}
+
+/** Gates `timelineReady` on the composition's declared readiness inputs
+ * (media, compute, and the paint-and-idle default) instead of just a known
+ * duration. The generation counter is module-scope, not store state: it
+ * guards an in-flight settlement, not something a component reads, so
+ * bumping it shouldn't trigger a render. */
+
+interface PlaybackReadinessSlice {
+    timelineReady: boolean;
+    /** Latched when the project's first preview shows its first frame (or fails), kept through edit
+     *  reloads, so work that must not compete with the boot waits for it once. */
+    previewBooted: boolean;
+    setTimelineReady: (ready: boolean) => void;
+    markPreviewBooted: () => void;
+    playLocked: boolean;
+    setPlayLocked: (locked: boolean) => void;
+    /** Sets timelineReady once doc's readiness inputs settle, or immediately
+     *  if doc is null. A wait a later call supersedes never wins the race.
+     *  Waits for doc's load step first: it pauses and rewinds the preview, so a
+     *  Play enabled before it would be undone. */
+    requestTimelineReady: (doc: Document | null) => void;
+    /** Called by the preview's load step for the document it ran on. */
+    markPreviewLoadStep: (doc: Document) => void;
+}
+declare function createPlaybackReadinessSlice(set: StoreApi<PlaybackReadinessSlice>["setState"]): PlaybackReadinessSlice;
+
+interface TimelineTimeRange$1 {
+    t0: number;
+    t1: number;
+}
+interface RangeSelectionSlice {
+    /** Shift-drag ruler range in seconds, normalized so t0 <= t1. */
+    rangeSelection: TimelineTimeRange$1 | null;
+}
+
+/**
+ * One row in the timeline: a clip as Studio needs it, translated from the
+ * runtime's manifest at createTimelineElementFromManifestClip.
+ *
+ * Split out of playerStore, which had reached the 600-line studio ceiling and
+ * could not carry another field. Re-exported from there, so every existing
+ * importer is unaffected.
+ */
+
+interface TimelineElement {
+    id: string;
+    label?: string;
+    transitionLabel?: string;
+    key?: string;
+    kind?: ClipManifestClip["kind"];
+    tag: string;
+    start: number;
+    duration: number;
+    track: number;
+    /**
+     * The data-track-index as written in the source file. Set at the manifest
+     * translation boundary (createTimelineElementFromManifestClip) from the
+     * runtime clip's verbatim track, and preserved through display-lane remaps
+     * (normalizeToZones packs sparse authored tracks onto contiguous display
+     * lanes; expanded sub-comp children get synthetic display rows). Lane edits
+     * must persist THIS space — writing a display-lane number into a sparse file
+     * re-targets the wrong track. For an expanded child the value is in its OWN
+     * source file's coordinate space, not the host timeline's.
+     */
+    authoredTrack?: number;
+    /** Resolved z-index for stacking-aware timeline ordering. */
+    zIndex?: number;
+    /** True when the effective z-index was authored inline or through CSS, not auto. */
+    hasExplicitZIndex?: boolean;
+    /** Canonical CSS stacking context this element's z-index participates in. */
+    stackingContextId?: string | null;
+    /** Nearest parent composition context, matching RuntimeTimelineClip. */
+    parentCompositionId?: string | null;
+    /** Composition ancestry from root to nearest parent, matching RuntimeTimelineClip. */
+    compositionAncestors?: string[];
+    domId?: string;
+    /** Stable `data-hf-id` attribute value — used as primary patch target when present */
+    hfId?: string;
+    /** Best-effort selector used when patching source HTML back from timeline edits */
+    selector?: string;
+    /** Zero-based occurrence index for non-unique selectors */
+    selectorIndex?: number;
+    /** Source composition file that owns this element, when known */
+    sourceFile?: string;
+    src?: string;
+    playbackStart?: number;
+    playbackStartAttr?: "media-start" | "playback-start";
+    playbackRate?: number;
+    sourceDuration?: number;
+    volume?: number;
+    /** A video with sound to mix (`data-has-audio`, or unmuted without it); `muted` silences it. */
+    hasAudio?: boolean;
+    muted?: boolean;
+    /** Clip-edge fades from `data-fade-in` / `data-fade-out`, seconds; absent means none. */
+    fadeIn?: number;
+    fadeOut?: number;
+    /** Verbatim `data-fx-chain` / `data-automation`; see automationLaneData. */
+    fxChain?: string;
+    automation?: string;
+    /** Path from data-composition-src — identifies sub-composition elements */
+    compositionSrc?: string;
+    /** Set by data-timeline-locked on the host element — disables move and trim in Studio. */
+    timelineLocked?: boolean;
+    /** Set by data-hidden on the host element — hides the clip in preview and render. */
+    hidden?: boolean;
+    /** Value of data-timeline-role attribute — used to identify music vs. voiceover. */
+    timelineRole?: string;
+    /** Verbatim `data-audio-group` — the id of the `<hf-audio-group>` this clip belongs to, when any. */
+    audioGroup?: string;
+    /** The owning group's `data-label` (falls back to its id) — resolved once per parse. */
+    audioGroupLabel?: string;
+    /** The owning group's `data-volume` (defaults to 1) — resolved once per parse. */
+    audioGroupVolume?: number;
+    /** The owning group's `data-hidden` (defaults to false) — resolved once per parse. */
+    audioGroupHidden?: boolean;
+    /** The owning group's serialized `data-fx-chain`, when set — resolved once per parse. */
+    audioGroupFxChain?: string;
+    audioGroupAutomation?: string;
+    link?: string;
+    compositionScope?: string;
+    syncOrigin?: string;
+    /**
+     * Master start of the composition this row runs in, which its tweens and its
+     * `data-start` are local to; 0 at the root. Writes go through toAuthoredStart.
+     */
+    parentCompositionStart?: number;
+    /** A legacy root-global media start: its `data-start` is already master time. */
+    authoredStartIsMasterTime?: boolean;
+    /** Legacy marker for an inline sub-composition child; current rows never set it. */
+    expandedHostKey?: string;
+    /** A text layer's words and look, which its row draws live instead of a captured picture. */
+    text?: TimelineText;
+}
+interface TimelineText {
+    value: string;
+    fontFamily?: string;
+    fontWeight?: string;
+    color?: string;
+    /** The layer's own opaque background colour, when it paints one. */
+    background?: string;
+}
+/**
+ * The fields `updateElement` may write.
+ *
+ * Deliberately a narrow allow-list rather than `Partial<TimelineElement>`: most
+ * of an element is derived from the document at parse time, and letting a
+ * caller poke those would put the store out of step with the file it mirrors.
+ *
+ * The `audioGroup*` entries are the GROUP's state, mirrored onto every member —
+ * a group row derives its label, fader, mute and chain from these, so a group
+ * write has to be able to land here or the header goes on rendering whatever it
+ * parsed at load.
+ */
+type TimelineElementPatch = Partial<Pick<TimelineElement, "start" | "duration" | "track" | "zIndex" | "hasExplicitZIndex" | "playbackStart" | "hidden" | "audioGroup" | "audioGroupLabel" | "audioGroupVolume" | "audioGroupHidden" | "audioGroupFxChain" | "audioGroupAutomation" | "text">>;
+/**
+ * The `data-*` state an expanded sub-composition child needs but cannot reach.
+ *
+ * A child row is synthesized from a manifest clip with no element to read, and
+ * for a real sub-composition it has no flat store twin either: such clips are
+ * dropped before the flat store is built. Read off the live preview instead
+ * (`collectSubCompositionHostState`) and carried on the store by dom id.
+ *
+ * Without it the eye reported every hidden child visible, so clicking it wrote
+ * `data-hidden` a second time instead of removing it, and the element could
+ * never be shown again, not even after a reload, since the attribute is in the
+ * source.
+ */
+interface SubCompositionHostState {
+    hidden?: boolean;
+    timelineLocked?: boolean;
+    timelineRole?: string;
+    fxChain?: string;
+    automation?: string;
+}
+
+type TimeListener = (time: number) => void;
+declare const liveTime: {
+    notify: (time: number) => void;
+    notifySeek: (time: number) => void;
+    seekCount: () => number;
+    latest: () => number;
+    subscribe: (listener: TimeListener) => () => boolean;
+};
+
+type ZoomMode = "fit" | "manual";
+type TimelineTool = "select" | "razor";
+interface SelectElementOptions {
+    preserveSet?: boolean;
+}
+type PlayerStoreSlices = KeyframeSlice & AutomationSelectionSlice & ThumbnailSlice & EditingModeSlice & ReturnType<typeof createPlaybackReadinessSlice> & RangeSelectionSlice;
+interface PlayerState extends PlayerStoreSlices {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    /** Increments exactly once when the Studio switches to a different project. */
+    timelineSessionEpoch: number;
+    /** Project owning the current timeline session; null outside a project-scoped reset. */
+    timelineProjectId: string | null;
+    /** True while a beat dot is being dragged — hides the playhead guideline. */
+    beatDragging: boolean;
+    elements: TimelineElement[];
+    selectedElementId: string | null;
+    playbackRate: number;
+    audioMuted: boolean;
+    audioVolume: number;
+    loopEnabled: boolean;
+    /** Timeline zoom: 'fit' auto-scales to viewport, 'manual' uses manualZoomPercent */
+    zoomMode: ZoomMode;
+    /** Timeline zoom percent relative to the fit width when in manual mode */
+    manualZoomPercent: number;
+    userZoomCount: number;
+    /**
+     * Bumped on every live z-index edit (handleDomZIndexReorderCommit apply AND
+     * rollback). Flashless z commits (skipReload) never reload the iframe or
+     * bump refreshKey, so DOM-derived views (the Layers panel's z-sorted tree)
+     * subscribe to this to re-read the live DOM while playback is paused.
+     */
+    zEditVersion: number;
+    /** Work-area in-point (seconds). When set, loop starts here and A jumps here. */
+    inPoint: number | null;
+    /** Work-area out-point (seconds). When set, loop ends here and E jumps here. */
+    outPoint: number | null;
+    activeTool: TimelineTool;
+    setActiveTool: (tool: TimelineTool) => void;
+    selectLeftward: () => void;
+    selectRightward: () => void;
+    /** Tween-relative percentage of the last-clicked keyframe diamond. Operations
+     *  (drag, resize, rotate) target this instead of recomputing from playhead. */
+    activeKeyframePct: number | null;
+    setActiveKeyframePct: (pct: number | null) => void;
+    /** Multi-select: additional selected elements beyond selectedElementId. */
+    selectedElementIds: Set<string>;
+    clearSelectedElementIds: () => void;
+    /** Replace the whole multi-selection at once (marquee live updates). */
+    setSelectedElementIds: (ids: Set<string>) => void;
+    /** Timeline magnet toggle — when false, clip drags/trims/drops never snap. */
+    timelineSnapEnabled: boolean;
+    setTimelineSnapEnabled: (enabled: boolean) => void;
+    /** Keeps the main track gapless on delete; distinct from the magnet above. */
+    rippleEditEnabled: boolean;
+    setRippleEditEnabled: (enabled: boolean) => void;
+    /** Transport + ruler readout: timecode ("time") or frame number ("frame"). */
+    timeDisplayMode: TimelineTimeDisplayMode;
+    setTimeDisplayMode: (mode: TimelineTimeDisplayMode) => void;
+    /** Pin the timeline zoom to its current scale before a duration change, so
+     *  it stops rescaling every clip. No-op once already pinned. */
+    pinTimelineZoom: (currentPixelsPerSecond: number, fitPixelsPerSecond: number) => void;
+    /** The timeline's live pixels-per-second + fit basis, published by <Timeline>. */
+    timelinePps: number;
+    timelineFitPps: number;
+    setTimelineScale: (pps: number, fitPps: number) => void;
+    setSelection: (ids: Iterable<string>, anchor?: string | null) => void;
+    addSelectedElementId: (id: string) => void;
+    toggleSelectedElementId: (id: string) => void;
+    clearSelection: () => void;
+    setIsPlaying: (playing: boolean) => void;
+    setCurrentTime: (time: number) => void;
+    setDuration: (duration: number) => void;
+    setPlaybackRate: (rate: number) => void;
+    setAudioMuted: (muted: boolean) => void;
+    setAudioVolume: (volume: number) => void;
+    setLoopEnabled: (enabled: boolean) => void;
+    setBeatDragging: (dragging: boolean) => void;
+    setElements: (elements: TimelineElement[]) => void;
+    setSelectedElementId: (id: string | null, options?: SelectElementOptions) => void;
+    /** Move the selection anchor within an active multi-selection without collapsing it. */
+    setSelectionAnchor: (id: string | null) => void;
+    updateElement: (elementId: string, updates: TimelineElementPatch) => void;
+    setZoomMode: (mode: ZoomMode) => void;
+    setManualZoomPercent: (percent: number) => void;
+    bumpZEditVersion: () => void;
+    setInPoint: (time: number | null) => void;
+    setOutPoint: (time: number | null) => void;
+    /** Owns the hard project boundary; repeated calls for one project are no-ops. */
+    beginTimelineSession: (projectId: string) => void;
+    /** Clears project data without creating a new hard-project session. */
+    reset: () => void;
+    /** Request a seek from outside the player loop (e.g. Layers panel);
+     *  useTimelinePlayer subscribes and calls adapter.seek() + liveTime.notify(). */
+    requestedSeekTime: number | null;
+    requestSeek: (time: number) => void;
+    clearSeekRequest: () => void;
+    /** Request the transport start or stop from outside the player loop: the FX
+     *  rack starts playback to audition a preset (silent while paused) and
+     *  restores the playhead on leave, without costing the author their place.
+     *  A nonce, not a bare boolean, so two hovers in a row both register. */
+    playbackRequest: {
+        playing: boolean;
+        returnTo: number | null;
+        nonce: number;
+    } | null;
+    requestPlayback: (playing: boolean, returnTo?: number | null) => void;
+    clearPlaybackRequest: () => void;
+    /**
+     * Request the timeline to scroll a clip into view (e.g. clicking an
+     * already-added asset card in the sidebar). Consumed and cleared by
+     * useTimelineRevealClip. The nonce makes repeat requests for the same
+     * clip observable so a second click re-reveals after the user scrolls away.
+     */
+    clipRevealRequest: {
+        elementId: string;
+        nonce: number;
+    } | null;
+    requestClipReveal: (elementId: string) => void;
+    clearClipRevealRequest: () => void;
+    timelineFocus: TimelineFocusRequest | null;
+    timelineFocusNonce: number;
+    requestTimelineFocus: (id: string) => void;
+    clearTimelineFocus: (nonce: number) => void;
+    lintFindingsByElement: Map<string, {
+        count: number;
+        messages: string[];
+    }>;
+    setLintFindingsByElement: (map: Map<string, {
+        count: number;
+        messages: string[];
+    }>) => void;
+    beatAnalysis: MusicBeatAnalysis | null;
+    setBeatAnalysis: (analysis: MusicBeatAnalysis | null) => void;
+    /** User edits (add/move/delete) layered over the detected beat grid. */
+    beatEdits: BeatEditState | null;
+    setBeatEdits: (edits: BeatEditState | null) => void;
+    /** Undo/redo stacks for beat edits (in-memory, session-only). */
+    beatUndo: BeatHistoryEntry[];
+    beatRedo: BeatHistoryEntry[];
+    commitBeatEdits: (next: BeatEditState | null, label: string) => void;
+    undoBeatEdits: () => string | null;
+    redoBeatEdits: () => string | null;
+    resetBeatHistory: () => void;
+    beatPersist: (() => void) | null;
+    setBeatPersist: (fn: (() => void) | null) => void;
+    clipManifest: ClipManifestClip[] | null;
+    setClipManifest: (clips: ClipManifestClip[] | null) => void;
+    clipParentMap: Map<string, string>;
+    setClipParentMap: (map: Map<string, string>) => void;
+    /**
+     * Sub-composition DOM descendants (groups + their children) that have no
+     * `data-start`, so they're absent from the clip manifest/tree. Collected
+     * studio-side from the live preview so the timeline can expand a sub-comp row
+     * to show its DOM-only children. Keeps the manifest lean (timed clips only).
+     */
+    domClipChildren: DomClipChild[];
+    setDomClipChildren: (children: DomClipChild[]) => void;
+    /**
+     * Host-element state for every id'd element inside a sub-composition, keyed by
+     * dom id. Collected from the live preview because it is the only place that
+     * sees it: these elements are filtered out of `elements` before the flat store
+     * is built, and the clip manifest carries timing, not attributes.
+     */
+    subCompositionHostState: Map<string, SubCompositionHostState>;
+    setSubCompositionHostState: (state: Map<string, SubCompositionHostState>) => void;
+}
+/** A sub-comp DOM-only timeline child (no data-start) and its nesting context. */
+interface DomClipChild {
+    id: string;
+    parentId: string;
+    /** The manifest sub-comp host clip id this descendant ultimately lives under. */
+    hostId: string;
+    label: string;
+    stackingContextId: string;
+    /**
+     * The child's audio-group state, read off its live element during the DOM
+     * walk — the only place that sees it. A sub-composition can declare a group
+     * and its members entirely within itself, and those members never reach the
+     * flat store, so an expanded child has no twin to inherit membership from.
+     */
+    audioGroup?: string;
+    audioGroupLabel?: string;
+    audioGroupVolume?: number;
+    audioGroupHidden?: boolean;
+    audioGroupFxChain?: string;
+    /** The group element's `data-automation`, mirrored the same way. */
+    audioGroupAutomation?: string;
+}
+interface BeatHistoryEntry {
+    restore: BeatEditState | null;
+    at: number;
+    label: string;
+}
+declare const usePlayerStore: zustand.UseBoundStore<zustand.StoreApi<PlayerState>>;
+
+interface PatchOperation {
+    type: "inline-style" | "attribute" | "text-content" | "html-attribute" | "rich-text";
+    property: string;
+    value: string | null;
+    childSelector?: string;
+    childIndex?: number;
+}
+interface PatchTarget {
+    id?: string | null;
+    hfId?: string;
+    selector?: string;
+    selectorIndex?: number;
+}
+/**
+ * Find which source file contains an element by its ID.
+ */
+declare function resolveSourceFile(elementId: string | null, selector: string, files: Record<string, string>): string | null;
+/**
+ * Apply a patch operation to an HTML source file.
+ */
+declare function applyPatch(html: string, elementId: string, op: PatchOperation): string;
+
+interface DomEditCapabilities {
+    canSelect: boolean;
+    canEditStyles: boolean;
+    /** Can take a non-destructive `clip-path: inset()` crop — broader than
+     *  canEditStyles (a sub-composition host is croppable from the parent view). */
+    canCrop: boolean;
+    /** Directly editable authored left/top style fields. Canvas drag uses manual edits instead. */
+    canMove: boolean;
+    /** Directly editable authored width/height style fields. Canvas resize uses manual edits instead. */
+    canResize: boolean;
+    canApplyManualOffset: boolean;
+    canApplyManualSize: boolean;
+    canApplyManualRotation: boolean;
+    reasonIfDisabled?: string;
+    commitCheckPending?: boolean;
+}
+interface DomEditTextField {
+    key: string;
+    label: string;
+    value: string;
+    tagName: string;
+    attributes: Array<{
+        name: string;
+        value: string;
+    }>;
+    inlineStyles: Record<string, string>;
+    computedStyles: Record<string, string>;
+    source: "self" | "child" | "text-node";
+    sourceChildIndex?: number;
+}
+interface DomEditSelection extends PatchTarget {
+    element: HTMLElement;
+    label: string;
+    tagName: string;
+    sourceFile: string;
+    compositionPath: string;
+    compositionSrc?: string;
+    isCompositionHost: boolean;
+    isInsideLockedComposition: boolean;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    textContent: string | null;
+    dataAttributes: Record<string, string>;
+    inlineStyles: Record<string, string>;
+    computedStyles: Record<string, string>;
+    textFields: DomEditTextField[];
+    capabilities: DomEditCapabilities;
+    existsInSource?: boolean;
+    gsapAnimations?: GsapAnimation$1[];
+}
+interface DomEditLayerItem {
+    key: string;
+    element: HTMLElement;
+    label: string;
+    tagName: string;
+    depth: number;
+    childCount: number;
+    id?: string;
+    hfId?: string;
+    selector?: string;
+    selectorIndex?: number;
+    sourceFile: string;
+}
+interface DomEditContextOptions {
+    activeCompositionPath: string | null;
+    isMasterView: boolean;
+    preferClipAncestor?: boolean;
+    /** The group wrapper the user has drilled into (null = top level). Selection
+     * resolution treats groups as a unit unless drilled into one. */
+    activeGroupElement?: HTMLElement | null;
+}
+
+declare function resolveDomEditSelection(startEl: HTMLElement | null, options: DomEditContextOptions & {
+    projectId?: string | null;
+    skipSourceProbe?: boolean;
+    exactTarget?: boolean;
+    previous?: DomEditSelection | null;
+}): Promise<DomEditSelection | null>;
+
+/**
+ * Agent prompt builder for HyperFrames element edit requests.
+ */
+
+/**
+ * The subset of an element selection shared by the Studio DOM editor (`DomEditSelection`) and the
+ * runtime picker (`HyperframePickerElementInfo`); a field absent from a caller's type is simply omitted.
+ */
+interface AgentPromptElementInfo {
+    id: string | null;
+    selector?: string | null;
+    /** Disambiguates duplicate selectors in `DomEditSelection`. The picker
+     *  payload has no such concept (one picked node, not a candidate list), so
+     *  a picker-built prompt always prints index 0 — expected, not a gap. */
+    selectorIndex?: number;
+    tagName: string;
+    label?: string;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    textContent: string | null;
+    src?: string | null;
+    textFields?: DomEditTextField[];
+    inlineStyles?: Record<string, string>;
+    computedStyles?: Record<string, string>;
+}
+/**
+ * Same convention as `buildElementAgentPrompt`, for a host app embedding only the player: built from
+ * the runtime picker's own payload, not `DomEditSelection`. Null selection yields a bare prompt, no guardrails.
+ */
+declare function buildPickerAgentPrompt({ selection, userInstruction, }: {
+    selection: HyperframePickerElementInfo | null;
+    userInstruction?: string;
+}): string;
+declare function buildPickerAgentContextPreview(selection: HyperframePickerElementInfo | null): string;
+
+interface SdkSessionPublication {
+    candidate: Composition;
+    expectedSession: Composition;
+    targetPath: string;
+}
+type SdkSessionPublicationResult = "published" | "rejected-active-target" | "rejected-inactive-target";
+type PublishSdkSession = (publication: SdkSessionPublication) => SdkSessionPublicationResult;
+
+type TimelineLayerDropPlacement = {
+    type: "onto";
+    layerId: string;
+} | {
+    type: "between";
+    beforeLayerId: string;
+    afterLayerId: string;
+} | {
+    type: "above";
+    layerId: string;
+} | {
+    type: "below";
+    layerId: string;
+};
+interface TimelineStackingZIndexChange {
+    key: string;
+    zIndex: number;
+    domId?: string;
+    selector?: string;
+    selectorIndex?: number;
+    sourceFile?: string;
+}
+interface TimelineStackingReorderIntent {
+    contextKey: string;
+    placement: TimelineLayerDropPlacement;
+    zIndexChanges: TimelineStackingZIndexChange[];
+}
+
+type BlockedTimelineEditIntent = "move" | "resize-start" | "resize-end";
+interface TimelineRangeSelection {
+    start: number;
+    end: number;
+    anchorX: number;
+    anchorY: number;
+}
+
+interface RecordEditInput$5 {
+    label: string;
+    coalesceKey?: string;
+    coalesceMs?: number;
+    files: Record<string, {
+        before: string;
+        after: string;
+    }>;
+    created?: string[];
+}
+
+interface ImportedFontAsset {
+    family: string;
+    path: string;
+    url: string;
+    weight?: string;
+    style?: "normal" | "italic";
+}
+
+/** Durable evidence returned by the one Studio DOM persistence actor. */
+interface DomEditPersistOutcome {
+    sourceFile: string;
+    version: string;
+    changed: boolean;
+}
+/**
+ * Durability report for a patch-batches commit. `durable === false` means the
+ * server could not locate at least one patch target on disk — the preview was
+ * reloaded to reconverge, and dependent follow-up writes (the z→lane timeline
+ * mirror) must be skipped. `allMatched` retains the underlying match detail.
+ * `changed === false` means no source file was written: every patch was a
+ * byte-identical no-op, or the atomic gesture was refused before any write.
+ */
+interface DomEditPatchBatchesResult {
+    durable: boolean;
+    allMatched: boolean;
+    changed: boolean;
+}
+/** Several data-* and HTML attribute ops on one element as ONE persist and ONE undo entry. */
+type CommitDomAttributeBatch = (selection: DomEditSelection, operations: PatchOperation[], options: {
+    label: string;
+    prepareContent?: (html: string) => string;
+}) => Promise<boolean>;
+
+interface RecordEditInput$4 {
+    label: string;
+    coalesceKey?: string;
+    files: Record<string, {
+        before: string;
+        after: string;
+    }>;
+}
+type TimelineZIndexReorderCommit = (entries: Array<{
+    element: HTMLElement;
+    zIndex: number;
+    id?: string;
+    selector?: string;
+    selectorIndex?: number;
+    sourceFile: string;
+    key?: string;
+}>, coalesceKey?: string) => Promise<DomEditPatchBatchesResult | undefined | void>;
+interface UseTimelineEditingOptions {
+    projectId: string | null;
+    activeCompPath: string | null;
+    timelineElements: TimelineElement[];
+    showToast: (message: string, tone?: "error" | "info") => void;
+    writeProjectFile: (path: string, content: string, expectedContent?: string) => Promise<void>;
+    observeProjectFileVersion?: (path: string, version: string | null) => void;
+    recordEdit: (input: RecordEditInput$4) => Promise<void>;
+    reloadPreview: () => void;
+    previewIframeRef: RefObject<HTMLIFrameElement | null>;
+    pendingTimelineEditPathRef: MutableRefObject<Set<string>>;
+    uploadProjectFiles: (files: Iterable<File>, dir?: string) => Promise<string[]>;
+    isRecordingRef?: RefObject<boolean>;
+    /** Stage 7 §3.2: SDK session for routing timing ops through setTiming. */
+    sdkSession?: Composition | null;
+    /** Publish a fully persisted candidate SDK session. */
+    publishSdkSession?: PublishSdkSession;
+    /** Resync the SDK session after a server-authoritative timeline write. */
+    forceReloadSdkSession?: () => void;
+    /** Reparse authored animations after a timing rewrite changes their positions. */
+    invalidateGsapCache?: () => void;
+    handleDomZIndexReorderCommitRef?: MutableRefObject<TimelineZIndexReorderCommit | null>;
+    /** Refuses a hand edit at the persist boundary when set; absent = Studio unchanged. */
+    canEdit?: CanEditTimelineElement;
+}
+/** What a timeline move commits: the new start and track, plus the z-index
+ *  reorder a vertical drag resolves to (absent for a pure horizontal move). */
+type TimelineMoveUpdates = Pick<TimelineElement, "start" | "track"> & {
+    stackingReorder?: TimelineStackingReorderIntent | null;
+};
+
+declare class StudioSaveHttpError extends Error {
+    readonly statusCode: number;
+    readonly alreadyToasted: boolean;
+    constructor(message: string, statusCode: number, options?: {
+        alreadyToasted?: boolean;
+    });
+}
+declare class StudioFileConflictError extends StudioSaveHttpError {
+    readonly filePath: string;
+    readonly currentVersion: string | null;
+    readonly currentContent: string | null;
+    readonly attemptedContent: string;
+    constructor(input: {
+        filePath: string;
+        currentVersion: string | null;
+        currentContent: string | null;
+        attemptedContent: string;
+    });
+}
+type StudioSaveDrainResult<Failure = unknown> = {
+    status: "clean";
+} | {
+    status: "conflict";
+    error: StudioFileConflictError;
+} | {
+    status: "failed";
+    error: Failure;
+};
+
+type StudioPendingEditsDrainResult = StudioSaveDrainResult;
+interface StudioEditInFlight {
+    reverted: () => boolean;
+    within: <T>(run: () => T) => T;
+    drawUnlessUndone: (draw: () => void) => void;
+    drawKeepingUndone: <T>(draw: () => T) => T;
+    markSaved: () => void;
+}
+declare function revertNewestStudioPendingEdit(): (() => void) | null;
+declare function flushStudioPendingEdits({ onlyCurrent, }?: {
+    onlyCurrent?: boolean | undefined;
+}): Promise<StudioPendingEditsDrainResult>;
+
+/** Value-only channels a `tl.set(...)` patch may touch. */
+interface SetPatchProps {
+    x?: number;
+    y?: number;
+    rotation?: number;
+    rotationX?: number;
+    rotationY?: number;
+    rotationZ?: number;
+    z?: number;
+    transformPerspective?: number;
+    scaleX?: number;
+    scaleY?: number;
+    scale?: number;
+    opacity?: number;
+}
+/** A single keyframe step's numeric channels (the GSAP array-keyframe form). */
+type KeyframeStep = Record<string, number>;
+type RuntimeTweenChange = {
+    kind: "set";
+    props: SetPatchProps;
+} | {
+    kind: "keyframes";
+    keyframes: KeyframeStep[];
+} | {
+    kind: "keyframe-rebuild";
+    pct: number;
+    props: KeyframeStep;
+} | {
+    kind: "global-set";
+    props: SetPatchProps;
+};
+
+type KeyframeUsageAction = "add" | "convert" | "remove_all" | "reset";
+
+interface MutationResult {
+    ok: boolean;
+    changed?: boolean;
+    mutationChanges?: boolean[];
+    parsed?: ParsedGsap;
+    before?: string;
+    after?: string;
+    scriptText?: string;
+}
+interface CommitMutationOptions {
+    label: string;
+    keyframeTelemetry?: boolean;
+    keyframeAction?: KeyframeUsageAction;
+    keyframeProperty?: string;
+    /** Observe the durable writer result without duplicating the request path. */
+    onResult?: (result: MutationResult) => void;
+    coalesceKey?: string;
+    coalesceMs?: number;
+    softReload?: boolean;
+    skipReload?: boolean;
+    /**
+     * Write the source but leave the preview alone; the caller renders once when it
+     * is done. For a multi-write action like a group drag, rendering after each
+     * write shows a source where the members not yet written still hold their old
+     * values, so they snap back until their own write lands. This also defers the
+     * in-place runtime patch's seek, which re-renders the whole timeline and repaints
+     * the queued members the same way. Unlike `skipReload` this changes nothing about
+     * error handling — a failed write still throws.
+     */
+    deferPreviewSync?: boolean;
+    /** Carries a deferred write not yet on screen (no patch, or a missed one) to the final render. */
+    previewFallbackLatch?: {
+        pending: boolean;
+    };
+    beforeReload?: () => void;
+    pendingEdit?: StudioEditInFlight;
+    /**
+     * Serialize this commit against others sharing the same key. Used to chain
+     * per-animationId GSAP meta updates. Every commit independently takes the
+     * project/file mutation lock, so this key only adds ordering and can never
+     * bypass whole-file serialization.
+     */
+    serializeKey?: string;
+    /**
+     * Value-only edit fast path. When present, `runCommit` first tries to patch the
+     * one changed tween in the preview's runtime timeline in place
+     * (`patchRuntimeTweenInPlace`) — instant, no composition re-run, no iframe
+     * remount. On a successful patch the reload is skipped entirely (panels still
+     * refresh); when the patch can't be confidently applied it falls back to the
+     * existing soft/full reload path. Structural edits omit this and reload as before.
+     */
+    instantPatch?: {
+        selector: string;
+        change: RuntimeTweenChange;
+    };
+    /**
+     * The same fast path for a batched commit: one patch per element the batch
+     * wrote, applied in order. All of them must land for the reload to be skipped
+     * — one that can't be applied leaves the preview half-patched, so the whole
+     * batch falls back to the reload. Only the last patch re-renders (see
+     * `deferSeek`), so a ten-element batch repaints once.
+     */
+    instantPatches?: Array<{
+        selector: string;
+        change: RuntimeTweenChange;
+    }>;
+}
+
+interface TimelineGroupMoveChange {
+    element: TimelineElement;
+    start: number;
+    track?: number;
+    audioGroup?: null;
+}
+interface TimelineGroupResizeChange {
+    element: TimelineElement;
+    start: number;
+    duration: number;
+    playbackStart?: number;
+}
+interface TimelineGroupCommitOptions {
+    beforeTiming?: Promise<void>;
+    coalesceKey?: string;
+    /** Overrides the default "Move timeline clips" undo-history label. Coalescing
+     *  keeps the LAST entry's label (editHistory.ts), so a mechanical follow-up
+     *  move folded into another gesture's coalesceKey (e.g. the ripple after a
+     *  delete) should carry that gesture's own label, not its own. */
+    label?: string;
+    /** Skips this call's own generic failure toast (the error is still logged
+     *  to the console) — for a caller that shows its own more specific message
+     *  on the same failure, so the user isn't told about one action twice. */
+    suppressFailureToast?: boolean;
+}
+
+type TimelineAtomicMoveUpdates = Pick<TimelineElement, "start" | "track"> & {
+    audioGroup?: null;
+};
+type TimelineMoveOperation = "timing" | "lane-reorder" | "track-insert";
+
+interface TimelineKeyframeTarget {
+    percentage: number;
+    tweenPercentage?: number;
+    propertyGroup?: string;
+    animationId?: string;
+    collidingAnimationTargets?: AnimationKeyframeTarget[];
+}
+
+interface TimelinePropertyGroupKeyframeToggle {
+    animationId: string;
+    propertyGroup: PropertyGroupName;
+    tweenPercentage: number;
+    properties: Record<string, number | string>;
+    remove: boolean;
+}
+/** Where an outside drop lands; `insertRow` opens a new track at that row boundary of `trackOrder`. */
+type TimelineDropPlacement = {
+    start: number;
+    track: number;
+} & ({
+    insertRow?: null;
+    trackOrder?: undefined;
+} | {
+    insertRow: number;
+    trackOrder: readonly number[];
+});
+/**
+ * Shared callback signatures for timeline editing operations.
+ * Used by NLELayout, Timeline, and any component that passes through
+ * the standard set of timeline mutation handlers.
+ */
+interface TimelineDropCallbacks {
+    onFileDrop?: (files: File[], placement?: TimelineDropPlacement) => Promise<void> | void;
+    onAssetDrop?: (assetPath: string, placement: TimelineDropPlacement) => Promise<void> | void;
+    onBlockDrop?: (blockName: string, placement: {
+        start: number;
+        track: number;
+    }) => Promise<void> | void;
+    onCompositionDrop?: (sourcePath: string, placement: {
+        start: number;
+        track: number;
+    }) => Promise<void> | void;
+}
+type TimelineLinkEdit = {
+    kind: "unlink";
+    elements: readonly TimelineElement[];
+} | {
+    kind: "link";
+    elements: readonly TimelineElement[];
+} | {
+    kind: "detach";
+    element: TimelineElement;
+} | {
+    kind: "merge";
+    video: TimelineElement;
+    audio: TimelineElement;
+} | {
+    kind: "move-into-sync";
+    element: TimelineElement;
+    start: number;
+} | {
+    kind: "slip-into-sync";
+    element: TimelineElement;
+    mediaStart: number;
+};
+interface TimelineEditCallbacks {
+    onMoveElement?: (element: TimelineElement, updates: TimelineAtomicMoveUpdates) => Promise<void> | void;
+    /** Atomic multi-clip move (single undo) for main-track ripple + track-insert.
+     *  `coalesceKey` (drag-commit gesture id) merges the move history entry with a
+     *  lane change's follow-up z-reorder entry into one undo step. */
+    onMoveElements?: (edits: Array<{
+        element: TimelineElement;
+        updates: TimelineAtomicMoveUpdates;
+    }>, coalesceKey?: string, operation?: TimelineMoveOperation) => Promise<void> | void;
+    onResizeElement?: (element: TimelineElement, updates: Pick<TimelineElement, "start" | "duration" | "playbackStart">) => Promise<void> | void;
+    onResizeElements?: (changes: Array<{
+        element: TimelineElement;
+        start: number;
+        duration: number;
+        playbackStart?: number;
+    }>, options?: {
+        coalesceKey?: string;
+    }) => Promise<void> | void;
+    /**
+     * `displayNumber` is the row the CLICKED control announced. It travels with
+     * the click because the header and the undo-history label derive the row from
+     * two different orderings: the header's comes from the group-aware row list
+     * (synthetic anchor rows, members pulled contiguous), the history's from a
+     * plain ascending sort of element-bearing keys. Once a group exists those
+     * disagree, so the same click said "Hide track 2" and recorded "Hide track 1".
+     * Passing the rendered number keeps one answer instead of two derivations.
+     */
+    onToggleTrackHidden?: (track: number, hidden: boolean, displayNumber?: number | null) => Promise<void> | void;
+    /** B7's bus strip: live-write the group's own attribute while dragging. */
+    onSetAudioGroupAttributeLive?: (groupId: string, attr: string, value: string | null) => void;
+    onRevertAudioGroupAttributeLive?: (groupId: string, attr: string) => void;
+    /** ...and persist one undo entry on release. */
+    onSetAudioGroupAttributeQuiet?: (groupId: string, attr: string, value: string | null, label: string) => Promise<TimelineEditOutcome | void>;
+    /** C1's ungrouped-track FX pointer: "Group these clips" — write
+     *  `data-audio-group` on every one of them, atomically. Same shape B6's
+     *  carve auto-grouping uses. */
+    onGroupClips?: (clipIds: readonly string[], groupId: string, groupLabel?: string) => Promise<void>;
+    /** C1's single-clip FX write: addressed by the clip itself rather than the
+     *  current selection, mirroring `onSetAudioGroupAttributeLive/Quiet`. */
+    onSetElementAttributeLive?: (element: TimelineElement, attr: string, value: string | null) => void;
+    onRevertElementAttributeLive?: (element: TimelineElement, attr: string) => void;
+    onSetElementAttributeQuiet?: (element: TimelineElement, attr: string, value: string | null, label: string) => Promise<TimelineEditOutcome | void>;
+    /** One attribute on several clips, saved as one undo step. */
+    onSetElementsAttributeQuiet?: (edits: ReadonlyArray<{
+        element: TimelineElement;
+        value: string | null;
+    }>, attr: string, label: string) => Promise<TimelineEditOutcome | void>;
+    onBlockedEditAttempt?: (element: TimelineElement, intent: BlockedTimelineEditIntent) => void;
+    onLinkEdit?: (edit: TimelineLinkEdit) => Promise<void> | void;
+    onDeleteElementOnly?: (element: TimelineElement) => Promise<void> | void;
+    onSplitElement?: (element: TimelineElement, splitTime: number) => Promise<void> | void;
+    onRazorSplit?: (element: TimelineElement, splitTime: number) => Promise<void> | void;
+    onRazorSplitAll?: (splitTime: number) => Promise<void> | void;
+    onFreezeFrame?: (element: TimelineElement, time: number) => Promise<void> | void;
+    clipMenuTools?: boolean;
+    onNotice?: (message: string, tone?: "error" | "info") => void;
+    onDeleteKeyframe?: (elementId: string, keyframe: TimelineKeyframeTarget) => void;
+    onDeleteAllKeyframes?: (element: TimelineElement, animationId?: string) => void;
+    onMoveKeyframeToPlayhead?: (element: TimelineElement, keyframe: TimelineKeyframeTarget) => void;
+    /** Drag-to-retime: `keyframe` identifies the dragged keyframe (its percentage
+     *  is clip-relative), `toClipPercentage` is the neighbour-clamped drop. */
+    onMoveKeyframe?: (elementId: string, keyframe: TimelineKeyframeTarget, toClipPercentage: number) => Promise<boolean>;
+    onToggleKeyframeAtPlayhead?: (element: TimelineElement) => void;
+    onTogglePropertyGroupKeyframe?: (element: TimelineElement, target: TimelinePropertyGroupKeyframeToggle) => Promise<void> | void;
+}
+
+interface TimelineTrackStyle {
+    clip: string;
+    accent: string;
+    label: string;
+    clipActive?: string;
+}
+interface TimelineTheme {
+    shellBackground: string;
+    shellBorder: string;
+    rulerBorder: string;
+    rowBackground: string;
+    rowBorder: string;
+    gutterBackground: string;
+    gutterBorder: string;
+    textPrimary: string;
+    textSecondary: string;
+    tickText: string;
+    tickMajor: string;
+    tickMinor: string;
+    clipBackground: string;
+    clipBackgroundActive: string;
+    clipBackgroundHover: string;
+    clipBackgroundDragging: string;
+    clipBorder: string;
+    clipBorderHover: string;
+    clipBorderActive: string;
+    handleColor: string;
+    panelResizeSeam: string;
+    panelResizeActive: string;
+    clipRadius: string;
+    audioClipRadius: string;
+    transitionZone: string;
+    transitionBadge: string;
+    transitionBadgeInk: string;
+}
+
+interface TimelineTimeRange {
+    readonly start: number;
+    readonly end: number;
+}
+interface TimelineClipInterval {
+    readonly element: TimelineElement;
+    readonly identity: string;
+    readonly ordinal: number;
+    readonly start: number;
+    readonly end: number;
+}
+interface TimelineClipRowIndex {
+    readonly byStart: readonly TimelineClipInterval[];
+    readonly treeLeafCount: number;
+    readonly maxPositiveEndTree: readonly number[];
+    readonly maxPointStartTree: readonly number[];
+    readonly byIdentity: ReadonlyMap<string, readonly TimelineClipInterval[]>;
+}
+interface TimelineClipIndex {
+    readonly rows: ReadonlyMap<number, TimelineClipRowIndex>;
+}
+
+declare const TRACK_H = 48;
+interface TimelineTrackPadding {
+    top?: number;
+    bottom?: number;
+}
+interface TimelineRowGeometry {
+    readonly rowKeys: readonly number[];
+    readonly rowHeights: readonly number[];
+    /** Cumulative row boundaries, including the final bottom boundary. */
+    readonly rowOffsets: readonly number[];
+    readonly rowsHeight: number;
+    readonly padding: Readonly<Required<TimelineTrackPadding>>;
+    readonly canvasHeight: number;
+    getRowIndex(rowKey: number): number;
+    getRowHeight(row: number): number;
+    getRowTop(row: number): number;
+    getRowFromY(contentY: number): number;
+    getRowPositionFromY(contentY: number): {
+        rowFloat: number;
+        row: number;
+        fraction: number;
+        rowHeight: number;
+    };
+}
+
+type TimelineEditOverrides = Pick<TimelineEditCallbacks, "onMoveElement" | "onMoveElements" | "onResizeElement" | "onResizeElements" | "onBlockedEditAttempt" | "onSplitElement">;
+
+/** With both set, a lane move restacks the preview's z-index to match the rows; each overrides Studio's own. */
+interface TimelineStackingSyncProps {
+    previewIframeRef?: RefObject<HTMLIFrameElement | null>;
+    onZIndexReorder?: TimelineZIndexReorderCommit;
+}
+
+interface TimelineClipRenderContext {
+    priority: "overscan" | "visible" | "interaction";
+    rich: boolean;
+}
+interface TimelineClipMenuItem {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    onSelect: () => void;
+}
+interface TimelineProps extends TimelineDropCallbacks, TimelineEditOverrides, TimelineStackingSyncProps {
+    /** Project-scoped reset boundary; soft source refreshes retain the same epoch. */
+    sessionEpoch?: number;
+    onSeek?: (time: number, options?: {
+        keepPlaying?: boolean;
+        follow?: boolean;
+    }) => void;
+    onDrillDown?: (element: TimelineElement) => void;
+    /** Picture only: takes no pointer input. Interactive content goes in renderClipOverlay. */
+    renderClipContent?: (element: TimelineElement, style: {
+        clip: string;
+        label: string;
+    }, context: TimelineClipRenderContext) => ReactNode;
+    renderClipOverlay?: (element: TimelineElement) => ReactNode;
+    onDeleteElement?: (element: TimelineElement) => Promise<void> | void;
+    onSelectElement?: (element: TimelineElement | null) => void;
+    /** Notification only; null when cleared. The value lives in usePlayerStore.rangeSelection. */
+    onRangeSelect?: (range: TimelineTimeRange$1 | null) => void;
+    onCopyClip?: () => boolean;
+    onPasteClip?: () => Promise<void>;
+    onDuplicateClip?: () => Promise<boolean>;
+    canPasteClip?: () => boolean;
+    clipMenuItems?: (element: TimelineElement) => readonly TimelineClipMenuItem[];
+    splitShortcut?: string;
+    theme?: Partial<TimelineTheme>;
+    showAudioEffects?: boolean;
+    showKeyframes?: boolean;
+    trackPadding?: TimelineTrackPadding;
+    readOnly?: boolean;
+    onReadOnlyPress?: () => void;
+}
+
+interface TimelineEmptyStateProps {
+    isDragOver: boolean;
+    onFileDrop?: boolean;
+    onDragOver: DragEventHandler<HTMLDivElement>;
+    onDragLeave: DragEventHandler<HTMLDivElement>;
+    onDrop: DragEventHandler<HTMLDivElement>;
+}
+declare function TimelineEmptyState({ isDragOver, onFileDrop, onDragOver, onDragLeave, onDrop, }: TimelineEmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface Rect$1 {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+type TimelineSnapType = "beat" | "playhead" | "clip-edge" | "grid";
+interface TimelineSnapTarget {
+    time: number;
+    type: TimelineSnapType;
+}
+
+interface DraggedClipState {
+    /** Pointer captured by the viewport coordinator; null for a keyboard pickup. */
+    pointerId: number | null;
+    element: TimelineElement;
+    originClientX: number;
+    originClientY: number;
+    originScrollLeft: number;
+    originScrollTop: number;
+    pointerClientX: number;
+    pointerClientY: number;
+    pointerOffsetX: number;
+    pointerOffsetY: number;
+    previewStart: number;
+    previewTrack: number;
+    /**
+     * The lane the POINTER aims at, before the kind-zone clamp picks `previewTrack`.
+     * The commit reads it to tell a deliberate vertical lane change (stacking sync
+     * allowed) from a horizontal drag. Absent: the commit falls back to `previewTrack`.
+     */
+    desiredTrack?: number;
+    /**
+     * When non-null, the drop inserts a NEW track at this visual row boundary
+     * (0 = above the top lane, trackOrder.length = below the bottom) instead of
+     * landing on previewTrack. Drives the opened preview lane.
+     */
+    insertRow: number | null;
+    /** Snap target the clip will land on, for the guide highlight. */
+    snapTime: number | null;
+    snapType: TimelineSnapType | null;
+    started: boolean;
+    altKey?: boolean;
+}
+interface ResizingClipState {
+    /** Pointer captured by the stable viewport coordinator for this gesture. */
+    pointerId: number;
+    element: TimelineElement;
+    edge: "start" | "end";
+    originClientX: number;
+    /**
+     * scrollLeft at gesture start. Edge auto-scroll moves the content under a
+     * stationary pointer, so the trim math folds (current − origin) scrollLeft
+     * into the pointer x — mirroring resolveTimelineMove's scroll compensation.
+     * Optional so pre-existing constructors/tests stay valid; when absent the
+     * first preview update captures the current scrollLeft.
+     */
+    originScrollLeft?: number;
+    previewStart: number;
+    previewDuration: number;
+    previewPlaybackStart?: number;
+    /** Snap target the trimmed edge landed on, for the guide highlight. */
+    snapTime?: number | null;
+    snapType?: TimelineSnapType | null;
+    /** Coordinator-owned group projection; canonical elements change only on commit. */
+    groupPreview?: readonly {
+        key: string;
+        start: number;
+        duration: number;
+        playbackStart?: number;
+    }[];
+    started: boolean;
+    altKey?: boolean;
+}
+interface BlockedClipState {
+    pointerId: number;
+    element: TimelineElement;
+    intent: BlockedTimelineEditIntent;
+    originClientX: number;
+    originClientY: number;
+    started: boolean;
+}
+
+type TrackVisualStyle = TimelineTrackStyle;
+
+/** One resolved audio group, positioned in the row order. */
+interface TimelineTrackGroupInfo {
+    id: string;
+    label: string;
+    /**
+     * Synthetic sort key for the group's own row — the same fractional-key
+     * convention sub-composition expansion already uses (see
+     * timelineTrackDisplay.ts): the first (lowest) member track's number minus
+     * 0.5, so it slots in immediately above that member.
+     */
+    anchorKey: number;
+    /** Member track numbers, ascending. */
+    memberTracks: number[];
+    /**
+     * Every clip under this group, in member-track order — INDEPENDENT of whether
+     * the group is expanded.
+     *
+     * Collapsing a group stops emitting its member rows into `tracks`, so anything
+     * that recovered member elements by looking them up there got an empty list in
+     * the default (collapsed) state — silently disabling the
+     * automation-lane count, and the bus strip's member labels. Membership is not
+     * a display concern, so it does not travel through the display list.
+     */
+    memberElements: TimelineElement[];
+    /** The group element's `data-volume`, mirrored from a member's parse (B7's slider). */
+    volume: number;
+    /** The group element's `data-hidden`, mirrored from a member's parse (B5's group mute). */
+    hidden: boolean;
+    /** The group element's serialized `data-fx-chain`, mirrored from a member's parse (C1's FX entry). */
+    fxChain?: string;
+    /** The group element's serialized `data-automation` — the group's OWN lanes,
+     *  which are what its `∿` discloses (groups doc §5). */
+    automation?: string;
+}
+/**
+ * The track number of each timeline row, top to bottom: pass the player store's `elements` and
+ * `collapsedGroupIds`. A group's anchor row is its first member's track minus 0.5.
+ */
+declare function displayTrackOrder(elements: readonly TimelineElement[], collapsedGroupIds: ReadonlySet<string>): number[];
+
+interface TimelineVirtualRow {
+    readonly index: number;
+    readonly rowKey: number;
+}
+
+/**
+ * Pure geometry for the LIVE multi-selection drag preview.
+ *
+ * Visual model (matches main): while a selected clip is dragged, ALL selected
+ * clips move together LIVE as one rigid formation following the cursor. The
+ * GRABBED clip is drawn as the free-floating ghost; every OTHER selected member
+ * ("passenger") slides by the SAME time delta via a cheap compositor
+ * `translateX` (no re-layout). Passengers do NOT stay still, and they do NOT lag
+ * behind individually — the whole formation moves by one delta, spacing locked.
+ *
+ * That single delta is the GRABBED clip's `draggedPreviewStart − draggedOriginStart`.
+ * The preview start is ALREADY group-clamped upstream (computeDragPreview floors it
+ * at groupMoveFloor), so this delta is the clamped delta:
+ * the instant any member would cross 0 the grabbed clip stops and every passenger
+ * stops with it — the formation never deforms. On DROP the commit shifts every
+ * moving clip (resolveGroupMovers) by this same delta (see timelineClipDragCommit).
+ *
+ * Track changes apply to the grabbed clip only (mirroring the commit); passengers
+ * keep their lanes, so only their x moves.
+ */
+interface MultiDragPreviewInput {
+    /** The drag is live (past the movement threshold). */
+    dragStarted: boolean;
+    /** Key of the clip under the pointer. */
+    draggedKey: string;
+    /** The dragged clip's committed start (pre-drag). */
+    draggedOriginStart: number;
+    /** The dragged clip's live preview start (already group-clamped upstream). */
+    draggedPreviewStart: number;
+    /** The current multi-selection (store.selectedElementIds). */
+    selectedKeys: ReadonlySet<string>;
+}
+
+interface TimelineLogicalItem {
+    id: string;
+    kind: "clip" | "keyframe" | "ease";
+    rowId: string;
+    elementId: string;
+    /** The item's time anchor. Clips use their midpoint; ease controls use the segment midpoint. */
+    time: number;
+    element?: TimelineElement;
+    keyframeTarget?: TimelineKeyframeTarget;
+}
+interface TimelineLogicalRow {
+    id: string;
+    kind: "row";
+    physicalTrackKey: number;
+    logicalIndex: number;
+    level: 1 | 2 | 3;
+    parentId: string | null;
+    elementId: string | null;
+    /** Set only on a group's own row (level 1, no clips of its own). */
+    groupId?: string;
+    expandable: boolean;
+    expanded: boolean;
+    propertyGroup?: PropertyGroupName;
+    items: readonly TimelineLogicalItem[];
+}
+
+/**
+ * Props shared by the scroll container ({@link import("./TimelineCanvas")}) and
+ * the lane renderer ({@link import("./TimelineLanes")}). TimelineCanvas passes
+ * these straight through via spread, so they are declared once here and both
+ * prop types compose from this base — no duplicated prop list. Kept in its own
+ * module so neither side has to import the other just to name the contract.
+ */
+interface TimelineLaneBaseProps {
+    pps: number;
+    contentOrigin: number;
+    contentGutter: number;
+    trackContentWidth: number;
+    theme: TimelineTheme;
+    showAudioEffects?: boolean;
+    displayTrackOrder: number[];
+    rowHeights: readonly number[];
+    rowGeometry: TimelineRowGeometry;
+    virtualRows: readonly TimelineVirtualRow[];
+    logicalRows: readonly TimelineLogicalRow[];
+    focusedTargetId: string | null;
+    rowsVirtualized: boolean;
+    clipIndex: TimelineClipIndex;
+    renderTimeRange: TimelineTimeRange;
+    visibleTimeRange: TimelineTimeRange;
+    pinnedClipIdentities: ReadonlySet<string>;
+    trackOrder: number[];
+    tracks: [number, TimelineElement[]][];
+    trackStyles: Map<number, TrackVisualStyle>;
+    laneCounts: ReadonlyMap<string, number>;
+    selectedElementId: string | null;
+    selectedElementIds: Set<string>;
+    hoveredClip: string | null;
+    draggedClip: DraggedClipState | null;
+    blockedClipRef: React.RefObject<BlockedClipState | null>;
+    suppressClickRef: React.RefObject<boolean>;
+    scrollRef: React.RefObject<HTMLDivElement | null>;
+    renderClipContent?: TimelineProps["renderClipContent"];
+    renderClipOverlay?: TimelineProps["renderClipOverlay"];
+    onDrillDown?: (element: TimelineElement) => void;
+    onSelectElement?: (element: TimelineElement | null) => void;
+    setHoveredClip: (key: string | null) => void;
+    setShowPopover: (v: boolean) => void;
+    setRangeSelection: (v: null) => void;
+    setResizingClip: (v: ResizingClipState | null) => void;
+    setDraggedClip: (v: DraggedClipState | null) => void;
+    setSelectedElementId: (id: string | null) => void;
+    getPreviewElement: (element: TimelineElement) => TimelineElement;
+    getTrackStyle: (tag: string) => TrackVisualStyle;
+    keyframeCache?: Map<string, KeyframeCacheEntry>;
+    gsapAnimations: Map<string, GsapAnimation[]>;
+    selectedKeyframes: Set<string>;
+    currentTime: number;
+    onSeek?: (time: number) => void;
+    onSelectSegment?: (elementId: string, target: TimelineKeyframeTarget) => void;
+    onClickKeyframe?: (element: TimelineElement, target: TimelineKeyframeTarget) => void;
+    onShiftClickKeyframe?: (elementId: string, target: TimelineKeyframeTarget) => void;
+    onContextMenuKeyframe?: (e: React.MouseEvent, elementId: string, target: TimelineKeyframeTarget) => void;
+    onMoveKeyframe?: (elementId: string, keyframe: TimelineKeyframeTarget, toClipPercentage: number, propertyGroup?: string, tweenPercentage?: number, animationId?: string) => Promise<boolean>;
+    onContextMenuClip?: (e: React.MouseEvent, element: TimelineElement) => void;
+    /**
+     * Right-click on EMPTY lane space (not on a clip — those preventDefault
+     * before this fires — not the gutter/ruler, not below the lanes). `time` is
+     * the timeline time (seconds) under the pointer on that lane.
+     */
+    onContextMenuLane?: (e: React.MouseEvent, track: number, time: number) => void;
+    beatAnalysis?: MusicBeatAnalysis | null;
+    /** Resolved audio groups, positioned in row order — see useTimelineTrackDerivations. */
+    groups: readonly TimelineTrackGroupInfo[];
+}
+
+/** An empty interval on the lane, [start, end) in seconds. */
+interface TrackGapInterval {
+    start: number;
+    end: number;
+}
+
+/**
+ * One lane's gap strips for the TimelineCanvas overlay.
+ *
+ * kind "hover"    — the gap(s) a hovered "Close gap" / "Close all gaps" menu
+ *                   row would collapse: the loud affordance.
+ * kind "selected" — every empty interval on a click-selected clip's lane: the
+ *                   quiet always-on hint (single click-selection only — a
+ *                   marquee multi-select spans lanes and would paint noise).
+ */
+interface TimelineLaneGapStrips {
+    track: number;
+    intervals: TrackGapInterval[];
+    kind: "hover" | "selected";
+}
+
+interface KeyframeDiamondContextMenuState {
+    x: number;
+    y: number;
+    /** Timeline project session that created this portaled target. */
+    sessionEpoch?: number;
+    element: TimelineElement;
+    elementId: string;
+    percentage: number;
+    tweenPercentage?: number;
+    propertyGroup?: string;
+    animationId?: string;
+    currentEase?: string;
+}
+
+type TimelineCanvasState = Omit<TimelineLaneBaseProps, "setRangeSelection" | "setResizingClip" | "setDraggedClip" | "renderClipContent" | "renderClipOverlay"> & {
+    major: number[];
+    minor: number[];
+    totalH: number;
+    effectiveDuration: number;
+    majorTickInterval: number;
+    rangeSelection: TimelineRangeSelection | null;
+    marqueeRect: Rect$1 | null;
+    resizingClip: ResizingClipState | null;
+    isScrubbing: boolean;
+    playheadRef: React.RefObject<HTMLDivElement | null>;
+    laneGapStrips: TimelineLaneGapStrips[];
+    dropPreview: TimelineDropPlacement | null;
+    acceptsMediaDrop: boolean;
+    setRangeSelection: (value: TimelineRangeSelection | null) => void;
+    setResizingClip: (value: ResizingClipState | null) => void;
+    setDraggedClip: (value: TimelineLaneBaseProps["draggedClip"]) => void;
+    beatDragging: boolean;
+    onResizeElement: TimelineEditCallbacks["onResizeElement"];
+    onMoveElement: TimelineEditCallbacks["onMoveElement"];
+    draggedElement: TimelineElement | null;
+    snapGuide: TimelineSnapTarget | null;
+    multiDragPreview: MultiDragPreviewInput | null;
+    onToggleTrackHidden: TimelineEditCallbacks["onToggleTrackHidden"];
+    onTogglePropertyGroupKeyframe: TimelineEditCallbacks["onTogglePropertyGroupKeyframe"];
+    onRazorSplit: TimelineEditCallbacks["onRazorSplit"];
+    onRazorSplitAll: TimelineEditCallbacks["onRazorSplitAll"];
+};
+interface ClipContextMenuState {
+    x: number;
+    y: number;
+    element: TimelineElement;
+    sessionEpoch: number;
+}
+interface TrackGapContextMenuState {
+    x: number;
+    y: number;
+    gapWidth: number | null;
+    canCloseGap: boolean;
+    canCloseAllGaps: boolean;
+    hasAnyGaps: boolean;
+}
+interface TimelineOverlaysState {
+    elements: readonly TimelineElement[];
+    elementsRef: {
+        current: readonly TimelineElement[];
+    };
+    theme: TimelineTheme;
+    showShortcutHint: boolean;
+    showPopover: boolean;
+    rangeSelection: TimelineRangeSelection | null;
+    setShowPopover: (value: boolean) => void;
+    setRangeSelection: (value: TimelineRangeSelection | null) => void;
+    kfContextMenu: KeyframeDiamondContextMenuState | null;
+    setKfContextMenu: (value: KeyframeDiamondContextMenuState | null) => void;
+    onDeleteKeyframe: TimelineEditCallbacks["onDeleteKeyframe"];
+    onDeleteAllKeyframes: TimelineEditCallbacks["onDeleteAllKeyframes"];
+    onMoveKeyframeToPlayhead: TimelineEditCallbacks["onMoveKeyframeToPlayhead"];
+    clipContextMenu: ClipContextMenuState | null;
+    setClipContextMenu: (value: ClipContextMenuState | null) => void;
+    currentTime: number;
+    onSplitElement: TimelineEditCallbacks["onSplitElement"];
+    pinZoomBeforeEdit: () => void;
+    onDeleteElement?: (element: TimelineElement) => Promise<void> | void;
+    onCopyClip?: () => boolean;
+    onPasteClip?: () => Promise<void>;
+    onDuplicateClip?: () => Promise<boolean>;
+    canPasteClip?: () => boolean;
+    clipMenuItems?: TimelineProps["clipMenuItems"];
+    splitShortcut?: TimelineProps["splitShortcut"];
+    gapContextMenu: TrackGapContextMenuState | null;
+    onDismissGapContextMenu: () => void;
+    onCloseTrackGap: () => void;
+    onCloseAllTrackGaps: () => void;
+    onHoverGapAction: (action: "close-gap" | "close-all" | null) => void;
+}
+interface TimelineContainerProps {
+    ref: RefCallback<HTMLDivElement>;
+    "aria-label": string;
+    "data-timeline-element-count": number;
+    className: string;
+    onMouseMove: (event: MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave: () => void;
+    style: CSSProperties;
+}
+interface TimelineViewportProps {
+    ref: RefCallback<HTMLDivElement>;
+    "data-timeline-scroll-viewport": boolean;
+    "data-timeline-auto-scroll-left-inset": number;
+    "data-timeline-content-origin": number;
+    tabIndex: number;
+    className: string;
+    onScroll: (event: UIEvent<HTMLDivElement>) => void;
+    onFocus: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onDragOver: (event: React.DragEvent<HTMLDivElement>) => void;
+    onDragLeave: (event: React.DragEvent<HTMLDivElement>) => void;
+    onDrop: (event: React.DragEvent<HTMLDivElement>) => void;
+    onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerMove: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerCancel: (event: PointerEvent<HTMLDivElement>) => void;
+    onLostPointerCapture: (event: PointerEvent<HTMLDivElement>) => void;
+}
+interface TimelineState {
+    timelineReady: boolean;
+    elements: readonly TimelineElement[];
+    selectedElementId: string | null;
+    sessionEpoch: number;
+    keyframeCache: Map<string, KeyframeCacheEntry>;
+    canvas: TimelineCanvasState;
+    overlays: TimelineOverlaysState;
+}
+interface TimelineActions {
+    renderClipContent: TimelineLaneBaseProps["renderClipContent"];
+    renderClipOverlay: TimelineLaneBaseProps["renderClipOverlay"];
+    setFocusedEaseSegment: (target: {
+        animationId: string;
+        collidingAnimationTargets?: AnimationKeyframeTarget[];
+        tweenPercentage: number;
+        elementId: string;
+    }) => void;
+}
+interface TimelineMeta {
+    emptyState: ComponentProps<typeof TimelineEmptyState>;
+    containerProps: TimelineContainerProps;
+    viewportProps: TimelineViewportProps;
+    razorGuide: ReactNode;
+}
+interface TimelineContextValue {
+    state: TimelineState;
+    actions: TimelineActions;
+    meta: TimelineMeta;
+}
+declare function TimelineProvider({ children, readOnly, onReadOnlyPress, ...props }: TimelineProps & {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useTimelineContext(): TimelineContextValue;
+
+declare function TimelineOverlays(): react_jsx_runtime.JSX.Element;
+
+/** The provider-backed canvas shell. */
+declare function TimelineFrame(): react_jsx_runtime.JSX.Element;
+/** The provider-backed ruler. */
+declare const TimelineRuler: typeof TimelineRulerPart;
+/**
+ * The provider-backed lane renderer. TimelineFrame remains the composed Studio
+ * canvas; this part is exported for hosts that own the canvas arrangement.
+ */
+declare function TimelineLanes(): react_jsx_runtime.JSX.Element;
+/** The provider-backed playhead indicator. */
+declare function TimelinePlayhead(): react_jsx_runtime.JSX.Element;
+/** The provider-backed razor guide. */
+declare function TimelineRazorGuide(): react.ReactNode;
+
+declare function TimelineEmptyStatePart(): react_jsx_runtime.JSX.Element;
+declare function TimelineShortcutHint(): react_jsx_runtime.JSX.Element;
+declare function TimelineEditPopover(): react_jsx_runtime.JSX.Element;
+declare function TimelineClipMenu(): react_jsx_runtime.JSX.Element;
+declare function TimelineKeyframeMenu(): react_jsx_runtime.JSX.Element;
+declare function TimelineGapMenu(): react_jsx_runtime.JSX.Element;
+
+declare const Timeline: react.NamedExoticComponent<TimelineProps> & {
+    Provider: typeof TimelineProvider;
+    Frame: typeof TimelineFrame;
+    Ruler: typeof TimelineRulerPart;
+    Lanes: typeof TimelineLanes;
+    Playhead: typeof TimelinePlayhead;
+    RazorGuide: typeof TimelineRazorGuide;
+    ShortcutHint: typeof TimelineShortcutHint;
+    EditPopover: typeof TimelineEditPopover;
+    ClipMenu: typeof TimelineClipMenu;
+    KeyframeMenu: typeof TimelineKeyframeMenu;
+    GapMenu: typeof TimelineGapMenu;
+    EmptyState: typeof TimelineEmptyStatePart;
+    Overlays: typeof TimelineOverlays;
+};
+
+type ThumbnailPriority = "overscan" | "visible" | "interaction";
+
+interface VideoThumbnailProps {
+    videoSrc: string;
+    label: string;
+    labelColor: string;
+    duration?: number;
+    sourceStart?: number;
+    sourceRangeDuration?: number;
+    projectId?: string;
+    sessionEpoch?: number;
+    priority?: ThumbnailPriority;
+}
+/** Sparse, bounded video frames supplied by the shared thumbnail scheduler. */
+declare const VideoThumbnail: react.NamedExoticComponent<VideoThumbnailProps>;
+
+interface CompositionThumbnailProps {
+    previewUrl: string;
+    label: string;
+    labelColor: string;
+    selector?: string;
+    selectorIndex?: number;
+    seekTime?: number;
+    duration?: number;
+    width?: number;
+    height?: number;
+    projectId?: string;
+    sessionEpoch?: number;
+    contentRevision?: number;
+    priority?: ThumbnailPriority;
+    rich?: boolean;
+}
+/** Server-rendered composition poster, deduplicated and budgeted by project/session. */
+declare const CompositionThumbnail: react.NamedExoticComponent<CompositionThumbnailProps>;
+
+/**
+ * React callbacks for synchronising the player store from iframe runtime data.
+ *
+ * Covers four related concerns:
+ *  - processTimelineMessage  — turn a clip-manifest postMessage into TimelineElements
+ *  - enrichMissingCompositions — fill gaps the manifest misses (element-ref starts)
+ *  - initializeAdapter        — called after iframe load: seek, set duration, read elements
+ *  - onIframeLoad             — orchestrates initializeAdapter with a message-based fallback
+ */
+
+type PreviewIframeRole = "live" | "shadow";
+interface PreviewIframeSlot {
+    gen: number;
+    role: PreviewIframeRole;
+    url?: string;
+}
+
+/**
+ * Runtime iframe integration utilities.
+ *
+ * Handles the boundary between the studio host page and the preview iframe:
+ * - Viewport normalisation on load
+ * - Auto-healing missing data-composition-id attributes
+ * - Unmuting media via postMessage
+ * - Resolving the underlying <iframe> from any wrapper element
+ * - Scanning the DOM for composition hosts the manifest missed
+ *   (element-reference starts that the CDN runtime fails to resolve)
+ */
+
+/**
+ * Resolve the underlying iframe from any host element. Supports:
+ * - Direct `<iframe>` element (most common — studio's own `Player.tsx`)
+ * - Custom elements (e.g. `<hyperframes-player>`) whose shadow DOM contains an iframe
+ * - Wrapper elements whose light DOM contains a descendant iframe
+ *
+ * Exported so web-component consumers can pre-resolve the iframe before
+ * assigning it to `iframeRef` returned by `useTimelinePlayer`. Returns `null`
+ * when the element has no associated iframe yet.
+ *
+ * @example
+ * ```tsx
+ * const { iframeRef } = useTimelinePlayer();
+ * const playerElRef = useRef<HyperframesPlayer>(null);
+ *
+ * useEffect(() => {
+ *   iframeRef.current = resolveIframe(playerElRef.current);
+ * }, [iframeRef]);
+ * ```
+ */
+declare function resolveIframe(el: Element | null): HTMLIFrameElement | null;
+
+interface UseTimelinePlayerOptions {
+    /** Runs right after a reloaded preview becomes the live iframe. */
+    onShadowPromoted?: () => void;
+    /** A reload was abandoned (cause in the message); the previous preview is still showing. */
+    onPreviewReloadFailed?: (message: string) => void;
+}
+declare function useTimelinePlayer({ onShadowPromoted, onPreviewReloadFailed, }?: UseTimelinePlayerOptions): {
+    iframeRef: react.RefObject<HTMLIFrameElement | null>;
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+    seek: (time: number, options?: {
+        keepPlaying?: boolean;
+        follow?: boolean;
+    }) => boolean;
+    onIframeLoad: (context?: number) => void;
+    refreshPlayer: () => void;
+    saveSeekPosition: () => boolean;
+    resetPlayer: () => void;
+    previewSlots: PreviewIframeSlot[];
+    onShadowIframeLoad: (context?: number) => void;
+    onShadowReadyChange: (gen: number, ready: boolean) => void;
+    onShadowError: (gen: number, cause: string) => void;
+    setShadowIframeNode: (node: HTMLIFrameElement | null) => void;
+    resetPreviewSlots: () => void;
+};
+
+interface PlayerHandleElement {
+    id: string;
+    start: number;
+    end: number;
+    selector?: string;
+    sourceFile?: string;
+    compositionSrc?: string;
+}
+type PlayerHandleListener = () => void;
+type PlayerHandleTimeListener = (time: number) => void;
+interface PlayerHandle {
+    ready: boolean;
+    playing: boolean;
+    seek: (seconds: number) => boolean;
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+    readonly currentTime: number;
+    duration: number;
+    elements: PlayerHandleElement[];
+    subscribe: (listener: PlayerHandleListener) => () => void;
+    subscribeTime: (listener: PlayerHandleTimeListener) => () => void;
+}
+/**
+ * Reads and controls the shell player. Call this under EditorShell/NLEProvider;
+ * the provider owns the mounted preview iframe and the single player instance.
+ */
+declare function usePlayerHandle(): PlayerHandle;
+
+declare function formatTime(time: number): string;
+
+/** A host's verdict on one element: editable, or blocked with a reason to show. */
+type TimelineEditPermission = true | {
+    blocked: true;
+    reason: string;
+};
+type CanEditTimelineElement = (element: TimelineElement) => TimelineEditPermission;
+/** What an effect save did: landed, refused before writing, or failed while writing. */
+type TimelineEditOutcome = {
+    status: "saved";
+} | {
+    status: "refused" | "failed";
+    reason: string;
+};
+
+interface TimelineEditCallbackDeps {
+    handleTimelineElementMove: (element: TimelineElement, updates: Pick<TimelineElement, "start" | "track">) => Promise<void> | void;
+    handleTimelineElementsMove: (edits: Array<{
+        element: TimelineElement;
+        updates: Pick<TimelineElement, "start" | "track">;
+    }>, coalesceKey?: string, operation?: TimelineMoveOperation) => Promise<void> | void;
+    handleTimelineElementResize: (element: TimelineElement, updates: Pick<TimelineElement, "start" | "duration" | "playbackStart">) => Promise<void> | void;
+    handleTimelineGroupResize: NonNullable<TimelineEditCallbacks["onResizeElements"]>;
+    handleToggleTrackHidden: (track: number, hidden: boolean) => Promise<void> | void;
+    setAudioGroupAttribute: {
+        setLive: (groupId: string, attr: string, value: string | null) => void;
+        revertLive?: (groupId: string, attr: string) => void;
+        setQuiet: (groupId: string, attr: string, value: string | null, label: string) => Promise<TimelineEditOutcome | void>;
+    };
+    handleBlockedTimelineEdit: (element: TimelineElement, intent: BlockedTimelineEditIntent) => void;
+    handleTimelineElementSplit: (element: TimelineElement, splitTime: number) => Promise<void> | void;
+    handleRazorSplit: (element: TimelineElement, splitTime: number) => Promise<void> | void;
+    handleRazorSplitAll: (splitTime: number) => Promise<void> | void;
+    handleFreezeFrame?: (element: TimelineElement, time: number) => Promise<void> | void;
+    handleLinkEdit?: TimelineEditCallbacks["onLinkEdit"];
+    handleTimelineElementDeleteOnly?: TimelineEditCallbacks["onDeleteElementOnly"];
+    /** C1's ungrouped-track FX pointer — same auto-grouping write B6's carve uses. */
+    handleGroupClips?: (clipIds: readonly string[], groupId: string, groupLabel?: string) => Promise<void>;
+    /** C1's single-clip FX write, addressed by the clip itself. */
+    setElementFxAttribute?: {
+        setLive: (element: TimelineElement, attr: string, value: string | null) => void;
+        revertLive?: (element: TimelineElement, attr: string) => void;
+        setQuiet: (element: TimelineElement, attr: string, value: string | null, label: string) => Promise<TimelineEditOutcome | void>;
+        setMany?: TimelineEditCallbacks["onSetElementsAttributeQuiet"];
+    };
+}
+
+interface BlockPreviewInfo {
+    videoUrl?: string;
+    posterUrl?: string;
+    title: string;
+}
+
+type GestureRecordingState = "idle" | "recording" | "preview";
+
+type RenderClipContent = (element: TimelineElement, style: {
+    clip: string;
+    label: string;
+}) => ReactNode;
+interface EditorShellProps extends TimelineEditCallbackDeps {
+    /** Dock.Panel elements for every panel except the built-in preview and timeline. */
+    panels: ReactNode;
+    timelineToolbar: ReactNode;
+    renderClipContent: RenderClipContent;
+    handleTimelineElementDelete: (element: TimelineElement) => Promise<void> | void;
+    handleTimelineAssetDrop: (assetPath: string, placement: TimelineDropPlacement) => Promise<void> | void;
+    handleTimelineBlockDrop?: (blockName: string, placement: TimelineDropPlacement) => Promise<void> | void;
+    handleTimelineCompositionDrop?: (sourcePath: string, placement: TimelineDropPlacement) => Promise<void> | void;
+    handlePreviewBlockDrop?: (blockName: string, position: {
+        left: number;
+        top: number;
+    }) => Promise<void> | void;
+    handleTimelineFileDrop: (files: File[], placement?: TimelineDropPlacement) => Promise<void> | void;
+    onCopyClip: () => boolean;
+    onPasteClip: () => Promise<void>;
+    onDuplicateClip: () => Promise<boolean>;
+    canPasteClip: () => boolean;
+    clipMenuItems?: TimelineProps["clipMenuItems"];
+    splitShortcut?: TimelineProps["splitShortcut"];
+    setCompIdToSrc: (map: Map<string, string>) => void;
+    setCompositionLoading: (loading: boolean) => void;
+    shouldShowMotionPath: boolean;
+    shouldShowSelectedDomBounds: boolean;
+    blockPreview?: BlockPreviewInfo | null;
+    isGestureRecording?: boolean;
+    recordingState?: GestureRecordingState;
+    onToggleRecording?: () => void;
+    /**
+     * Host layer over the preview, positioned with `usePreviewCompositionRect`. Hidden in
+     * fullscreen and during a block preview; below the selection overlay past z-index 10.
+     */
+    gestureOverlay?: ReactNode;
+    /** Clicks still select and report; the preview cannot move, edit or delete anything. */
+    readOnlyPreview?: boolean;
+    /** Short text shown on disabled hand-edit controls while `readOnlyPreview` is set. */
+    readOnlyPreviewReason?: string;
+}
+declare const EditorShell: react.NamedExoticComponent<EditorShellProps>;
+
+interface PreviewCompositionSize {
+    width: number;
+    height: number;
+}
+
+interface CompositionLevel {
+    /** Unique id — "master" or composition file path */
+    id: string;
+    /** Display label — "Master" or filename without extension */
+    label: string;
+    /** Preview URL for this composition level */
+    previewUrl: string;
+}
+interface CompositionBreadcrumbProps {
+    stack: CompositionLevel[];
+    onNavigate: (index: number) => void;
+}
+declare function CompositionBreadcrumb({ stack, onNavigate }: CompositionBreadcrumbProps): react_jsx_runtime.JSX.Element | null;
+
+interface NLEContextValue {
+    projectId: string;
+    iframeRef: React.MutableRefObject<HTMLIFrameElement | null>;
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+    seek: (time: number, options?: {
+        keepPlaying?: boolean;
+        follow?: boolean;
+    }) => boolean;
+    refreshPlayer: () => void;
+    onIframeLoad: () => void;
+    previewSlots: PreviewIframeSlot[];
+    onShadowIframeLoad: (gen: number) => void;
+    onShadowReadyChange: (gen: number, ready: boolean) => void;
+    onShadowError: (gen: number, message: string) => void;
+    setShadowIframeNode: (node: HTMLIFrameElement | null) => void;
+    resetPreviewSlots: () => void;
+    containerRef: React.MutableRefObject<HTMLDivElement | null>;
+    compositionStack: CompositionLevel[];
+    updateCompositionStack: React.Dispatch<React.SetStateAction<CompositionLevel[]>>;
+    handleNavigateComposition: (index: number) => void;
+    handleDrillDown: (element: TimelineElement) => void;
+    compIdToSrc: Map<string, string>;
+    compositionLoading: boolean;
+    setCompositionLoading: (loading: boolean) => void;
+    timelineDisabled: boolean;
+    timelineSessionEpoch: number;
+    hasLoadedOnceRef: React.MutableRefObject<boolean>;
+    previewCompositionSize: {
+        width: number;
+        height: number;
+    } | null;
+    setPreviewCompositionSize: (size: {
+        width: number;
+        height: number;
+    } | null) => void;
+}
+
+interface NLEPreviewProps extends Pick<NLEContextValue, "projectId" | "onIframeLoad" | "previewSlots" | "onShadowIframeLoad" | "onShadowReadyChange" | "onShadowError" | "setShadowIframeNode" | "resetPreviewSlots"> {
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    onCompositionLoadingChange?: (loading: boolean) => void;
+    portrait?: boolean;
+    directUrl?: string;
+    suppressLoadingOverlay?: boolean;
+    onStageRef?: (ref: React.RefObject<HTMLDivElement | null>) => void;
+    /** Reports the authored composition size measured from the loaded preview. */
+    onCompositionSizeChange?: (size: PreviewCompositionSize | null) => void;
+    /** Draws the picture edge to edge in this box, without Studio's inset band. */
+    fillBox?: boolean;
+}
+declare const NLEPreview: react.NamedExoticComponent<NLEPreviewProps>;
+
+interface ShortcutsButtonProps {
+    sections?: readonly ShortcutSection[];
+    disabled?: boolean;
+    onSeek?: (time: number) => void;
+}
+declare function ShortcutsButton({ sections, disabled, onSeek }: ShortcutsButtonProps): react_jsx_runtime.JSX.Element;
+
+interface LinkShortcutCallbacks {
+    handleLinkEdit?: TimelineEditCallbacks["onLinkEdit"];
+    handleTimelineElementDeleteOnly?: TimelineEditCallbacks["onDeleteElementOnly"];
+}
+/** ⌘L unlink/link, ⌥⇧D detach audio, ⌥⌫ delete one linked clip — the clip menu's shortcuts. */
+declare function dispatchLinkShortcut(event: KeyboardEvent, cb: LinkShortcutCallbacks): boolean;
+
+interface UseCompositionStackOptions {
+    projectId: string;
+    activeCompositionPath?: string | null;
+    onCompositionChange?: (compositionPath: string | null) => void;
+}
+interface UseCompositionStackResult {
+    compositionStack: CompositionLevel[];
+    updateCompositionStack: React.Dispatch<React.SetStateAction<CompositionLevel[]>>;
+    handleNavigateComposition: (index: number) => void;
+    handleDrillDown: (element: {
+        id: string;
+        compositionSrc?: string;
+    }) => void;
+    masterSeekRef: React.MutableRefObject<number>;
+    compIdToSrc: Map<string, string>;
+    setCompIdToSrc: React.Dispatch<React.SetStateAction<Map<string, string>>>;
+}
+declare function useCompositionStack({ projectId, activeCompositionPath, onCompositionChange, }: UseCompositionStackOptions): UseCompositionStackResult;
+
+declare const PANEL_IDS: readonly ["preview", "timeline", "compositions", "assets", "code", "catalog", "design", "layers", "renders", "variables", "slideshow"];
+type PanelId = (typeof PANEL_IDS)[number];
+type PanelZone = "left" | "center" | "right";
+
+declare function Root({ projectId, panels, storageKey, dockWidth, children, }: {
+    projectId: string | null;
+    panels?: readonly PanelId[];
+    storageKey?: string;
+    dockWidth?: () => number;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function Panel({ id, title, children }: {
+    id: PanelId;
+    title?: string;
+    children: ReactNode;
+}): react.ReactPortal | null;
+declare function WindowMenu(): react_jsx_runtime.JSX.Element;
+declare const Dock: {
+    Root: typeof Root;
+    Panel: typeof Panel;
+    WindowMenu: typeof WindowMenu;
+};
+
+/** The narrow surface Dock.Root exposes; dockview types never leave the dock folder. */
+interface DockController {
+    /** Adds the panel at its default place if it is closed; never moves focus. */
+    open: (id: PanelId) => void;
+    /** Focuses the panel, reopening it at its default place if it was closed. */
+    activate: (id: PanelId) => void;
+    setTitle: (id: PanelId, title: string) => void;
+    close: (id: PanelId) => void;
+    /** Hides or shows the panel's whole tab group without closing it. */
+    setGroupVisible: (id: PanelId, visible: boolean) => void;
+    reset: () => void;
+}
+interface DockSnapshot {
+    openPanels: ReadonlySet<PanelId>;
+    /** Open panels whose tab is showing and whose group is not hidden. */
+    visiblePanels: ReadonlySet<PanelId>;
+    activePanel: PanelId | null;
+    /** The tab each group shows, so a restored layout still records what every side column last showed. */
+    groupActivePanels?: readonly PanelId[];
+}
+type LastActive = Partial<Record<PanelZone, PanelId>>;
+interface DockLayoutState extends DockSnapshot {
+    controller: DockController | null;
+    panels: readonly PanelId[];
+    lastActive: LastActive;
+    /** An activation requested before the dock mounted; Dock.Root applies it on ready. */
+    pendingActivation: PanelId | null;
+    attach: (controller: DockController, panels?: readonly PanelId[]) => void;
+    detach: () => void;
+    sync: (snapshot: DockSnapshot) => void;
+    takePendingActivation: () => PanelId | null;
+    activatePanel: (id: PanelId) => void;
+    closePanel: (id: PanelId) => void;
+    togglePanel: (id: PanelId) => void;
+    setZoneVisible: (zone: PanelZone, visible: boolean) => void;
+    resetLayout: () => void;
+}
+declare const useDockLayoutStore: zustand.UseBoundStore<zustand.StoreApi<DockLayoutState>>;
+
+interface PreviewIframeState {
+    iframe: HTMLIFrameElement | null;
+    setIframe: (iframe: HTMLIFrameElement | null) => void;
+}
+/** The one owner of "the live preview iframe element"; a promoted reload replaces it. */
+declare const usePreviewIframeStore: zustand.UseBoundStore<zustand.StoreApi<PreviewIframeState>>;
+
+interface AudioGainDialogState {
+    targetKeys: readonly string[] | null;
+    open: (keys: readonly string[]) => void;
+    close: () => void;
+}
+/** Which clips the Audio Gain dialog (G) is open for. */
+declare const useAudioGainDialogStore: zustand.UseBoundStore<zustand.StoreApi<AudioGainDialogState>>;
+/** Open Audio Gain for the selection (or the clicked clip); false when none of it has sound. */
+declare function openAudioGainDialog(clicked?: TimelineElement): boolean;
+
+type FadeEdge = "in" | "out";
+/** The clip as drawn; `toolsLeft` is where its FX badge starts, null when it has none. */
+interface FadeHandleClipBox {
+    width: number;
+    height: number;
+    radius: number;
+    toolsLeft: number | null;
+}
+/** A fade handle's hit box in px from the clip's top left; `tabLeft` is its tab's centre within it. */
+interface FadeHandleBox {
+    left: number;
+    width: number;
+    height: number;
+    tabLeft: number;
+    top: number;
+}
+/**
+ * Where the fade handles sit on a clip `widthPx` wide: each centred on its fade's end, inside the
+ * clip and left of its tools; two drawn handles that would overlap split at the midpoint.
+ */
+declare function fadeHandleBoxes(input: {
+    widthPx: number;
+    inPx: number;
+    outPx: number;
+    clipBox: FadeHandleClipBox;
+    drawn: Record<FadeEdge, boolean>;
+}): Record<FadeEdge, FadeHandleBox>;
+
+interface AudioWaveformProps {
+    audioUrl: string;
+    waveformUrl?: string;
+    label: string;
+    labelColor: string;
+    trimStartFraction?: number;
+    trimEndFraction?: number;
+    projectId: string;
+    sessionEpoch: number;
+    priority: ThumbnailPriority;
+    /** `data-hidden` or a muted audio group. Greys the pill; the clip stays. */
+    muted?: boolean;
+    labelInset?: number;
+}
+/** Bounded waveform subscriber; cache, cancellation and dedupe live in one scheduler. */
+declare const AudioWaveform: react.NamedExoticComponent<AudioWaveformProps>;
+
+interface ImageThumbnailProps {
+    imageSrc: string;
+    label: string;
+    labelColor: string;
+    projectId?: string;
+    sessionEpoch?: number;
+    priority?: ThumbnailPriority;
+    rich?: boolean;
+}
+/** A scheduler-backed still-image strip. Mounting is the sole work trigger. */
+declare const ImageThumbnail: react.NamedExoticComponent<ImageThumbnailProps>;
+
+interface UseRenderClipContentOptions {
+    projectIdRef: {
+        current: string | null;
+    };
+    compIdToSrc: Map<string, string>;
+    activePreviewUrl: string | null;
+    effectiveTimelineDuration: number;
+}
+declare function useRenderClipContent({ projectIdRef, compIdToSrc, activePreviewUrl, effectiveTimelineDuration, }: UseRenderClipContentOptions): (el: TimelineElement, style: {
+    clip: string;
+    label: string;
+}, context?: TimelineClipRenderContext) => ReactNode;
+
+interface UseThumbnailStillOptions {
+    sessionEpoch?: number;
+    priority?: ThumbnailPriority;
+}
+type ThumbnailStill = {
+    status: "loading";
+} | {
+    status: "ready";
+    url: string;
+} | {
+    status: "failed";
+};
+/** A host picture's server still through the thumbnail scheduler, so it yields to a preview reload. */
+declare function useThumbnailStill(url: string | null, projectId: string, { sessionEpoch, priority }?: UseThumbnailStillOptions): ThumbnailStill;
+
+interface DomEditCompositionRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    scaleX: number;
+    scaleY: number;
+}
+
+/**
+ * Where the composition sits inside `overlayRef`, in overlay pixels, plus the scale from
+ * composition units to pixels.
+ */
+declare function usePreviewCompositionRect(overlayRef: RefObject<HTMLDivElement | null>, iframe: HTMLIFrameElement | null): DomEditCompositionRect;
+
+interface PreviewSnapPreferences {
+    snapEnabled: boolean;
+    gridVisible: boolean;
+    gridSpacing: number;
+    snapToGrid: boolean;
+}
+interface PreviewOverlayContextValue {
+    state: {
+        snapPrefs: PreviewSnapPreferences;
+        rulerVisible: boolean;
+        safeMarginsVisible: boolean;
+        iframeRef: RefObject<HTMLIFrameElement | null>;
+        compositionRect: DomEditCompositionRect;
+    };
+    actions: {
+        setSnapPrefs: (patch: Partial<PreviewSnapPreferences>) => void;
+        toggleRulers: () => void;
+        toggleSafeMargins: () => void;
+    };
+}
+interface PreviewOverlayProviderProps {
+    iframe?: HTMLIFrameElement | null;
+    children: ReactNode;
+}
+declare function PreviewOverlayProvider({ iframe, children }: PreviewOverlayProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePreviewOverlayContext(): PreviewOverlayContextValue;
+
+/** Ruler and safe-margin boxes drawn over the preview pane, never inside the composition. */
+declare const PreviewGuides: react.NamedExoticComponent<object>;
+
+declare const GridOverlay: react.NamedExoticComponent<object>;
+
+declare const SnapToolbar: react.NamedExoticComponent<object>;
+
+type GuideKey = "rulerVisible" | "safeMarginsVisible";
+interface PreviewGuidesState {
+    rulerVisible: boolean;
+    safeMarginsVisible: boolean;
+    toggle: (key: GuideKey) => void;
+}
+declare const usePreviewGuidesStore: zustand.UseBoundStore<zustand.StoreApi<PreviewGuidesState>>;
+
+interface SourceEditorProps {
+    content: string;
+    filePath?: string;
+    language?: string;
+    onChange?: (content: string) => void;
+    readOnly?: boolean;
+    revealOffset?: number | null;
+}
+declare const SourceEditor: react.NamedExoticComponent<SourceEditorProps>;
+
+interface GeometryCommitResult {
+    ok: true;
+    changed: boolean;
+}
+
+/**
+ * Edit callbacks shared by GsapAnimationSection and each AnimationCard it
+ * renders. Extracted so the two prop interfaces don't duplicate the (large)
+ * signatures the section forwards straight through to the card.
+ */
+interface GsapAnimationEditCallbacks {
+    onUpdateProperty: (animationId: string, property: string, value: number | string) => void;
+    onUpdateMeta: (animationId: string, updates: {
+        duration?: number;
+        ease?: string;
+        position?: number;
+    }) => void;
+    onDeleteAnimation: (animationId: string) => void;
+    onAddProperty: (animationId: string, property: string) => void;
+    onRemoveProperty: (animationId: string, property: string) => void;
+    onUpdateFromProperty?: (animationId: string, property: string, value: number | string) => void;
+    onAddFromProperty?: (animationId: string, property: string) => void;
+    onRemoveFromProperty?: (animationId: string, property: string) => void;
+    onLivePreview?: (property: string, value: number | string) => void;
+    onLivePreviewEnd?: () => void;
+    onSetArcPath?: (animationId: string, config: {
+        enabled: boolean;
+        autoRotate?: boolean | number;
+        segments?: ArcPathSegment[];
+    }) => void;
+    onUpdateArcSegment?: (animationId: string, segmentIndex: number, update: Partial<ArcPathSegment>) => void;
+    onUpdateKeyframeEase?: (animationId: string, percentage: number, ease: string) => void;
+    onUpdateSegmentEase?: (targets: AnimationKeyframeTarget[], ease: string) => void;
+    /** Apply one ease to every keyframe segment at once (clears per-segment overrides). */
+    onSetAllKeyframeEases?: (animationId: string, ease: string) => void;
+    /** Unroll a computed (helper/loop) tween into literal tweens so it edits directly. */
+    onUnroll?: (animationId: string) => void;
+}
+
+interface BackgroundRemovalProgress {
+    status: "processing" | "complete" | "failed";
+    progress: number;
+    stage?: string;
+    outputPath?: string;
+    backgroundOutputPath?: string;
+    error?: string;
+    provider?: string;
+}
+interface BackgroundRemovalResult {
+    outputPath: string;
+    backgroundOutputPath?: string;
+    provider?: string;
+}
+interface MediaOverlayPlacement {
+    start: number;
+    duration?: number;
+    track?: number;
+    compositionPath?: string;
+}
+type AddMediaOverlayHandler = (blockName: string, placement: MediaOverlayPlacement) => Promise<void>;
+interface PropertyPanelProps {
+    projectId: string;
+    projectDir: string | null;
+    assets: string[];
+    element: DomEditSelection | null;
+    multiSelectCount?: number;
+    multiSelectedElements?: DomEditSelection[];
+    onGroupSelection?: () => void;
+    onHideAllSelected?: () => void;
+    copiedAgentPrompt: boolean;
+    onClearSelection: () => void;
+    onUngroup?: () => void;
+    onSetStyle: (prop: string, value: string) => void | Promise<unknown>;
+    onPreviewStyle?: (prop: string, value: string) => void;
+    onSetAttribute: (attr: string, value: string) => void | Promise<void>;
+    /** Commits several data-* attributes on the SAME element in ONE atomic
+     *  persist call — e.g. a pinned timing range's start+duration together, so
+     *  a selection change or a partial failure mid-commit can't misdirect one
+     *  of the two writes or leave them half-applied. Falls back to sequential
+     *  `onSetAttribute` calls where omitted. */
+    onSetAttributes?: (selection: DomEditSelection, attrs: Record<string, string>) => Promise<void>;
+    onSetAttributeLive: (attr: string, value: string | null, onSettled?: (ok: boolean) => void) => void | Promise<void>;
+    /** Persists without reloading the preview, but re-reads the selection after —
+     *  for attributes the runtime applies to the live graph itself, where a reload
+     *  would only interrupt playback, and where the panel still has to see the
+     *  value it just wrote to compute the next edit from. */
+    onSetAttributeQuiet?: (attr: string, value: string | null) => void | Promise<void>;
+    onApplyColorGradingScope?: (scope: "source-file" | "project", value: string | null) => Promise<{
+        changedFiles: number;
+        changedElements: number;
+    }>;
+    onSetHtmlAttribute: (attr: string, value: string | null) => void | Promise<void>;
+    onSetAttributeBatch: CommitDomAttributeBatch;
+    onRemoveBackground?: (inputPath: string, options: {
+        createBackgroundPlate?: boolean;
+        quality?: "fast" | "balanced" | "best";
+        onProgress?: (progress: BackgroundRemovalProgress) => void;
+    }) => Promise<BackgroundRemovalResult>;
+    onSetManualOffset: (element: DomEditSelection, next: {
+        x: number;
+        y: number;
+    }, route?: {
+        plainTranslate: boolean;
+    }) => void | Promise<void | GeometryCommitResult>;
+    onSetManualSize: (element: DomEditSelection, next: {
+        width: number;
+        height: number;
+    }) => void | Promise<void | GeometryCommitResult>;
+    onSetManualRotation: (element: DomEditSelection, next: {
+        angle: number;
+    }) => void | Promise<void | GeometryCommitResult>;
+    onSetText: (value: string, fieldKey?: string) => void;
+    onSetTextFieldStyle: (fieldKey: string, property: string, value: string) => void;
+    onPreviewTextFieldStyle?: (fieldKey: string, property: string, value: string) => void;
+    onAddTextField: (afterFieldKey?: string) => string | Promise<string | null> | null;
+    onRemoveTextField: (fieldKey: string) => void;
+    onAskAgent: () => void;
+    onToggleElementHidden?: (elementKey: string, hidden: boolean) => void | Promise<void>;
+    /** B6: group two or more picked voice clips, atomically, one undo entry. */
+    onAutoGroupCarveSources?: (clipIds: readonly string[], groupId: string) => Promise<void>;
+    onImportAssets?: (files: FileList, dir?: string) => Promise<string[]>;
+    onAddMediaOverlay?: AddMediaOverlayHandler;
+    fontAssets?: ImportedFontAsset[];
+    onImportFonts?: (files: FileList | File[]) => Promise<ImportedFontAsset[]>;
+    previewIframeRef?: RefObject<HTMLIFrameElement | null>;
+    gsapAnimations?: GsapAnimation$1[];
+    gsapMultipleTimelines?: boolean;
+    gsapUnsupportedTimelinePattern?: boolean;
+    onUpdateGsapProperty?: (animId: string, prop: string, value: number | string) => void;
+    onUpdateGsapMeta?: (animId: string, updates: {
+        duration?: number;
+        ease?: string;
+        position?: number;
+    }) => void;
+    onDeleteGsapAnimation?: (animId: string) => void;
+    onAddGsapProperty?: (animId: string, prop: string) => void;
+    onRemoveGsapProperty?: (animId: string, prop: string) => void;
+    onUpdateGsapFromProperty?: (animId: string, prop: string, value: number | string) => void;
+    onAddGsapFromProperty?: (animId: string, prop: string) => void;
+    onRemoveGsapFromProperty?: (animId: string, prop: string) => void;
+    onAddGsapAnimation?: (method: "to" | "from" | "set" | "fromTo") => void;
+    onSetArcPath?: (animId: string, config: {
+        enabled: boolean;
+        autoRotate?: boolean | number;
+        segments?: ArcPathSegment[];
+    }) => void;
+    onUpdateArcSegment?: (animId: string, segmentIndex: number, update: Partial<ArcPathSegment>) => void;
+    onUnroll?: (animationId: string) => void;
+    onAddKeyframe?: (animationId: string, percentage: number, property: string, value: number | string) => void;
+    onRemoveKeyframe?: (animationId: string, percentage: number) => void;
+    onUpdateKeyframeEase?: (animationId: string, percentage: number, ease: string) => void;
+    onUpdateSegmentEase?: NonNullable<GsapAnimationEditCallbacks["onUpdateSegmentEase"]>;
+    onSetAllKeyframeEases?: (animationId: string, ease: string) => void;
+    onConvertToKeyframes?: (animationId: string, duration?: number) => void;
+    onCommitAnimatedProperty?: (selection: DomEditSelection, property: string, value: number | string) => Promise<void>;
+    onCommitAnimatedProperties?: (selection: DomEditSelection, props: Record<string, number | string>) => Promise<void>;
+    onSeekToTime?: (time: number) => void;
+    recordingState?: "idle" | "recording" | "preview";
+    recordingDuration?: number;
+    onToggleRecording?: () => void;
+}
+
+interface LocalFontData {
+    family: string;
+    fullName?: string;
+    postscriptName?: string;
+    style?: string;
+    blob?: () => Promise<Blob>;
+}
+declare global {
+    interface Window {
+        queryLocalFonts?: () => Promise<LocalFontData[]>;
+    }
+}
+
+declare const PropertyPanel: react.NamedExoticComponent<PropertyPanelProps>;
+
+interface FileTreeProps {
+    files: string[];
+    activeFile: string | null;
+    onSelectFile: (path: string) => void;
+    onCreateFile?: (path: string) => void;
+    onCreateFolder?: (path: string) => void;
+    onDeleteFile?: (path: string) => void;
+    onRenameFile?: (oldPath: string, newPath: string) => void;
+    onDuplicateFile?: (path: string) => void;
+    onMoveFile?: (oldPath: string, newPath: string) => void;
+    onImportFiles?: (files: FileList, dir?: string) => void;
+    lintFindingsByFile?: Map<string, {
+        count: number;
+        messages: string[];
+    }>;
+}
+declare const FileTree: react.NamedExoticComponent<FileTreeProps>;
+
+interface StudioAppProps {
+    /** Clicks still select and report; the preview cannot move, edit or delete anything. */
+    readOnlyPreview?: boolean;
+    /** Short text shown on disabled hand-edit controls while `readOnlyPreview` is set. */
+    readOnlyPreviewReason?: string;
+}
+declare function StudioApp({ readOnlyPreview, readOnlyPreviewReason }?: StudioAppProps): react_jsx_runtime.JSX.Element;
+
+type RightPanelTab = "layers" | "design" | "renders" | "block-params" | "slideshow" | "variables";
+interface AgentModalAnchorPoint {
+    x: number;
+    y: number;
+}
+
+interface AskAgentModalProps {
+    selectionLabel: string;
+    contextPreview?: string;
+    anchorPoint?: AgentModalAnchorPoint | null;
+    onSubmit: (instruction: string) => void;
+    onClose: () => void;
+}
+declare function AskAgentModal({ selectionLabel, contextPreview, anchorPoint, onSubmit, onClose, }: AskAgentModalProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * What the dev server knows about this machine's FFmpeg, as reported by
+ * `GET /api/environment/ffmpeg`. Studio asks when the Render panel opens so a
+ * missing encoder is a prompt with an install command, not a failed export an
+ * hour into the work.
+ */
+interface FfmpegStatus {
+    ok: boolean;
+    /** Short headline, e.g. "FFmpeg not found". Absent when ok. */
+    title?: string;
+    /** Why it cannot run, in the server's words. Absent when ok. */
+    detail?: string;
+    /** Prose remediation, including the manual route where one exists. */
+    hint?: string;
+    /** A single pasteable install command, when this platform has one. */
+    command?: string;
+}
+
+interface RenderJob {
+    id: string;
+    status: "rendering" | "complete" | "failed" | "cancelled";
+    progress: number;
+    stage?: string;
+    error?: string;
+    filename: string;
+    createdAt: number;
+    durationMs?: number;
+}
+type ResolutionPreset = CanvasResolution;
+interface StartRenderOptions {
+    fps?: number;
+    quality?: "draft" | "standard" | "high";
+    format?: "mp4" | "webm" | "mov";
+    /** `"auto"` (default) renders at the composition's authored dimensions. */
+    resolution?: ResolutionPreset | "auto";
+    /**
+     * Render a specific composition file. Omit it to render the composition the
+     * user currently has open — only the sidebar's per-composition Render button
+     * names one, because it renders a card the user is not looking at.
+     */
+    composition?: string;
+    /**
+     * Composition-variable overrides ({variableId: value}), forwarded to the
+     * render route and injected as window.__hfVariables — the same channel
+     * `hyperframes render --variables` uses.
+     */
+    variables?: Record<string, unknown>;
+}
+declare function useRenderQueue(projectId: string | null, activeCompPathRef: {
+    current: string | null;
+}): {
+    jobs: RenderJob[];
+    isRendering: boolean;
+    loadError: string | null;
+    actionError: string | null;
+    dismissActionError: () => void;
+    reloadRenders: () => Promise<void>;
+    deleteRender: (jobId: string) => Promise<void>;
+    cancelRender: (jobId: string) => Promise<void>;
+    clearCompleted: () => void;
+    startRender: (options: unknown) => Promise<void>;
+    ffmpeg: FfmpegStatus | null;
+    ffmpegMissing: boolean;
+    ffmpegChecking: boolean;
+    recheckFfmpeg: () => void;
+};
+
+interface CompositionDimensions {
+    width: number;
+    height: number;
+}
+type StartRenderHandler = (format: "mp4" | "webm" | "mov", quality: "draft" | "standard" | "high", resolution: ResolutionPreset | "auto", fps: 24 | 30 | 60) => void | Promise<void>;
+interface RenderQueueProps {
+    jobs: RenderJob[];
+    projectId: string;
+    onDelete: (jobId: string) => void;
+    onCancel?: (jobId: string) => void;
+    onClearCompleted: () => void;
+    onStartRender: StartRenderHandler;
+    isRendering: boolean;
+    /** History fetch failure (null when the last load succeeded). */
+    loadError?: string | null;
+    /** Retry a failed history load. */
+    onRetryLoad?: () => void;
+    /** Failure of a delete/cancel action, shown inline until dismissed. */
+    actionError?: string | null;
+    onDismissActionError?: () => void;
+    /**
+     * Authored dimensions of the active composition. Used to pick the
+     * matching preset (landscape / portrait / square) when the user selects
+     * a 1080p or 4K scale. `null` falls back to landscape (legacy default).
+     */
+    compositionDimensions?: CompositionDimensions | null;
+    /**
+     * Encoder availability, owned by useRenderQueue so the panel's Export button
+     * and the header's agree. `null` means "no answer", not "missing".
+     */
+    ffmpeg: FfmpegStatus | null;
+    ffmpegChecking: boolean;
+    onRecheckFfmpeg: () => void;
+}
+declare const RenderQueue: react.NamedExoticComponent<RenderQueueProps>;
+
+interface PersistedRenderSettings {
+    format: "mp4" | "webm" | "mov";
+    quality: "draft" | "standard" | "high";
+    fps: 24 | 30 | 60;
+}
+declare function getPersistedRenderSettings(): PersistedRenderSettings;
+declare function persistRenderSettings(format: PersistedRenderSettings["format"], quality: PersistedRenderSettings["quality"], fps: PersistedRenderSettings["fps"]): void;
+
+interface PickedElement {
+    id: string | null;
+    tagName: string;
+    selector: string;
+    label: string;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    textContent: string | null;
+    src: string | null;
+    dataAttributes: Record<string, string>;
+    computedStyles: Record<string, string>;
+}
+interface UseElementPickerReturn {
+    isPickMode: boolean;
+    pickedElement: PickedElement | null;
+    enablePick: () => void;
+    disablePick: () => void;
+    clearPick: () => void;
+    /** Update a CSS property on the picked element live + persist to source */
+    setStyle: (prop: string, value: string) => void;
+    /** Update a data attribute on the picked element + persist to source */
+    setDataAttr: (attr: string, value: string) => void;
+    /** Update the text content of the picked element + persist to source */
+    setTextContent: (text: string) => void;
+    /** Override the active iframe (for zoomed canvas view). Pass null to restore primary. */
+    setActiveIframe: (el: HTMLIFrameElement | null) => void;
+    /** Ref that always points to the active iframe (focused canvas frame or preview panel) */
+    activeIframeRef: React.RefObject<HTMLIFrameElement | null>;
+}
+interface PickerOptions {
+    /** Workspace files for source patching */
+    workspaceFiles?: Record<string, string>;
+    /** Callback to sync patched files to the project */
+    onSyncFiles?: (files: Record<string, string>) => void;
+}
+/**
+ * Hook for element picking via the HyperFrame runtime's picker API.
+ * Communicates with the iframe via postMessage.
+ */
+declare function useElementPicker(iframeRef: React.RefObject<HTMLIFrameElement | null>, options?: PickerOptions): UseElementPickerReturn;
+
+/**
+ * HTML Editor — Utility functions for parsing and manipulating HyperFrame HTML source.
+ */
+/**
+ * Parse a CSS inline style string into a key-value map.
+ * e.g. "opacity: 0.5; transform: matrix(1,0,0,1,0,0)" →
+ *      { opacity: "0.5", transform: "matrix(1,0,0,1,0,0)" }
+ */
+declare function parseStyleString(style: string): Record<string, string>;
+/**
+ * Merge `newStyles` into an opening tag string's `style` attribute.
+ * - New values win over existing ones.
+ * - If no `style` attribute is present, one is added before the closing `>`.
+ */
+declare function mergeStyleIntoTag(tag: string, newStyles: string): string;
+/**
+ * Find the full element block (opening tag through closing tag) in the source.
+ * Uses quote-aware scanning to handle attributes containing >.
+ * Uses depth counting to handle nested same-name tags.
+ */
+declare function findElementBlock(html: string, elementId: string): {
+    start: number;
+    end: number;
+    openTag: string;
+    tagName: string;
+    indent: string;
+    innerContent: string;
+    isSelfClosing: boolean;
+} | null;
+
+/** One file's restore from the edit-history store: before (live) / after (target) bytes. */
+interface UndoRestoreFile {
+    previous: string;
+    restored: string;
+}
+type RestoreFiles = Record<string, UndoRestoreFile>;
+
+interface ApplyCallbacks {
+    readFile: (path: string) => Promise<string>;
+    serialize?: <T>(paths: readonly string[], task: () => Promise<T>) => Promise<T>;
+    claimedAfter?: number;
+}
+interface UsePersistentEditHistoryOptions {
+    projectId: string | null;
+}
+interface ApplyResult {
+    ok: boolean;
+    /** content-mismatch: `paths` changed after the step's entry. failed: `message` says why. */
+    reason?: "empty" | "content-mismatch" | "failed";
+    message?: string;
+    label?: string;
+    paths?: string[];
+    undoes?: string;
+    files?: RestoreFiles;
+}
+/** Studio's undo over the server's project history: an edit claims what it wrote; Cmd+Z steps the person's. */
+declare function usePersistentEditHistory({ projectId }: UsePersistentEditHistoryOptions): {
+    loaded: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    undoLabel: string | undefined;
+    redoLabel: string | undefined;
+    undoPaths: string[];
+    redoPaths: string[];
+    state: {
+        undo: {
+            createdAt: number;
+        }[];
+        redo: {
+            createdAt: number;
+        }[];
+    };
+    recordEdit: ({ label, coalesceKey, coalesceMs, files, created }: RecordEditInput$5) => Promise<void>;
+    claimKey: (key: string) => string;
+    undo: (callbacks: ApplyCallbacks) => Promise<ApplyResult>;
+    redo: (callbacks: ApplyCallbacks) => Promise<ApplyResult>;
+    predict: (direction: "undo" | "redo") => {
+        id: string;
+        files: RestoreFiles;
+    } | null;
+    claims: () => number;
+    noteOutsideChange: () => void;
+};
+
+/** The files an undo or redo rewrote. */
+interface LiveLaneRestore {
+    paths?: string[];
+    files?: Record<string, {
+        restored: string;
+    }>;
+}
+
+declare function useTimelineEditing({ projectId, activeCompPath, timelineElements, showToast, writeProjectFile, observeProjectFileVersion, recordEdit, reloadPreview, previewIframeRef, pendingTimelineEditPathRef, uploadProjectFiles, isRecordingRef, sdkSession, publishSdkSession, forceReloadSdkSession, invalidateGsapCache, handleDomZIndexReorderCommitRef, canEdit, }: UseTimelineEditingOptions): {
+    handleTimelineElementMove: (element: TimelineElement, updates: TimelineMoveUpdates) => Promise<void>;
+    handleTimelineElementResize: (element: TimelineElement, updates: Pick<TimelineElement, "start" | "duration" | "playbackStart">) => Promise<void>;
+    handleToggleTrackHidden: (track: number, hidden: boolean, displayNumber?: number | null | undefined) => Promise<void>;
+    handleToggleElementHidden: (elementKey: string | readonly string[], hidden: boolean) => Promise<void>;
+    handleAutoGroupCarveSources: (clipIds: readonly string[], groupId: string, groupLabel?: string | undefined) => Promise<void>;
+    setAudioGroupAttribute: {
+        setQuiet: (groupId: string, attr: string, value: string | null, label: string) => Promise<TimelineEditOutcome>;
+        setLive: (groupId: string, attr: string, value: string | null) => void;
+        revertLive: (groupId: string, attr: string) => void;
+        restoreLive: (restore: LiveLaneRestore) => void;
+    };
+    setElementFxAttribute: {
+        setMany: (edits: readonly {
+            element: TimelineElement;
+            value: string | null;
+        }[], attr: string, label: string) => Promise<TimelineEditOutcome>;
+        setQuiet: (element: TimelineElement, attr: string, value: string | null, label: string) => Promise<TimelineEditOutcome>;
+        setLive: (element: TimelineElement, attr: string, value: string | null) => void;
+        revertLive: (element: TimelineElement, attr: string) => void;
+        restoreLive: (restore: LiveLaneRestore) => void;
+    };
+    handleTimelineElementDelete: (element: TimelineElement) => Promise<void>;
+    handleTimelineElementsDelete: (selection: TimelineElement[]) => Promise<void>;
+    handleTimelineElementDeleteOnly: (element: TimelineElement) => Promise<void>;
+    handleLinkEdit: (edit: TimelineLinkEdit) => Promise<void>;
+    handleTimelineElementSplit: (element: TimelineElement, splitTime: number) => Promise<void>;
+    handleRazorSplit: (element: TimelineElement, splitTime: number) => Promise<void>;
+    handleFreezeFrame: (element: TimelineElement, playhead: number) => Promise<void>;
+    handleRazorSplitAll: (splitTime: number) => Promise<void>;
+    handleTimelineAssetDrop: (assetPath: string, placement: TimelineDropPlacement, durationOverride?: number | undefined) => Promise<void>;
+    handleTimelineFileDrop: (files: File[], placement?: TimelineDropPlacement | undefined) => Promise<void>;
+    handleTimelineCompositionDrop: (sourcePath: string, placement: Pick<TimelineElement, "track" | "start">) => Promise<void>;
+    handleBlockedTimelineEdit: (element: TimelineElement) => void;
+    handleTimelineGroupMove: (changes: TimelineGroupMoveChange[], options?: TimelineGroupCommitOptions | undefined) => Promise<void>;
+    handleTimelineGroupResize: (changes: TimelineGroupResizeChange[], options?: TimelineGroupCommitOptions | undefined) => Promise<void>;
+    restoreLiveLanes: (restore: Parameters<(restore: LiveLaneRestore) => void>[0]) => void;
+};
+
+interface HistoryResult {
+    ok: boolean;
+    reason?: string;
+    message?: string;
+    label?: string;
+    paths?: string[];
+    undoes?: string;
+    /** Per-file restored/previous content, used to soft-apply the preview. */
+    files?: RestoreFiles;
+}
+interface HistoryFileCallbacks {
+    readFile: (path: string) => Promise<string>;
+    serialize?: <T>(paths: readonly string[], task: () => Promise<T>) => Promise<T>;
+    claimedAfter?: number;
+}
+interface EditHistoryHandle {
+    undo: (cb: HistoryFileCallbacks) => Promise<HistoryResult>;
+    redo: (cb: HistoryFileCallbacks) => Promise<HistoryResult>;
+    predict?: (direction: "undo" | "redo") => {
+        id: string;
+        files: RestoreFiles;
+    } | null;
+    claims?: () => number;
+    state: {
+        undo: ReadonlyArray<{
+            createdAt: number;
+        }>;
+        redo: ReadonlyArray<{
+            createdAt: number;
+        }>;
+    };
+}
+interface UseEditHistoryActionsOptions {
+    editHistory: Pick<EditHistoryHandle, "undo" | "redo" | "predict" | "claims">;
+    readOptionalProjectFile: (path: string) => Promise<string>;
+    readProjectFile: (path: string) => Promise<string>;
+    writeProjectFile: (path: string, content: string) => Promise<void>;
+    showToast: (message: string, tone?: "error" | "info") => void;
+    syncHistoryPreviewAfterApply: (restore: Pick<HistoryResult, "paths" | "files">) => Promise<void>;
+    showHistoryRestoreNow?: (files: RestoreFiles) => (() => void) | null;
+    waitForPendingDomEditSaves: () => Promise<void>;
+    onAfterUndoRedo?: (restore: Pick<HistoryResult, "paths" | "files">) => void;
+    /** Active composition path — decides whether undo/redo must resync the SDK session. */
+    activeCompPath?: string | null;
+    /** Reloads the SDK session after a revert of the active comp, past the self-write suppress window. */
+    forceReloadSdkSession?: () => void;
+}
+/** Takes one step of the project's history: the single owner of undo/redo over project files. */
+declare function useEditHistoryActions({ editHistory, readOptionalProjectFile, readProjectFile, writeProjectFile, showToast, syncHistoryPreviewAfterApply, showHistoryRestoreNow, waitForPendingDomEditSaves, onAfterUndoRedo, activeCompPath, forceReloadSdkSession, }: UseEditHistoryActionsOptions): {
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+};
+
+interface UseProjectFileWriterOptions {
+    projectId: string | null;
+}
+declare function useProjectFileWriter({ projectId }: UseProjectFileWriterOptions): {
+    fileVersions: Map<string, string | null>;
+    readProjectFile: (path: string) => Promise<string>;
+    writeProjectFile: (path: string, content: string, expectedContent?: string) => Promise<void>;
+    readOptionalProjectFile: (path: string) => Promise<string>;
+    observeProjectFileVersion: (path: string, version: string | null) => void;
+};
+
+type ExternalFileChangeBlockedState = {
+    status: "conflict";
+    generation: number;
+    error: StudioFileConflictError;
+    payload: unknown;
+} | {
+    status: "failed";
+    generation: number;
+    path: string;
+    error: unknown;
+    payload: unknown;
+    studioContent: string | null;
+    recovered: boolean;
+};
+interface ExternalFileChangeCoordinatorHandle {
+    blocked: ExternalFileChangeBlockedState | null;
+    retry: () => Promise<void>;
+    useExternalFile: () => Promise<void>;
+    keepStudioFile: () => Promise<void>;
+}
+
+declare function ExternalFileConflictBanner({ coordinator, }: {
+    coordinator: ExternalFileChangeCoordinatorHandle;
+}): react_jsx_runtime.JSX.Element | null;
+
+interface TimelinePaneProps {
+    /** Slot rendered above the timeline tracks (toolbar with split, delete, zoom) */
+    timelineToolbar?: ReactNode;
+    /** Slot rendered below the timeline tracks */
+    timelineFooter?: ReactNode;
+    /** Slot for a host's own overlay spanning the whole timeline area (e.g. a draft/ghost
+     *  clip), positioned absolutely the same way PreviewPane's previewOverlay is. */
+    timelineOverlay?: ReactNode;
+    /** Custom clip content renderer for timeline (thumbnails, waveforms, etc.) */
+    renderClipContent?: (element: TimelineElement, style: {
+        clip: string;
+        label: string;
+    }) => ReactNode;
+    onFileDrop?: (files: File[], placement?: Pick<TimelineElement, "start" | "track">) => Promise<void> | void;
+    onDeleteElement?: (element: TimelineElement) => Promise<void> | void;
+    onAssetDrop?: (assetPath: string, placement: Pick<TimelineElement, "start" | "track">) => Promise<void> | void;
+    onBlockDrop?: (blockName: string, placement: Pick<TimelineElement, "start" | "track">) => Promise<void> | void;
+    onCompositionDrop?: (sourcePath: string, placement: Pick<TimelineElement, "start" | "track">) => Promise<void> | void;
+    onBlockedEditAttempt?: (element: TimelineElement, intent: BlockedTimelineEditIntent) => void;
+    onSelectTimelineElement?: (element: TimelineElement | null) => void;
+    onRangeSelect?: (range: TimelineTimeRange$1 | null) => void;
+    /** Copy/paste/duplicate act on the store's own selection, not a passed
+     *  element, so unlike onDeleteElement they need no composition-basis wrapper. */
+    onCopyClip?: () => boolean;
+    onPasteClip?: () => Promise<void>;
+    onDuplicateClip?: () => Promise<boolean>;
+    canPasteClip?: () => boolean;
+    clipMenuItems?: TimelineProps["clipMenuItems"];
+    splitShortcut?: TimelineProps["splitShortcut"];
+}
+declare function TimelinePane({ timelineToolbar, timelineFooter, timelineOverlay, renderClipContent, onFileDrop, onDeleteElement, onAssetDrop, onBlockDrop, onCompositionDrop, onBlockedEditAttempt, onSelectTimelineElement, onRangeSelect, onCopyClip, onPasteClip, onDuplicateClip, canPasteClip, clipMenuItems, splitShortcut, }: TimelinePaneProps): react_jsx_runtime.JSX.Element;
+
+declare function TimelineEditProvider({ value, children, }: {
+    value: TimelineEditCallbacks;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface EnableKeyframesSession {
+    domEditSelection: DomEditSelection | null;
+    selectedGsapAnimations: GsapAnimation[];
+    previewIframeRef?: React.RefObject<HTMLIFrameElement | null>;
+    handleGsapAddAnimation: (method: "to" | "from" | "set" | "fromTo") => void;
+    handleGsapConvertToKeyframes: (animId: string, resolvedFromValues?: Record<string, number | string>, duration?: number, commitOverrides?: Partial<CommitMutationOptions>) => void | Promise<void>;
+    handleGsapRemoveKeyframe: (animId: string, pct: number) => void;
+    handleGsapAddKeyframeBatch?: (animId: string, pct: number, properties: Record<string, number | string>, commitOverrides?: Partial<CommitMutationOptions>) => Promise<void>;
+    commitMutation?: (mutation: Record<string, unknown>, options: CommitMutationOptions) => Promise<void>;
+}
+
+interface TimelineHistoryButtonsProps {
+    canUndo?: boolean;
+    canRedo?: boolean;
+    undoLabel?: string;
+    redoLabel?: string;
+    onUndo?: () => Promise<void> | void;
+    onRedo?: () => Promise<void> | void;
+}
+/** Undo and Redo: a host's props win, else the shell's edit history. */
+declare function TimelineHistoryButtons(props: TimelineHistoryButtonsProps): react_jsx_runtime.JSX.Element;
+
+interface DomEditSessionSlice extends EnableKeyframesSession {
+    domEditSelection: DomEditSelection | null;
+    selectedGsapAnimations: GsapAnimation[];
+}
+interface TimelineToolbarProps {
+    domEditSession?: DomEditSessionSlice;
+    onSplitElement?: (element: TimelineElement, splitTime: number) => void;
+    splitShortcut?: TimelineProps["splitShortcut"];
+    history?: TimelineHistoryButtonsProps;
+    showHistory?: boolean;
+    showSelectAroundPlayhead?: boolean;
+    showAddBeat?: boolean;
+    /** Hides Add keyframe and auto-record, and turns off auto-record and the K shortcut with them. */
+    showKeyframes?: boolean;
+    rightActions?: ReactNode;
+}
+declare const TimelineToolbar: react.NamedExoticComponent<TimelineToolbarProps>;
+
+interface AudioMeterStripProps {
+    /** Pass a stable ref (useRef): a new object each render restarts the meter loop. */
+    previewIframeRef?: RefObject<HTMLIFrameElement | null>;
+}
+declare const AudioMeterStrip: react.NamedExoticComponent<AudioMeterStripProps>;
+
+/** Whether the audio meter strip is shown; persisted, off unless the user showed it. */
+declare const useAudioMetersVisible: zustand.UseBoundStore<zustand.StoreApi<{
+    visible: boolean;
+    setVisible: (visible: boolean) => void;
+}>>;
+
+type InPlace = {
+    inPlace?: boolean;
+};
+interface RecordEditInput$3 {
+    label: string;
+    coalesceKey?: string;
+    files: Record<string, {
+        before: string;
+        after: string;
+    }>;
+}
+interface UseClipboardOptions {
+    projectId: string | null;
+    activeCompPath: string | null;
+    domEditSelectionRef: React.MutableRefObject<DomEditSelection | null>;
+    showToast: (message: string, tone?: "error" | "info") => void;
+    writeProjectFile: (path: string, content: string) => Promise<void>;
+    recordEdit: (input: RecordEditInput$3) => Promise<void>;
+    reloadPreview: () => void;
+    handleTimelineElementsDelete: (elements: TimelineElement[]) => Promise<void>;
+    handleDomEditElementDelete: (selection: DomEditSelection) => Promise<void>;
+    previewIframeRef: React.MutableRefObject<HTMLIFrameElement | null>;
+    waitForPendingDomEditSaves: () => Promise<void>;
+}
+declare function useClipboard({ projectId, activeCompPath, domEditSelectionRef, showToast, writeProjectFile, recordEdit, reloadPreview, handleTimelineElementsDelete, handleDomEditElementDelete, previewIframeRef, waitForPendingDomEditSaves, }: UseClipboardOptions): {
+    handleCopy: () => boolean;
+    handlePaste: (options?: InPlace) => Promise<void>;
+    handleCut: () => Promise<boolean>;
+    handleDuplicate: (options?: InPlace) => Promise<boolean>;
+    canPaste: () => boolean;
+};
+
+/** The live markup to persist and the session snapshot to restore on failure. */
+interface InlineTextEditCommit {
+    /** The exact preview node that owned the edit; a reload must not retarget it. */
+    element: HTMLElement;
+    html: string;
+    previousHtml: string;
+}
+
+/** Where a plain rotate draws its turn, read once at press: the element's own `rotate`, or, when its
+ *  transform translates it (often the translate(-50%, -50%) centring), a rotate() right after that
+ *  translate, so the box turns in place in screen space. `share` is what the rest already turns. */
+interface CssRotationTarget {
+    property: "rotate" | "transform";
+    before: string;
+    after: string;
+    share: number;
+    /** -1 when a mirroring `scale` property flips a turn made inside the transform. */
+    sign: number;
+    /** An inline box does not transform, so the turn makes it inline-block. */
+    inline: boolean;
+}
+type PressChoseGsap = null;
+type RotationCommit = {
+    angle: number;
+    plain?: CssRotationTarget | PressChoseGsap;
+};
+
+declare const SNAP_THRESHOLD_PX = 6;
+/** Whether a move of this size has travelled far enough for snapping to apply. */
+declare function snapEngagedForTravel(dx: number, dy: number): boolean;
+interface SnapEdge {
+    position: number;
+    source: "grid";
+    id: string;
+}
+interface SnapTarget {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    centerX: number;
+    centerY: number;
+    id: string;
+}
+interface SnapGuide {
+    axis: "x" | "y";
+    position: number;
+    /** Extent of the guide line (min of involved elements). */
+    from: number;
+    /** Extent of the guide line (max of involved elements). */
+    to: number;
+}
+interface SpacingGuide {
+    axis: "x" | "y";
+    /** Position of the gap (start of gap). */
+    position: number;
+    /** Size of the gap in pixels. */
+    size: number;
+    /** Extent for rendering the indicator. */
+    from: number;
+    /** Extent for rendering the indicator. */
+    to: number;
+}
+interface SnapResult {
+    dx: number;
+    dy: number;
+    guides: SnapGuide[];
+    spacingGuides: SpacingGuide[];
+}
+interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/**
+ * Convert overlay rects to snap targets with precomputed edges & centers.
+ */
+declare function extractSnapTargets(entries: Array<{
+    rect: Rect;
+    id: string;
+}>): SnapTarget[];
+/**
+ * Create a snap target from the composition/overlay boundary.
+ */
+declare function buildCompositionSnapTarget(rect: Rect): SnapTarget;
+/**
+ * Generate grid-line snap edges.
+ * `gridSpacing` is in composition pixels; `scale` converts to overlay pixels.
+ * X edges are vertical grid lines; Y edges are horizontal grid lines.
+ */
+declare function buildGridSnapEdges(compositionRect: Rect, gridSpacing: number, scale: number): {
+    x: SnapEdge[];
+    y: SnapEdge[];
+};
+declare function resolveSnapAdjustment(input: {
+    movingRect: Rect;
+    proposedDx: number;
+    proposedDy: number;
+    targets: SnapTarget[];
+    gridEdges?: {
+        x: SnapEdge[];
+        y: SnapEdge[];
+    };
+    threshold: number;
+    disabled: boolean;
+    /** Set when the gesture has not travelled far enough for snapping yet. */
+    disabledForTravel?: boolean;
+    lockedAxis?: "x" | "y";
+}): SnapResult;
+/**
+ * Full-length guide line spanning the composition: a vertical line (axis "x")
+ * runs the composition's height at the snapped x position; a horizontal line
+ * (axis "y") runs the composition's width. `composition` is the composition
+ * rect in overlay space — guide positions are already overlay-space, so the
+ * line must be offset by the composition's left/top (the canvas is usually
+ * letterboxed inside the overlay).
+ */
+declare function resolveGuideLineRect(guide: SnapGuide, composition: Rect): Rect;
+declare function resolveEquidistanceGuides(input: {
+    movingRect: Rect;
+    targets: SnapTarget[];
+    threshold: number;
+}): SpacingGuide[];
+
+interface SnapContext {
+    targets: SnapTarget[];
+    compositionTarget: SnapTarget | null;
+    gridEdges: {
+        x: SnapEdge[];
+        y: SnapEdge[];
+    } | null;
+    snapEnabled: boolean;
+}
+declare function collectSnapContext(input: {
+    overlayEl: HTMLDivElement;
+    iframe: HTMLIFrameElement;
+    excludeElements: Set<HTMLElement>;
+}): SnapContext;
+
+interface SnapGuidesState {
+    guides: SnapGuide[];
+    spacingGuides: SpacingGuide[];
+}
+interface SnapGuideOverlayProps {
+    snapGuidesRef: RefObject<SnapGuidesState | null>;
+    /** Composition rect in overlay space — guide lines span exactly this rect. */
+    compositionLeft: number;
+    compositionTop: number;
+    compositionWidth: number;
+    compositionHeight: number;
+}
+declare const SnapGuideOverlay: react.NamedExoticComponent<SnapGuideOverlayProps>;
+
+interface DomSelectionResult {
+    changed: boolean;
+    count: number;
+}
+interface ApplyDomSelectionOptions {
+    revealPanel?: boolean;
+    additive?: boolean;
+    preserveGroup?: boolean;
+    announce?: boolean;
+}
+interface ResolveDomSelectionOptions {
+    preferClipAncestor?: boolean;
+    skipSourceProbe?: boolean;
+    activeGroupElement?: HTMLElement | null;
+    /** Resolve this node itself instead of applying human group-capture behavior. */
+    exactTarget?: boolean;
+    previous?: DomEditSelection | null;
+}
+interface DomEditTimelineParams {
+    projectId: string | null;
+    activeCompPath: string | null;
+    compIdToSrc: Map<string, string>;
+    captionEditMode: boolean;
+    previewIframeRef: MutableRefObject<HTMLIFrameElement | null>;
+    timelineElements: TimelineElement[];
+    getTimelineSelectionSet: () => ReadonlySet<string>;
+    setSelectedTimelineElementId: (id: string | null, options?: SelectElementOptions) => void;
+    /** Publishes a whole multi-selection to the timeline; the anchor is set separately. */
+    setTimelineSelectionSet: (ids: Set<string>) => void;
+    setRightCollapsed: (collapsed: boolean) => void;
+    setRightPanelTab: (tab: RightPanelTab) => void;
+}
+
+interface PreviewMouseDownOptions {
+    preferClipAncestor?: boolean;
+    hoverSelection?: DomEditSelection | null;
+}
+
+interface MoveCommitOptions {
+    altKey?: boolean;
+    plainTranslate?: boolean;
+}
+interface DomEditGroupPathOffsetCommit {
+    selection: DomEditSelection;
+    next: {
+        x: number;
+        y: number;
+    };
+    plainTranslate?: boolean;
+}
+
+/**
+ * Why a DOM edit commit did not change the file.
+ *
+ * `runDomEditCommit` resolves on persist failure by design (see its contract
+ * above), so a caller cannot learn whether the write landed by awaiting it — a
+ * failed persist and a successful one are indistinguishable. Capture and apply
+ * bugs still reject. The human path does not need to ask about handled persist
+ * failures, because `onError` already put a toast on screen. A programmatic
+ * caller has no screen, so it has to be told.
+ */
+type DomEditCommitDeclineReason = "no-project" | "no-selection" | "geometry-property" | "styles-not-editable" | "not-text-editable" | "preview-stale" | "persist-failed";
+type DomEditCommitOutcome = {
+    ok: true;
+    persistence?: DomEditPersistOutcome;
+    changed?: boolean;
+} | {
+    ok: false;
+    reason: DomEditCommitDeclineReason;
+};
+
+/**
+ * Which elements a delete acts on.
+ *
+ * Its own module so `useDomEditSession.ts` stays under the studio's 600-line
+ * cap; it reads only its arguments.
+ */
+
+/** One entry in the studio's edit history, as `useDomEditSession`'s caller
+ *  supplies it. */
+interface RecordEditInput$2 {
+    label: string;
+    coalesceKey?: string;
+    files: Record<string, {
+        before: string;
+        after: string;
+    }>;
+}
+
+interface DomGroupMove {
+    selection: DomEditSelection;
+    /** Composition px: the element's box moves by exactly this in the film. */
+    delta: {
+        x: number;
+        y: number;
+    };
+}
+
+interface UseDomEditSessionParams extends DomEditTimelineParams {
+    compositionLoading: boolean;
+    showToast: (message: string, tone?: "error" | "info") => void;
+    isRecordingRef?: React.RefObject<boolean>;
+    refreshPreviewDocumentVersion: () => void;
+    queueDomEditSave: <T>(save: () => Promise<T>) => Promise<T>;
+    readProjectFile: (path: string) => Promise<string>;
+    writeProjectFile: (path: string, content: string, expectedContent?: string) => Promise<void>;
+    updateEditingFileContent: (path: string, content: string) => void;
+    editHistory: {
+        recordEdit: (entry: RecordEditInput$2) => Promise<void>;
+    };
+    fileTree: string[];
+    importedFontAssetsRef: React.MutableRefObject<ImportedFontAsset[]>;
+    projectDir: string | null;
+    projectIdRef: React.MutableRefObject<string | null>;
+    previewIframe: HTMLIFrameElement | null;
+    refreshKey: number;
+    previewDocumentVersion: number;
+    rightPanelTab: RightPanelTab;
+    applyStudioManualEditsToPreviewRef: React.MutableRefObject<(iframe: HTMLIFrameElement) => Promise<void>>;
+    syncPreviewHotkeys: (iframe: HTMLIFrameElement | null) => void;
+    reloadPreview: () => void;
+    setRefreshKey: React.Dispatch<React.SetStateAction<number>>;
+    openSourceForSelection?: (sourceFile: string, target: PatchTarget) => void;
+    sdkSession?: Composition | null;
+    publishSdkSession?: PublishSdkSession;
+    forceReloadSdkSession?: () => void;
+    /** The timeline context menu's delete op — a canvas selection that IS a
+     *  timeline row hands off here instead of the REST remove-elements path. */
+    handleTimelineElementsDelete: (elements: TimelineElement[]) => Promise<void>;
+    readOnlyPreview: boolean;
+}
+declare function useDomEditSession({ projectId, activeCompPath, compIdToSrc, captionEditMode, compositionLoading, previewIframeRef, timelineElements, getTimelineSelectionSet, setSelectedTimelineElementId, setTimelineSelectionSet, setRightCollapsed, setRightPanelTab, showToast, isRecordingRef, refreshPreviewDocumentVersion, queueDomEditSave, readProjectFile, writeProjectFile, updateEditingFileContent, editHistory, fileTree, importedFontAssetsRef, projectDir, projectIdRef, previewIframe: hostPreviewIframe, refreshKey, previewDocumentVersion, rightPanelTab, applyStudioManualEditsToPreviewRef, syncPreviewHotkeys, reloadPreview, openSourceForSelection, sdkSession, publishSdkSession, forceReloadSdkSession, handleTimelineElementsDelete, readOnlyPreview, }: UseDomEditSessionParams): {
+    domEditSelection: DomEditSelection | null;
+    domEditGroupSelections: DomEditSelection[];
+    domEditHoverSelection: DomEditSelection | null;
+    activeGroupElement: HTMLElement | null;
+    agentModalOpen: boolean;
+    agentModalAnchorPoint: AgentModalAnchorPoint | null;
+    copiedAgentPrompt: boolean;
+    agentPromptSelectionContext: string | undefined;
+    domEditSelectionRef: react.MutableRefObject<DomEditSelection | null>;
+    handleTimelineElementSelect: (element: TimelineElement | null) => Promise<void>;
+    handlePreviewCanvasMouseDown: (e: React.MouseEvent<HTMLDivElement>, options?: PreviewMouseDownOptions) => Promise<void>;
+    handlePreviewCanvasPointerMove: (e: React.PointerEvent<HTMLDivElement>, options?: {
+        preferClipAncestor?: boolean;
+    }) => Promise<DomEditSelection | null>;
+    handlePreviewCanvasPointerLeave: () => void;
+    applyDomSelection: (selection: DomEditSelection | null, options?: ApplyDomSelectionOptions) => void;
+    clearDomSelection: () => void;
+    refreshDomEditSelectionFromPreview: (selection: DomEditSelection) => Promise<void>;
+    handleDomStyleCommit: (property: string, value: string) => Promise<DomEditCommitOutcome>;
+    handleDomStyleCommitForSelection: (selection: DomEditSelection, propertyOrStylesAsOnePatch: string | Record<string, string>, value?: string) => Promise<DomEditCommitOutcome>;
+    handleDomAttributeCommit: (attr: string, value: string) => Promise<void>;
+    handleDomAttributeLiveCommit: (attr: string, value: string | null, onSettled?: (ok: boolean) => void, live?: {
+        previewOnly?: boolean;
+    }) => Promise<void>;
+    handleDomAttributeQuietCommit: (attr: string, value: string | null) => Promise<void>;
+    handleDomHtmlAttributeCommit: (attr: string, value: string | null) => Promise<void>;
+    handleDomAttributesCommit: (selection: DomEditSelection, attrs: Record<string, string>) => Promise<void>;
+    handleDomAttributeBatchCommit: CommitDomAttributeBatch;
+    handleDomPathOffsetCommit: (selection: DomEditSelection, next: {
+        x: number;
+        y: number;
+    }, modifiers?: MoveCommitOptions) => Promise<GeometryCommitResult | undefined>;
+    handleDomGroupPathOffsetCommit: (updates: DomEditGroupPathOffsetCommit[], options?: {
+        refusalToast?: boolean;
+    }) => Promise<GeometryCommitResult>;
+    handleDomGroupMoveBy: (moves: DomGroupMove[]) => Promise<void>;
+    handleDomZIndexReorderCommit: (entries: Array<{
+        element: HTMLElement;
+        zIndex: number;
+        id?: string;
+        selector?: string;
+        selectorIndex?: number;
+        sourceFile: string;
+        key?: string;
+    }>, gestureCoalesceKey?: string, actionKind?: string) => Promise<void> | Promise<DomEditPatchBatchesResult>;
+    handleDomBoxSizeCommit: (selection: DomEditSelection, next: {
+        width: number;
+        height: number;
+    }, offset?: {
+        x: number;
+        y: number;
+    }, restore?: () => void, route?: {
+        plainTranslate: boolean;
+    }) => Promise<GeometryCommitResult>;
+    handleDomRotationCommit: (selection: DomEditSelection, next: RotationCommit) => Promise<GeometryCommitResult | undefined>;
+    handleDomManualEditsReset: (selection: DomEditSelection) => Promise<DomEditPersistOutcome | undefined>;
+    handleDomTextCommit: (value: string, fieldKey?: string) => Promise<DomEditCommitOutcome>;
+    handleDomTextCommitForSelection: (selection: DomEditSelection, value: string, fieldKey?: string) => Promise<DomEditCommitOutcome>;
+    handleDomRichTextCommit: ({ element, html, previousHtml }: InlineTextEditCommit) => Promise<void>;
+    handleDomTextFieldStyleCommit: (fieldKey: string, property: string, value: string) => Promise<void>;
+    handleDomAddTextField: (afterFieldKey?: string) => Promise<string | null>;
+    handleDomRemoveTextField: (fieldKey: string) => Promise<void>;
+    getGsapAnimationsForSelection: (selection: DomEditSelection) => _hyperframes_parsers.GsapAnimation[] | Promise<_hyperframes_parsers.GsapAnimation[]>;
+    handleAskAgent: () => void;
+    handleAgentModalSubmit: (userInstruction: string) => Promise<void>;
+    handleBlockedDomMove: (selection: DomEditSelection, reason?: string) => void;
+    handleDomManualDragStart: () => void;
+    handleDomEditElementDelete: (selection: DomEditSelection, options?: {
+        expandGroup?: boolean;
+    }) => Promise<void>;
+    handleGroupSelection: () => void;
+    handleUngroupSelection: () => void;
+    setActiveGroupElement: (el: HTMLElement | null) => void;
+    buildDomSelectionFromTarget: (target: HTMLElement, options?: ResolveDomSelectionOptions) => Promise<DomEditSelection | null>;
+    buildDomSelectionForTimelineElement: (element: TimelineElement) => Promise<DomEditSelection | null>;
+    updateDomEditHoverSelection: (selection: DomEditSelection | null) => void;
+    applyMarqueeSelection: (selections: DomEditSelection[], additive: boolean) => DomSelectionResult;
+    resolveImportedFontAsset: (fontFamilyValue: string) => ImportedFontAsset | null;
+    setAgentModalOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    setAgentPromptSelectionContext: react.Dispatch<react.SetStateAction<string | undefined>>;
+    setAgentModalAnchorPoint: react.Dispatch<react.SetStateAction<AgentModalAnchorPoint | null>>;
+    selectedGsapAnimations: _hyperframes_parsers.GsapAnimation[];
+    gsapMultipleTimelines: boolean;
+    gsapUnsupportedTimelinePattern: boolean;
+    handleGsapUpdateProperty: (animId: string, prop: string, value: number | string) => void;
+    handleGsapUpdateMeta: (animId: string, updates: {
+        duration?: number;
+        ease?: string;
+        position?: number;
+    }, selectionOverride?: DomEditSelection | null) => Promise<boolean>;
+    handleGsapDeleteAnimation: (animId: string, selectionOverride?: DomEditSelection | null) => Promise<boolean>;
+    handleGsapDeleteAllForElement: (targetSelector: string) => void;
+    handleGsapAddAnimation: (method: "to" | "from" | "set" | "fromTo", selectionOverride?: DomEditSelection | null) => Promise<boolean>;
+    handleGsapAddProperty: (animId: string, prop: string) => void;
+    handleGsapRemoveProperty: (animId: string, prop: string) => void;
+    handleGsapUpdateFromProperty: (animId: string, prop: string, value: number | string) => void;
+    handleGsapAddFromProperty: (animId: string, prop: string) => void;
+    handleGsapRemoveFromProperty: (animId: string, prop: string) => void;
+    handleGsapAddKeyframe: (animId: string, percentage: number, property: string, value: number | string, selectionOverride?: DomEditSelection | null) => void;
+    handleGsapAddKeyframeBatch: (animId: string, percentage: number, properties: Record<string, number | string>, commitOverrides?: Partial<CommitMutationOptions>, selectionOverride?: DomEditSelection | null) => Promise<void>;
+    handleGsapRemoveKeyframe: (animId: string, percentage: number, commitOverrides?: Partial<CommitMutationOptions>, selectionOverride?: DomEditSelection | null) => void;
+    handleGsapMoveKeyframeToPlayhead: (animId: string, fromPercentage: number, selectionOverride?: DomEditSelection | null, animationOverride?: _hyperframes_parsers.GsapAnimation) => void;
+    handleGsapMoveKeyframe: (animId: string, fromPercentage: number, toPercentage: number, selectionOverride?: DomEditSelection | null) => Promise<boolean>;
+    handleGsapResizeKeyframedTween: (animId: string, position: number, duration: number, pctRemap: Array<{
+        from: number;
+        to: number;
+    }>, selectionOverride?: DomEditSelection | null) => Promise<boolean>;
+    handleGsapConvertToKeyframes: (animId: string, resolvedFromValues?: Record<string, number | string>, duration?: number, commitOverrides?: Partial<CommitMutationOptions>, selectionOverride?: DomEditSelection | null) => Promise<void>;
+    handleGsapRemoveAllKeyframes: (animId: string, selectionOverride?: DomEditSelection | null, telemetry?: boolean) => Promise<boolean>;
+    handleResetSelectedElementKeyframes: () => boolean;
+    handleUpdateKeyframeEase: (animationId: string, percentage: number, ease: string) => void;
+    handleUpdateSegmentEase: (targets: AnimationKeyframeTarget[], ease: string) => void;
+    handleSetAllKeyframeEases: (animationId: string, ease: string) => void;
+    commitAnimatedProperty: (selection: DomEditSelection, property: string, value: number | string) => Promise<void>;
+    commitAnimatedProperties: (selection: DomEditSelection, properties: Record<string, number | string>) => Promise<void>;
+    handleSetArcPath: (animId: string, config: Parameters<(sel: DomEditSelection, animId: string, config: {
+        enabled: boolean;
+        autoRotate?: boolean | number;
+        segments?: Array<{
+            curviness: number;
+            cp1?: {
+                x: number;
+                y: number;
+            };
+            cp2?: {
+                x: number;
+                y: number;
+            };
+        }>;
+    }) => void>[2]) => void;
+    handleUpdateArcSegment: (animId: string, segmentIndex: number, update: Parameters<(sel: DomEditSelection, animId: string, segmentIndex: number, update: {
+        curviness?: number;
+        cp1?: {
+            x: number;
+            y: number;
+        };
+        cp2?: {
+            x: number;
+            y: number;
+        };
+    }) => void>[3]) => void;
+    handleUnroll: () => void;
+    invalidateGsapCache: () => void;
+    previewIframeRef: react.MutableRefObject<HTMLIFrameElement | null>;
+    commitMutation: (mutation: Record<string, unknown>, options: CommitMutationOptions, selection?: DomEditSelection | null) => Promise<void>;
+};
+
+/** The one source for which preview is on screen: the host's iframe, then each reload promoted in its place. */
+declare function useLivePreviewIframe(host: HTMLIFrameElement | null): HTMLIFrameElement | null;
+
+type PreviewPromotion = {
+    retired: HTMLIFrameElement | null;
+    live: HTMLIFrameElement;
+};
+
+interface DomEditSaveQueue {
+    enqueue: <T>(save: () => Promise<T>) => Promise<T>;
+    waitForIdle: () => Promise<DomEditSaveDrainResult>;
+    isIdle: () => boolean;
+    reset: () => void;
+    destroy: () => void;
+}
+type DomEditSaveDrainResult = StudioSaveDrainResult;
+
+/** The restore payload the undo/redo preview-sync consumes (from the history store). */
+interface HistoryPreviewRestore {
+    paths?: string[];
+    files?: RestoreFiles;
+}
+interface RecordEditInput$1 {
+    label: string;
+    coalesceKey?: string;
+    files: Record<string, {
+        before: string;
+        after: string;
+    }>;
+}
+interface UsePreviewPersistenceParams {
+    showToast: (message: string, tone?: "error" | "info") => void;
+    readOptionalProjectFile: (path: string) => Promise<string>;
+    writeProjectFile: (path: string, content: string) => Promise<void>;
+    recordEdit: (entry: RecordEditInput$1) => Promise<void>;
+    previewIframeRef: React.MutableRefObject<HTMLIFrameElement | null>;
+    activeCompPathRef: React.MutableRefObject<string | null>;
+    /** Called to reload the preview after undo/redo or external file changes. */
+    reloadPreview: () => void;
+}
+declare function usePreviewPersistence({ showToast, readOptionalProjectFile: _readOptionalProjectFile, writeProjectFile: _writeProjectFile, recordEdit: _recordEdit, previewIframeRef, activeCompPathRef, reloadPreview, }: UsePreviewPersistenceParams): {
+    domTextCommitVersionRef: react.RefObject<number>;
+    domEditSaveQueueRef: react.RefObject<DomEditSaveQueue | null>;
+    applyStudioManualEditsToPreviewRef: react.RefObject<(iframe?: HTMLIFrameElement | null) => Promise<void>>;
+    queueDomEditSave: <T>(save: () => Promise<T>) => Promise<T>;
+    drainPendingDomEditSaves: () => Promise<{
+        status: "clean";
+    } | {
+        status: "conflict";
+        error: StudioFileConflictError;
+    } | {
+        status: "failed";
+        error: unknown;
+    }>;
+    waitForPendingDomEditSaves: () => Promise<void>;
+    settlePendingEdits: () => Promise<void>;
+    domEditSaveQueuePaused: string | null;
+    resetDomEditSaveQueueBreaker: () => void;
+    applyCurrentStudioManualEditsToPreview: (iframe?: HTMLIFrameElement | null) => void;
+    applyStudioManualEditsToPreview: (iframe?: HTMLIFrameElement | null) => Promise<void>;
+    syncHistoryPreviewAfterApply: (restore: HistoryPreviewRestore) => Promise<void>;
+    showHistoryRestoreNow: (files: RestoreFiles) => (() => void) | null;
+};
+
+type DomEditValue = ReturnType<typeof useDomEditSession>;
+interface DomEditSelectionValue extends Pick<DomEditValue, "domEditSelection" | "domEditGroupSelections" | "domEditHoverSelection" | "activeGroupElement" | "domEditSelectionRef" | "selectedGsapAnimations" | "gsapMultipleTimelines" | "gsapUnsupportedTimelinePattern" | "agentModalOpen" | "agentModalAnchorPoint" | "copiedAgentPrompt" | "agentPromptSelectionContext"> {
+}
+declare function useDomEditSelectionContext(): DomEditSelectionValue;
+declare function DomEditProvider({ value: { domEditSelection, domEditGroupSelections, domEditHoverSelection, agentModalOpen, agentModalAnchorPoint, copiedAgentPrompt, agentPromptSelectionContext, domEditSelectionRef, handleTimelineElementSelect, handlePreviewCanvasMouseDown, handlePreviewCanvasPointerMove, handlePreviewCanvasPointerLeave, applyDomSelection, clearDomSelection, refreshDomEditSelectionFromPreview, handleDomStyleCommit, handleDomStyleCommitForSelection, handleDomAttributeCommit, handleDomAttributeLiveCommit, handleDomAttributeQuietCommit, handleDomHtmlAttributeCommit, handleDomAttributesCommit, handleDomAttributeBatchCommit, handleDomPathOffsetCommit, handleDomGroupPathOffsetCommit, handleDomGroupMoveBy, handleDomZIndexReorderCommit, handleDomBoxSizeCommit, handleDomRotationCommit, handleDomManualEditsReset, handleDomTextCommit, handleDomTextCommitForSelection, handleDomRichTextCommit, handleDomTextFieldStyleCommit, handleDomAddTextField, handleDomRemoveTextField, getGsapAnimationsForSelection, handleAskAgent, handleAgentModalSubmit, handleBlockedDomMove, handleDomManualDragStart, handleDomEditElementDelete, handleGroupSelection, handleUngroupSelection, setActiveGroupElement, activeGroupElement, buildDomSelectionFromTarget, buildDomSelectionForTimelineElement, updateDomEditHoverSelection, resolveImportedFontAsset, setAgentModalOpen, setAgentPromptSelectionContext, setAgentModalAnchorPoint, selectedGsapAnimations, gsapMultipleTimelines, gsapUnsupportedTimelinePattern, handleGsapUpdateProperty, handleGsapUpdateMeta, handleGsapDeleteAnimation, handleGsapDeleteAllForElement, handleGsapAddAnimation, handleGsapAddProperty, handleGsapRemoveProperty, handleGsapUpdateFromProperty, handleGsapAddFromProperty, handleGsapRemoveFromProperty, handleGsapAddKeyframe, handleGsapAddKeyframeBatch, handleGsapRemoveKeyframe, handleGsapMoveKeyframeToPlayhead, handleGsapMoveKeyframe, handleGsapResizeKeyframedTween, handleGsapConvertToKeyframes, handleGsapRemoveAllKeyframes, handleResetSelectedElementKeyframes, commitAnimatedProperty, commitAnimatedProperties, handleSetArcPath, handleUpdateArcSegment, handleUnroll, invalidateGsapCache, previewIframeRef, commitMutation, applyMarqueeSelection, handleUpdateKeyframeEase, handleUpdateSegmentEase, handleSetAllKeyframeEases, }, children, }: {
+    value: DomEditValue;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function PreviewReadOnlyProvider({ readOnly, reason, children, }: {
+    readOnly: boolean;
+    reason?: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Pure z-order helpers for the canvas right-click context menu.
+ *
+ * Layering strategy: z-index + CSS stacking context (position ≠ static).
+ * All sibling z-index values are read from the live iframe DOM via
+ * element.style.zIndex (inline style, set by the editor) falling back to
+ * the computed value. Treat missing / "auto" as 0 for comparison purposes.
+ *
+ * "Overlapping siblings" = siblings whose bounding rects intersect the
+ * target's bounding rect AND are actually visible at the current frame.
+ * Forward/backward operate within that set; front/back operate across all
+ * siblings (full painting family, visible or not — unchanged semantics).
+ *
+ * ── Visibility ───────────────────────────────────────────────────────────────
+ * In HyperFrames compositions the nearest z-neighbor is often INVISIBLE at the
+ * paused frame: the runtime hides time-inactive clips with inline
+ * `visibility:hidden` / `display:none` (see core runtime
+ * syncTimedElementVisibility), and GSAP timelines park elements at `opacity:0`.
+ * Stepping "forward" over such a sibling looks like a silent no-op. The
+ * forward/backward comparison set therefore keeps only siblings whose
+ * element-level computed style is visible (display ≠ none, visibility ≠
+ * hidden, opacity > 0.01) — all runtime hiding signals are inline styles, so
+ * computed style covers them. Ancestor-chain checks are unnecessary here:
+ * siblings share the target's ancestors. The probe is injectable
+ * (ZOrderResolveOptions.isVisible) so the pure-module tests stay meaningful
+ * without a real style engine, mirroring how tests stub rect reading.
+ *
+ * ── Tie-awareness ────────────────────────────────────────────────────────────
+ * CSS paint order for elements that share a z-index is DOM document order:
+ * the element that comes LATER in the DOM paints ON TOP. The old resolver
+ * compared z-index alone, so a target tied with the element visually below it
+ * (equal z, target later in DOM) had an empty "below" set and silently
+ * no-op'd. This module computes true render order — sort by
+ * (zIndex asc, DOM position asc), bottom→top — moves the target one step (or
+ * to an end) in that order, then realizes the new order back into z values.
+ *
+ * The result is a MULTI-element patch: a single-element patch when a
+ * strictly-between z value can express the new order given DOM-order
+ * tie-breaking, otherwise a minimal renumber of the affected set (emitting
+ * patches only for elements whose z actually changes). z is never negative
+ * (project convention clamps z ≥ 0).
+ */
+type ZOrderAction = "bring-forward" | "send-backward" | "bring-to-front" | "send-to-back";
+/** A resolved change: set `element`'s z-index to `zIndex`. */
+interface ZOrderPatch {
+    element: HTMLElement;
+    zIndex: number;
+}
+
+interface DomEditOverlayProps {
+    iframeRef: RefObject<HTMLIFrameElement | null>;
+    activeCompositionPath: string | null;
+    selection: DomEditSelection | null;
+    groupSelections?: DomEditSelection[];
+    hoverSelection: DomEditSelection | null;
+    allowCanvasMovement?: boolean;
+    allowBodyDrag?: boolean;
+    /** "host": no hover, marquee, box re-select, or body drag if allowBodyDrag is false; Enter still opens text. */
+    canvasInput?: "overlay" | "host";
+    onTextEditingChange?: (editing: boolean) => void;
+    /** A click on a single selection's box, in either mode; the event may be the pointerup. */
+    onSelectionBoxClick?: (event: React.MouseEvent<HTMLDivElement>, selection: DomEditSelection) => void;
+    onCanvasMouseDown: (event: React.MouseEvent<HTMLDivElement>, options?: PreviewMouseDownOptions) => void;
+    onCanvasPointerMove: (event: React.PointerEvent<HTMLDivElement>, options?: {
+        preferClipAncestor?: boolean;
+    }) => Promise<DomEditSelection | null>;
+    onCanvasPointerLeave: () => void;
+    onSelectionChange: (selection: DomEditSelection, options?: {
+        revealPanel?: boolean;
+        additive?: boolean;
+    }) => void;
+    onBlockedMove: (selection: DomEditSelection, reason?: string) => void;
+    onManualDragStart?: () => void;
+    onPathOffsetCommit: (selection: DomEditSelection, next: {
+        x: number;
+        y: number;
+    }, modifiers?: MoveCommitOptions) => Promise<unknown> | void;
+    onGroupPathOffsetCommit: (updates: DomEditGroupPathOffsetCommit[]) => Promise<unknown> | void;
+    onBoxSizeCommit: (selection: DomEditSelection, next: {
+        width: number;
+        height: number;
+    }, offset?: {
+        x: number;
+        y: number;
+    }, restore?: () => void, route?: {
+        plainTranslate: boolean;
+    }) => Promise<unknown> | void;
+    onRotationCommit: (selection: DomEditSelection, next: RotationCommit) => Promise<unknown> | void;
+    onStyleCommit?: (property: string, value: string) => Promise<unknown> | void;
+    recordingState?: GestureRecordingState;
+    onToggleRecording?: () => void;
+    onMarqueeSelect?: (selections: DomEditSelection[], additive: boolean) => DomSelectionResult | void;
+    /**
+     * Delete the selected canvas element.
+     * Wire to handleDomEditElementDelete from useDomEditActionsContext —
+     * same handler the Delete/Backspace hotkey uses.
+     */
+    onDeleteSelection?: (selection: DomEditSelection) => void;
+    /**
+     * Called with the resolved z-order patch list and the menu action that
+     * produced it (feeds the undo coalesce key). The patch list is tie-aware and
+     * may include sibling elements (see canvasContextMenuZOrder); the live DOM is
+     * NOT yet mutated. Wire to handleDomZIndexReorderCommit from
+     * useDomEditActionsContext. See CanvasContextMenu.tsx module comment.
+     */
+    onApplyZIndex?: (selection: DomEditSelection, patches: ZOrderPatch[], action: ZOrderAction, 
+    /** Sibling a forward/backward step moved past (pre-mutation render order);
+     *  null for front/back. Feeds the timeline z-mirror's crossedKey. */
+    crossed: HTMLElement | null) => void;
+}
+declare const DomEditOverlay: react.NamedExoticComponent<DomEditOverlayProps>;
+
+type HostInputProps = Pick<ComponentProps<typeof DomEditOverlay>, "canvasInput" | "onSelectionBoxClick" | "allowBodyDrag">;
+interface ConnectedDomEditOverlayProps extends HostInputProps {
+    activeCompositionPath: string | null;
+    showHoverSelection: boolean;
+    shouldShowSelectedDomBounds: boolean;
+    isGestureRecording?: boolean;
+    /** True when an in-place text edit opens its caret, false when it ends or unmounts. */
+    onTextEditingChange?: (editing: boolean) => void;
+}
+declare function ConnectedDomEditOverlay({ activeCompositionPath, showHoverSelection, shouldShowSelectedDomBounds, isGestureRecording, canvasInput, allowBodyDrag, onTextEditingChange, onSelectionBoxClick, }: ConnectedDomEditOverlayProps): react_jsx_runtime.JSX.Element;
+
+interface StudioShellValue {
+    projectId: string;
+    activeCompPath: string | null;
+    setActiveCompPath: (path: string | null) => void;
+    showToast: (message: string, tone?: "error" | "info") => void;
+    previewIframeRef: React.MutableRefObject<HTMLIFrameElement | null>;
+    editHistory: {
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: string | undefined;
+        redoLabel: string | undefined;
+    };
+    /**
+     * Why a composition write would be refused right now, or null when writes
+     * are possible. Derived from the paused save queue and the external-file
+     * conflict state, both of which are otherwise banners with no lock behind
+     * them. One field rather than two, so there is one owner of the question.
+     */
+    writeBlockedReason: string | null;
+    handleUndo: () => Promise<void>;
+    handleRedo: () => Promise<void>;
+    renderQueue: {
+        jobs: unknown[];
+        isRendering: boolean;
+        loadError: string | null;
+        actionError: string | null;
+        dismissActionError: () => void;
+        reloadRenders: () => void;
+        deleteRender: (jobId: string) => void;
+        cancelRender: (jobId: string) => void;
+        clearCompleted: () => void;
+        startRender: (options: unknown) => Promise<void>;
+        /** Encoder availability. `null` means "no answer", not "missing". */
+        ffmpeg: FfmpegStatus | null;
+        /** True only when the server positively reported no usable FFmpeg. */
+        ffmpegMissing: boolean;
+        ffmpegChecking: boolean;
+        recheckFfmpeg: () => void;
+    };
+    compositionDimensions: CompositionDimensions | null;
+    waitForPendingDomEditSaves: () => Promise<void>;
+    handlePreviewIframeRef: (iframe: HTMLIFrameElement | null) => void;
+}
+interface StudioPlaybackValue {
+    captionEditMode: boolean;
+    compositionLoading: boolean;
+    refreshKey: number;
+    setRefreshKey: React.Dispatch<React.SetStateAction<number>>;
+    timelineElements: TimelineElement[];
+    isPlaying: boolean;
+    refreshPreviewDocumentVersion: () => void;
+}
+
+/** Studio state the panel reads; passed by hosts outside Studio's providers. Keep previewIframeRef stable,
+ * and bump refreshKey when the preview document is rebuilt without an iframe load. */
+type LayersPanelHost = Pick<StudioShellValue, "previewIframeRef" | "activeCompPath" | "showToast"> & Pick<StudioPlaybackValue, "timelineElements" | "isPlaying"> & Partial<Pick<StudioPlaybackValue, "refreshKey" | "compositionLoading">>;
+declare const LayersPanel: react.NamedExoticComponent<{
+    host?: LayersPanelHost;
+}>;
+
+interface DomEditZOrder {
+    /** False in a read-only preview, for an element no longer in the live preview, or at that end of its stacking set. */
+    enabled: (sel: DomEditSelection, action: ZOrderAction) => boolean;
+    /** Resolve and commit one step; false when nothing is sent to be saved. */
+    apply: (sel: DomEditSelection, action: ZOrderAction) => boolean;
+    /** Commit patches already resolved (the canvas menu resolves its own); false when none could be sent to be saved. */
+    commit: (sel: DomEditSelection, patches: ReadonlyArray<ZOrderPatch>, action: ZOrderAction, crossed: HTMLElement | null) => boolean;
+}
+declare function useDomEditZOrder(): DomEditZOrder;
+
+interface RecordEditInput {
+    label: string;
+    coalesceKey?: string;
+    coalesceMs?: number;
+    files: Record<string, {
+        before: string;
+        after: string;
+    }>;
+}
+
+interface UseDomStyleCommitOptions {
+    projectId: string | null;
+    /** The preview the host already runs: the style applies there live, and it reseeks after a save. */
+    iframeRef: React.MutableRefObject<HTMLIFrameElement | null>;
+    /** The same function objects the host gives the timeline, so there is one writer and one undo list. */
+    writeProjectFile: (path: string, content: string, expectedContent?: string) => Promise<void>;
+    recordEdit: (entry: RecordEditInput) => Promise<void>;
+    activeCompPath?: string | null;
+    showToast?: (message: string, tone?: "error" | "info") => void;
+}
+/** Saves style edits on a selection through Studio's own style commit, for a host without the editor. */
+declare function useDomStyleCommit({ projectId, iframeRef, writeProjectFile, recordEdit, activeCompPath, showToast, }: UseDomStyleCommitOptions): {
+    commitStyle: (selection: DomEditSelection, styles: Record<string, string>) => Promise<DomEditCommitOutcome>;
+    waitForPendingSaves: () => Promise<DomEditSaveDrainResult>;
+};
+
+declare function ColorField({ label, value, disabled, onReset, flat, mixed, onPreview, onCommit, }: {
+    label: string;
+    value: string;
+    disabled?: boolean;
+    onReset?: () => void;
+    flat?: boolean;
+    mixed?: boolean;
+    onPreview?: (nextValue: string) => void;
+    onCommit: (nextValue: string) => void;
+}): react_jsx_runtime.JSX.Element;
+
+declare function GradientField({ value, fallbackColor, disabled, onCommit, }: {
+    value: string;
+    fallbackColor: string | undefined;
+    disabled?: boolean;
+    onCommit: (nextValue: string) => void;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Studio's `Player` must show the project, with `beginTimelineSession(projectId)` run before it
+ * mounts; drain `waitForPendingSaves` before switching projects.
+ */
+interface UseDomGeometryCommitOptions extends UseDomStyleCommitOptions {
+    /** Reloads the host's preview when a save cannot patch it in place. */
+    reloadPreview: () => void;
+}
+interface DomGeometryCommits {
+    commitPathOffset: (selection: DomEditSelection, next: {
+        x: number;
+        y: number;
+    }, modifiers?: MoveCommitOptions) => Promise<DomEditCommitOutcome>;
+    commitGroupPathOffset: (updates: DomEditGroupPathOffsetCommit[]) => Promise<DomEditCommitOutcome>;
+    commitBoxSize: (selection: DomEditSelection, next: {
+        width: number;
+        height: number;
+    }, offset?: {
+        x: number;
+        y: number;
+    }, restore?: () => void, route?: {
+        plainTranslate: boolean;
+    }) => Promise<DomEditCommitOutcome>;
+    commitRotation: (selection: DomEditSelection, next: RotationCommit) => Promise<DomEditCommitOutcome>;
+    waitForPendingSaves: () => Promise<void>;
+}
+/**
+ * Saves canvas moves, resizes and rotations through Studio's own GSAP-aware commits, for a host
+ * without the editor. A failed save rejects, so DomEditOverlay undoes the live gesture.
+ */
+declare function useDomGeometryCommit({ projectId, iframeRef, writeProjectFile, recordEdit, activeCompPath, showToast, reloadPreview, }: UseDomGeometryCommitOptions): DomGeometryCommits;
+
+interface MarqueeGesturesDeps<T = DomEditSelection> {
+    iframeRef: React.RefObject<HTMLIFrameElement | null>;
+    overlayRef: React.RefObject<HTMLDivElement | null>;
+    activeCompositionPathRef: React.RefObject<string | null>;
+    onMarqueeSelectRef: React.RefObject<((selections: T[], additive: boolean) => DomSelectionResult | void) | undefined>;
+    /** Turns the elements a drag touched into picks; without it, Studio's edit selections. */
+    resolveHits?: (elements: HTMLElement[]) => T[] | Promise<T[]>;
+    selectionRef?: React.RefObject<DomEditSelection | null>;
+    /** Studio's pointer handling, for the events that are not part of a marquee. */
+    gestures?: {
+        onPointerMove: (event: React.PointerEvent<HTMLDivElement>) => void;
+        onPointerUp: (event: React.PointerEvent<HTMLDivElement>) => void;
+        clearPointerState: (ref: React.RefObject<DomEditSelection | null>) => void;
+    };
+}
+interface MarqueeGestures {
+    marqueeRect: Rect$1 | null;
+    candidateRects: Rect$1[];
+    /** Starts a marquee at this press; the host has decided it landed on empty canvas. */
+    begin: (event: React.PointerEvent<HTMLElement>) => void;
+    /** Drops an active marquee without selecting anything. */
+    cancel: () => void;
+    onPointerMove: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: (event: React.PointerEvent<HTMLDivElement>) => void;
+    onPointerCancel: () => void;
+}
+declare function useMarqueeGestures(deps: MarqueeGesturesDeps): MarqueeGestures;
+declare function useMarqueeGestures<T>(deps: MarqueeGesturesDeps<T> & Required<Pick<MarqueeGesturesDeps<T>, "resolveHits">>): MarqueeGestures;
+
+interface MarqueeOverlayProps {
+    /** Elements the marquee currently intersects — outlined live before mouse-up. */
+    candidateRects: Rect$1[];
+    /** The marquee drag rectangle itself, or null when not marquee-selecting. */
+    marqueeRect: Rect$1 | null;
+}
+/**
+ * The marquee selection visuals: a live "candidate" outline on each element the
+ * box currently touches, plus the dashed drag rectangle. Extracted from
+ * DomEditOverlay to keep that file under the 600-line cap.
+ */
+declare function MarqueeOverlay({ candidateRects, marqueeRect }: MarqueeOverlayProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * The slice of the WebMCP browser API that Studio uses.
+ *
+ * Mirrors the WebIDL in the W3C spec (`webmachinelearning/webmcp`, `index.bs`)
+ * as of 2026-08-26. Two things worth knowing before editing this file:
+ *
+ * - The API hangs off `document`, NOT `navigator`. `navigator.modelContext` is
+ *   a polyfill compatibility shim, not a spec member, so feature-detecting it
+ *   is wrong even where an article's sample "works".
+ * - The spec is pre-stable (Origin Trial). This file and `registrar.ts` are the
+ *   only places that touch the API, so a spec change is a two-file edit. Re-read
+ *   `index.bs` rather than trusting this transcription.
+ *
+ * Only the surface Studio registers against is declared. `getTools` and
+ * `executeTool` are the consumer side; Studio registers, it does not call.
+ *
+ * These stay hand-written rather than imported from `@mcp-b/webmcp-types`,
+ * which the polyfill pulls in. That package's `registerTool` is overloaded to
+ * infer argument types from a literal `inputSchema`, which is useful when you
+ * register one tool inline and actively hostile when you register a uniform
+ * list of them, as `registerStudioTools` does. Narrower is the safe operation
+ * here. It does mean this file can drift from the spec, hence the note above.
+ */
+interface ModelContextToolAnnotations {
+    /** The tool does not change state. Lets an agent decide when calling is free. */
+    readOnlyHint?: boolean;
+    /** The tool's output contains data the page's author does not vouch for. */
+    untrustedContentHint?: boolean;
+}
+interface ToolExecuteCallbackOptions {
+    /**
+     * Aborted when the caller cancels. Studio's commit path is not cancellable
+     * once dispatched, so tools check this BEFORE dispatching and document that a
+     * late abort does not unwind a write.
+     */
+    signal: AbortSignal;
+}
+interface ModelContextTool {
+    /**
+     * Max 128 characters, ASCII alphanumeric plus `_`, `-`, `.`. Registering a
+     * name that already exists REJECTS with InvalidStateError; it does not
+     * replace.
+     */
+    name: string;
+    title?: string;
+    /** Required and non-empty; an empty string rejects with InvalidStateError. */
+    description: string;
+    /** JSON Schema. Nothing in the platform validates input against it. */
+    inputSchema?: object;
+    /**
+     * The user agent JSON-serializes whatever this resolves with, so it must
+     * return an object. Returning `undefined` fails the serialization.
+     *
+     * A rejection is NOT a usable error channel: the spec discards the reason and
+     * rejects the caller with a bare UnknownError. Resolve with a tagged failure
+     * instead. See `toolResult.ts`.
+     *
+     * `options` is optional here although the spec always passes it: the
+     * `@mcp-b/global` polyfill (through 5.1.0) calls `execute(input)` with no
+     * second argument, so a Studio handler must not depend on receiving one.
+     */
+    execute: (input: object, options?: ToolExecuteCallbackOptions) => Promise<unknown>;
+    annotations?: ModelContextToolAnnotations;
+}
+
+/**
+ * The shape every Studio tool resolves with.
+ *
+ * Tools resolve, they never reject. That is forced by the spec, not a style
+ * choice: a rejected `execute` has its reason DISCARDED and the caller is
+ * rejected with a bare `UnknownError` (`index.bs`, the execute-tool completion
+ * steps). Rejecting would therefore guarantee the agent cannot see why the edit
+ * failed, which is the one thing it needs most.
+ *
+ * There is no `outputSchema` in the platform yet, so this discriminant is
+ * invisible to the agent's schema layer. Every tool's `description` has to say
+ * that it returns `ok`.
+ */
+type ToolFailureKind = 
+/** A real state the agent can route around: save queue paused, capability off. */
+"blocked"
+/** The agent's fault: unknown handle, bad enum, out of range. */
+ | "invalid"
+/** Exogenous: the server said no, the patch target could not be resolved. */
+ | "failed"
+/** Our bug. Reported AND re-thrown, so it is findable instead of plausible. */
+ | "internal";
+interface ToolFailure {
+    ok: false;
+    kind: ToolFailureKind;
+    reason: string;
+    /** What to try instead. This is what turns a failure into a next action. */
+    hint?: string;
+}
+type ToolResult<T> = ({
+    ok: true;
+} & T) | ToolFailure;
+
+/**
+ * `studio_look`: the one call that orients an agent.
+ *
+ * Deliberately fat. Every field here is one the agent would otherwise have to
+ * spend a round trip discovering.
+ *
+ * The building is a pure function over a snapshot so it can be tested with
+ * values. Gathering the snapshot is the React layer's job.
+ */
+
+type StudioLookSceneSnapshot = {
+    status: "loading";
+} | {
+    status: "ready";
+    items: readonly DomEditLayerItem[];
+    drillInItem: DomEditLayerItem | null;
+};
+interface StudioLookSnapshot {
+    projectId: string | null;
+    compositionPath: string | null;
+    currentTime: number;
+    duration: number;
+    isPlaying: boolean;
+    elements: readonly TimelineElement[];
+    scene: StudioLookSceneSnapshot;
+    selection: DomEditSelection | null;
+    /** Live animations for the current selection arrive outside DomEditSelection. */
+    selectionAnimationCount: number;
+    /**
+     * The undo stack as Studio's shell actually exposes it.
+     *
+     * This is a weaker signal than a revision counter, and deliberately not
+     * dressed up as one: the depth lives in component-local state and is not
+     * reachable here without plumbing it through the shell context. What an agent
+     * CAN do is checkpoint `undoLabel` before a batch and notice it change to
+     * something it did not do, which means a human pressed undo and its earlier
+     * edits are gone.
+     */
+    history: {
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: string | null;
+        redoLabel: string | null;
+    };
+}
+/** Gather the live scene once per tool call. The response never retains DOM nodes. */
+declare function collectStudioLookScene(doc: Document | null, activeCompositionPath: string | null, activeGroupElement: HTMLElement | null): StudioLookSceneSnapshot;
+
+/**
+ * `studio_select` and `studio_seek`: pointing the human and the agent at the
+ * same thing.
+ *
+ * Selection is shared human-visible state. Element writes do not infer their
+ * target from it: they resolve an explicit source-safe handle per call. Keeping
+ * these contracts separate means a human click cannot redirect an agent write.
+ */
+
+interface SelectionToolDeps {
+    /** The preview iframe's document, or null before it mounts. */
+    getPreviewDocument: () => Document | null;
+    getCompositionPath: () => string | null;
+    getProjectId: () => string | null;
+    buildSelection: (element: HTMLElement) => Promise<DomEditSelection | null>;
+    applySelection: (selection: DomEditSelection) => void;
+    /** Out-of-loop seek. `requestSeek`, not `setCurrentTime`. */
+    requestSeek: (time: number) => void;
+    readPlayhead: () => {
+        currentTime: number;
+        duration: number;
+        isPlaying: boolean;
+    };
+}
+
+/**
+ * `studio_frame`: the eyes.
+ *
+ * Without this the tool set is a remote control. With it an agent can author a
+ * change, look at the instant it affects, judge it, and adjust. That loop is the
+ * one thing source alone cannot support, because "what does this look like at
+ * 2.4 seconds" is not a question a file can answer.
+ *
+ * Reuses Studio's existing capture endpoint (`utils/frameCapture`) rather than
+ * inventing a second one. The server renders the composition with Puppeteer, so
+ * the frame reflects the file on disk, not the live preview DOM.
+ */
+
+interface FrameToolDeps {
+    getProjectId: () => string | null;
+    getCompositionPath: () => string | null;
+    readPlayhead: () => {
+        currentTime: number;
+        duration: number;
+        isPlaying: boolean;
+    };
+    requestSeek: (time: number) => void;
+    /** Confirms the URL renders. Injected so tests need no network. */
+    probeFrame: (url: string) => Promise<{
+        ok: boolean;
+        status: number;
+    }>;
+    wait: (ms: number) => Promise<void>;
+}
+
+/**
+ * `studio_inspect`: everything about one element, in one call.
+ *
+ * The point is to prevent a failed write. Every field here either tells the
+ * agent what it can change (`can`, with `reasonIfDisabled` verbatim) or what it
+ * would be changing (the resolved styles, the text fields, the animations).
+ * An agent that reads this first should never attempt an edit the element will
+ * refuse.
+ *
+ * The GSAP diagnostics are here for the same reason: `multipleTimelines` and
+ * `unsupportedTimelinePattern` are states where animation editing is off, and
+ * learning that from a read is cheaper than learning it from a failed write.
+ */
+
+interface InspectToolDeps extends SelectionToolDeps {
+    /** What the human currently has selected, used when no handle is given. */
+    getCurrentSelection: () => DomEditSelection | null;
+    getGsapDiagnostics: () => {
+        animations: readonly GsapAnimation$1[];
+        multipleTimelines: boolean;
+        unsupportedTimelinePattern: boolean;
+    };
+}
+
+interface TargetedWriteDeps {
+    getPreviewDocument: () => Document | null;
+    getProjectId: () => string | null;
+    getWriteBlockedReason: () => string | null;
+    buildSelection: (element: HTMLElement) => Promise<DomEditSelection | null>;
+    applySelection: (selection: DomEditSelection) => void;
+}
+
+/**
+ * `studio_set_text` and `studio_set_style`: the first tools that change the file.
+ *
+ * The explicit source-safe handle is resolved to one selection per invocation.
+ * That captured selection is passed into Studio's existing commit actor; visible
+ * selection is presentation only and cannot redirect the write.
+ */
+
+interface ContentToolDeps extends TargetedWriteDeps {
+    setText: (selection: DomEditSelection, value: string, fieldKey?: string) => Promise<DomEditCommitOutcome>;
+    setStyle: (selection: DomEditSelection, property: string, value: string) => Promise<DomEditCommitOutcome>;
+}
+
+/**
+ * `studio_transform`: move, resize and rotate, as a drag would.
+ *
+ * This tool reads the element's box back after every write and reports what
+ * ACTUALLY changed. That is not belt-and-braces, it is the only thing standing
+ * between an agent and a silent lie, because two of the three handlers can do
+ * nothing and resolve:
+ *
+ * - The handlers exposed on `DomEditActionsValue` are the GSAP-AWARE wrappers
+ *   (`useDomEditSession.ts` aliases them), not the CSS ones in
+ *   `useDomGeometryCommits.ts`.
+ * - `handleGsapAwarePathOffsetCommit` and `handleGsapAwareRotationCommit` are
+ *   `if (gsapCommitMutation) { ...intercept... }` with NO else branch. In a
+ *   composition with no GSAP they return having done nothing. The adjacent
+ *   comments confirm that is deliberate: there is no CSS fallback to write to.
+ * - `handleGsapAwareBoxSizeCommit` is different. It runs through
+ *   `runGestureTransaction` with a scale route and a width/height route, so
+ *   resize works more generally than the other two.
+ *
+ * Read back, do not assume.
+ */
+
+interface ElementBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface TransformToolDeps extends TargetedWriteDeps {
+    /** The element's box as it renders right now. */
+    readBox: (selection: DomEditSelection) => ElementBox;
+    moveTo: (selection: DomEditSelection, next: {
+        x: number;
+        y: number;
+    }) => Promise<DomEditCommitOutcome | void>;
+    resizeTo: (selection: DomEditSelection, next: {
+        width: number;
+        height: number;
+    }) => Promise<DomEditCommitOutcome | void>;
+    rotateTo: (selection: DomEditSelection, next: {
+        angle: number;
+    }) => Promise<DomEditCommitOutcome | void>;
+}
+
+/**
+ * `studio_animate`: author motion.
+ *
+ * Add, update, and delete await the shared GSAP commit pipeline. Its promise is
+ * the single settlement boundary for persistence and live-preview sync, so a
+ * successful tool response never races ahead of the pixels the user sees.
+ * Keyframe writes still report dispatch because their existing actor catches
+ * its own failure instead of returning a landed signal.
+ */
+
+type GsapMethod = "to" | "from" | "set" | "fromTo";
+interface AnimationToolDeps extends TargetedWriteDeps {
+    getAnimationsForSelection: (selection: DomEditSelection) => Promise<readonly {
+        id: string;
+    }[]>;
+    readPlayhead: () => {
+        currentTime: number;
+        duration: number;
+        isPlaying: boolean;
+    };
+    addAnimation: (selection: DomEditSelection, method: GsapMethod) => Promise<boolean>;
+    updateAnimation: (selection: DomEditSelection, animationId: string, updates: {
+        duration?: number;
+        ease?: string;
+        position?: number;
+    }) => Promise<boolean>;
+    addKeyframe: (selection: DomEditSelection, animationId: string, percent: number, properties: Record<string, number | string>) => Promise<void>;
+    deleteAnimation: (selection: DomEditSelection, animationId: string) => Promise<boolean>;
+}
+
+interface StudioAgentToolsDeps extends SelectionToolDeps, FrameToolDeps, InspectToolDeps, ContentToolDeps, TransformToolDeps, AnimationToolDeps {
+    /** Read Studio's current state. Called per tool invocation, never cached. */
+    getSnapshot: () => StudioLookSnapshot;
+}
+/**
+ * Build the tool list once.
+ *
+ * Every `execute` reads `depsRef.current` at CALL time rather than closing over
+ * a snapshot, which is what lets the list be built once and still see live
+ * state. That is the whole point of the ref: see the registration note below.
+ */
+declare function buildStudioTools(depsRef: {
+    readonly current: StudioAgentToolsDeps;
+}): ModelContextTool[];
+
+export { type AgentModalAnchorPoint, type AgentPromptElementInfo, AskAgentModal, type AskAgentModalProps, AudioMeterStrip, type AudioMeterStripProps, AudioWaveform, type AudioWaveformProps, type BlockedTimelineEditIntent, type CanEditTimelineElement, ColorField, CompositionBreadcrumb, type CompositionDimensions, type CompositionLevel, CompositionThumbnail, ConnectedDomEditOverlay, type ConnectedDomEditOverlayProps, DEFAULT_SHORTCUT_SECTIONS, Dock, type DockController, type DomEditCapabilities, type DomEditCommitDeclineReason, type DomEditCommitOutcome, type DomEditGroupPathOffsetCommit, DomEditOverlay, type DomEditOverlayProps, DomEditProvider, type DomEditSelection, type DomEditZOrder, type DomGeometryCommits, type EditHistoryHandle, EditorShell, type EditorShellProps, type ExternalFileChangeBlockedState, type ExternalFileChangeCoordinatorHandle, ExternalFileConflictBanner, type FadeEdge, type FadeHandleBox, type FadeHandleClipBox, type FfmpegStatus, FileTree, GradientField, GridOverlay, ImageThumbnail, type ImageThumbnailProps, LayersPanel, type LayersPanelHost, type LinkShortcutCallbacks, type MarqueeGestures, type MarqueeGesturesDeps, MarqueeOverlay, type MarqueeOverlayProps, type Rect$1 as MarqueeRect, type ModelContextTool, NLEPreview, type PanelId, type PatchOperation, type PersistedRenderSettings, type PickedElement, PlayerControls, type PlayerHandle, type PlayerHandleElement, type PlayerHandleListener, type PlayerHandleTimeListener, type DomEditCompositionRect as PreviewCompositionRect, PreviewGuides, PreviewOverlayProvider, type PreviewOverlayProviderProps, type PreviewPromotion, PreviewReadOnlyProvider, type PreviewSnapPreferences, PropertyPanel, type RenderJob, RenderQueue, type RenderQueueProps, type ResolutionPreset, SNAP_THRESHOLD_PX, type ShortcutHint, type ShortcutSection, ShortcutsButton, type ShortcutsButtonProps, type SnapContext, type SnapEdge, type SnapGuide, SnapGuideOverlay, type SnapGuideOverlayProps, type SnapGuidesState, type Rect as SnapRect, type SnapResult, type SnapTarget, SnapToolbar, SourceEditor, type SpacingGuide, type StartRenderOptions, type StudioAgentToolsDeps, StudioApp, StudioFileConflictError, type StudioLookSnapshot, type StudioPendingEditsDrainResult, TRACK_H, type ThumbnailPriority, type ThumbnailStill, Timeline, TimelineClipMenu, type TimelineClipMenuItem, type TimelineClipRenderContext, type TimelineEditCallbacks, type TimelineEditOutcome, type TimelineEditPermission, TimelineEditPopover, TimelineEditProvider, type TimelineElement, TimelineEmptyStatePart, TimelineFrame, TimelineGapMenu, TimelineHistoryButtons, type TimelineHistoryButtonsProps, TimelineKeyframeMenu, TimelineLanes, TimelineOverlays, TimelinePane, type TimelinePaneProps, TimelinePlayhead, TimelineProvider, TimelineRazorGuide, TimelineRuler, TimelineShortcutHint, type TimelineTheme, type TimelineTimeRange$1 as TimelineTimeRange, TimelineToolbar, type TimelineToolbarProps, type TimelineTrackPadding, type TimelineZIndexReorderCommit, type ToolResult, type UseClipboardOptions, type UseDomEditSessionParams, type UseDomGeometryCommitOptions, type UseDomStyleCommitOptions, type UseEditHistoryActionsOptions, type UsePersistentEditHistoryOptions, type UsePreviewPersistenceParams, type UseProjectFileWriterOptions, type UseRenderClipContentOptions, type UseThumbnailStillOptions, type UseTimelineEditingOptions, VideoThumbnail, type ZOrderAction, applyPatch, buildCompositionSnapTarget, buildGridSnapEdges, buildPickerAgentContextPreview, buildPickerAgentPrompt, buildStudioTools, collectSnapContext, collectStudioLookScene, dispatchLinkShortcut, displayTrackOrder, extractSnapTargets, fadeHandleBoxes, findElementBlock, flushStudioPendingEdits, formatTime, getPersistedRenderSettings, liveTime, mergeStyleIntoTag, openAudioGainDialog, parseStyleString, persistRenderSettings, resolveDomEditSelection, resolveEquidistanceGuides, resolveGuideLineRect, resolveIframe, resolveSnapAdjustment, resolveSourceFile, revertNewestStudioPendingEdit, snapEngagedForTravel, useAudioGainDialogStore, useAudioMetersVisible, useClipboard, useCompositionStack, useDockLayoutStore, useDomEditSelectionContext, useDomEditSession, useDomEditZOrder, useDomGeometryCommit, useDomStyleCommit, useEditHistoryActions, useElementPicker, useLivePreviewIframe, useMarqueeGestures, usePersistentEditHistory, usePlayerHandle, usePlayerStore, usePreviewCompositionRect, usePreviewGuidesStore, usePreviewIframeStore, usePreviewOverlayContext, usePreviewPersistence, useProjectFileWriter, useRenderClipContent, useRenderQueue, useThumbnailStill, useTimelineContext, useTimelineEditing, useTimelinePlayer };