hyperframes 0.8.53 → 0.8.54

package/dist/studio/assets/{index-Y4OnpTEM.js → index-DkAzKuPZ.js}

@@ -1 +1 @@
-import{g as P}from"./index-HfP3sap2.js";function j(c,d){for(var s=0;s<d.length;s++){const a=d[s];if(typeof a!="string"&&!Array.isArray(a)){for(const i in a)if(i!=="default"&&!(i in c)){const l=Object.getOwnPropertyDescriptor(a,i);l&&Object.defineProperty(c,i,l.get?l:{enumerable:!0,get:()=>a[i]})}}}return Object.freeze(Object.defineProperty(c,Symbol.toStringTag,{value:"Module"}))}var v={},w;function k(){if(w)return v;w=1,Object.defineProperty(v,"__esModule",{value:!0}),v.default=d;var c=window.OfflineAudioContext||window.webkitOfflineAudioContext;function d(e){var r=a(e);return r.start(0),[i,y,O(e.sampleRate),s].reduce(function(t,o){return o(t)},r.buffer.getChannelData(0))}function s(e){return e.sort(function(r,t){return t.count-r.count}).splice(0,5)[0].tempo}function a(e){var r=e.length,t=e.numberOfChannels,o=e.sampleRate,n=new c(t,r,o),u=n.createBufferSource();u.buffer=e;var f=n.createBiquadFilter();return f.type="lowpass",u.connect(f),f.connect(n.destination),u}function i(e){for(var r=[],t=.9,o=.3,n=15;r.length<n&&t>=o;)r=l(e,t),t-=.05;if(r.length<n)throw new Error("Could not find enough samples for a reliable detection.");return r}function l(e,r){for(var t=[],o=0,n=e.length;o<n;o+=1)e[o]>r&&(t.push(o),o+=1e4);return t}function y(e){var r=[];return e.forEach(function(t,o){for(var n=function(x){var g=e[o+x]-t,_=r.some(function(h){if(h.interval===g)return h.count+=1});_||r.push({interval:g,count:1})},u=0;u<10;u+=1)n(u)}),r}function O(e){return function(r){var t=[];return r.forEach(function(o){if(o.interval!==0){for(var n=60/(o.interval/e);n<90;)n*=2;for(;n>180;)n/=2;n=Math.round(n);var u=t.some(function(f){if(f.tempo===n)return f.count+=o.count});u||t.push({tempo:n,count:o.count})}}),t}}return v}var p,b;function q(){return b||(b=1,p=k().default),p}var m=q();const A=P(m),D=j({__proto__:null,default:A},[m]);export{D as i};
+import{g as P}from"./index-DPUJoO8n.js";function j(c,d){for(var s=0;s<d.length;s++){const a=d[s];if(typeof a!="string"&&!Array.isArray(a)){for(const i in a)if(i!=="default"&&!(i in c)){const l=Object.getOwnPropertyDescriptor(a,i);l&&Object.defineProperty(c,i,l.get?l:{enumerable:!0,get:()=>a[i]})}}}return Object.freeze(Object.defineProperty(c,Symbol.toStringTag,{value:"Module"}))}var v={},w;function k(){if(w)return v;w=1,Object.defineProperty(v,"__esModule",{value:!0}),v.default=d;var c=window.OfflineAudioContext||window.webkitOfflineAudioContext;function d(e){var r=a(e);return r.start(0),[i,y,O(e.sampleRate),s].reduce(function(t,o){return o(t)},r.buffer.getChannelData(0))}function s(e){return e.sort(function(r,t){return t.count-r.count}).splice(0,5)[0].tempo}function a(e){var r=e.length,t=e.numberOfChannels,o=e.sampleRate,n=new c(t,r,o),u=n.createBufferSource();u.buffer=e;var f=n.createBiquadFilter();return f.type="lowpass",u.connect(f),f.connect(n.destination),u}function i(e){for(var r=[],t=.9,o=.3,n=15;r.length<n&&t>=o;)r=l(e,t),t-=.05;if(r.length<n)throw new Error("Could not find enough samples for a reliable detection.");return r}function l(e,r){for(var t=[],o=0,n=e.length;o<n;o+=1)e[o]>r&&(t.push(o),o+=1e4);return t}function y(e){var r=[];return e.forEach(function(t,o){for(var n=function(x){var g=e[o+x]-t,_=r.some(function(h){if(h.interval===g)return h.count+=1});_||r.push({interval:g,count:1})},u=0;u<10;u+=1)n(u)}),r}function O(e){return function(r){var t=[];return r.forEach(function(o){if(o.interval!==0){for(var n=60/(o.interval/e);n<90;)n*=2;for(;n>180;)n/=2;n=Math.round(n);var u=t.some(function(f){if(f.tempo===n)return f.count+=o.count});u||t.push({tempo:n,count:o.count})}}),t}}return v}var p,b;function q(){return b||(b=1,p=k().default),p}var m=q();const A=P(m),D=j({__proto__:null,default:A},[m]);export{D as i};

package/dist/studio/index.d.ts

@@ -1,5 +1,5 @@
 import * as react from 'react';
-import { ButtonHTMLAttributes, ReactNode, ElementType, ComponentPropsWithoutRef, ReactElement, RefObject } from 'react';
+import { ButtonHTMLAttributes, ReactNode, ElementType, ComponentPropsWithoutRef, ReactElement, RefObject, MutableRefObject } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Tabs as Tabs$1 } from '@base-ui/react/tabs';
 import * as node_modules_cn_dist_types from 'node_modules/cn/dist/types';
@@ -13,6 +13,7 @@ import { StoreApi } from 'zustand';
 import { MusicBeatAnalysis } from '@hyperframes/core/beats';
 import { GsapAnimation as GsapAnimation$1, ArcPathSegment } from '@hyperframes/parsers/gsap-parser';
 import { CanvasResolution } from '@hyperframes/parsers';
+import { Composition } from '@hyperframes/sdk';
 
 type ButtonVariant = "primary" | "secondary" | "danger" | "ghost";
 type ButtonSize = "sm" | "md" | "lg";
@@ -44,6 +45,8 @@ declare const buttonVariants: Record<ButtonVariant, string>;
 declare const buttonSizes: Record<ButtonSize, string>;
 declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
 
+declare function HyperframesLogo(): react_jsx_runtime.JSX.Element;
+
 interface IconButtonProps extends ButtonBaseProps {
     icon: ReactNode;
     "aria-label": string;
@@ -76,6 +79,20 @@ declare function Tab({ value, className, ...props }: TabProps): react_jsx_runtim
 /** The panel for one tab. Base UI wires `aria-labelledby` back to its tab. */
 declare function TabPanel({ className, ...props }: StyledProps$1<typeof Tabs$1.Panel>): react_jsx_runtime.JSX.Element;
 
+interface HyperframesLoaderProps {
+    /** Status text shown below the mark. */
+    title: string;
+    /** Optional secondary detail line. */
+    detail?: string;
+    /** Optional monospace third line for IDs, counts, or percentages. */
+    mono?: string;
+    /** Pixel size of the mark itself; status text scales independently. */
+    size?: number;
+    /** Optional normalized progress value from 0 to 1. */
+    progress?: number;
+}
+declare function HyperframesLoader({ title, detail, mono, size, progress, }: HyperframesLoaderProps): react_jsx_runtime.JSX.Element;
+
 interface TooltipProps {
     label: string;
     /** A single element, wrapped in a box-less span so a disabled one still gets hover. */
@@ -88,8 +105,6 @@ interface TooltipProps {
 }
 declare function Tooltip({ label, children, delay, side }: TooltipProps): react_jsx_runtime.JSX.Element;
 
-declare function HyperframesLogo(): react_jsx_runtime.JSX.Element;
-
 /**
  * Studio's tailwind-merge config: teaches it the two scales `theme.css`
  * invents (`text-step-*`, `ctl`/`ctl-sm`/`ctl-lg`) so overrides replace, not stack.
@@ -543,11 +558,14 @@ interface PlaybackReadinessSlice {
 }
 declare function createPlaybackReadinessSlice(set: StoreApi<PlaybackReadinessSlice>["setState"]): PlaybackReadinessSlice;
 
-type TimeListener = (time: number) => void;
-declare const liveTime: {
-    notify: (time: number) => void;
-    subscribe: (listener: TimeListener) => () => boolean;
-};
+interface TimelineTimeRange {
+    t0: number;
+    t1: number;
+}
+interface RangeSelectionSlice {
+    /** Shift-drag ruler range in seconds, normalized so t0 <= t1. */
+    rangeSelection: TimelineTimeRange | null;
+}
 
 /**
  * One row in the timeline: a clip as Studio needs it, translated from the
@@ -668,12 +686,18 @@ interface SubCompositionHostState {
     automation?: string;
 }
 
+type TimeListener = (time: number) => void;
+declare const liveTime: {
+    notify: (time: number) => void;
+    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>;
+type PlayerStoreSlices = KeyframeSlice & AutomationSelectionSlice & ThumbnailSlice & EditingModeSlice & ReturnType<typeof createPlaybackReadinessSlice> & RangeSelectionSlice;
 interface PlayerState extends PlayerStoreSlices {
     isPlaying: boolean;
     currentTime: number;
@@ -978,8 +1002,179 @@ declare function buildPickerAgentPrompt({ selection, userInstruction, }: {
 }): string;
 declare function buildPickerAgentContextPreview(selection: HyperframePickerElementInfo | null): string;
 
+type EditHistoryKind = "manual" | "motion" | "timeline" | "source";
+interface EditHistoryFileSnapshot {
+    before: string;
+    after: string;
+    beforeHash: string;
+    afterHash: string;
+}
+interface EditHistoryEntry {
+    id: string;
+    projectId: string;
+    label: string;
+    kind: EditHistoryKind;
+    coalesceKey?: string;
+    /** Per-entry coalesce window override (ms). Falls back to the reducer default. */
+    coalesceMs?: number;
+    createdAt: number;
+    files: Record<string, EditHistoryFileSnapshot>;
+}
+interface EditHistoryState {
+    version: 1;
+    updatedAt: number;
+    undo: EditHistoryEntry[];
+    redo: EditHistoryEntry[];
+}
+interface BuildEditHistoryEntryInput {
+    id: string;
+    projectId: string;
+    label: string;
+    kind?: EditHistoryKind;
+    coalesceKey?: string;
+    coalesceMs?: number;
+    now: number;
+    files: Record<string, {
+        before: string;
+        after: 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";
 
+/**
+ * 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;
+}
+
+/** 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;
+
+interface RecordEditInput$1 {
+    label: string;
+    kind: EditHistoryKind;
+    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$1) => 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;
+};
+
+interface TimelineGroupMoveChange {
+    element: TimelineElement;
+    start: number;
+    track?: number;
+}
+interface TimelineGroupResizeChange {
+    element: TimelineElement;
+    start: number;
+    duration: number;
+    playbackStart?: number;
+}
+interface TimelineGroupCommitOptions {
+    beforeTiming?: Promise<void>;
+    coalesceKey?: string;
+    /** Per-entry undo coalesce window override (ms) — see EditHistoryEntry.coalesceMs. */
+    coalesceMs?: number;
+    /** 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 TimelineMoveOperation = "timing" | "lane-reorder" | "track-insert";
 
 interface TimelineKeyframeTarget {
@@ -1130,6 +1325,8 @@ interface TimelineProps extends TimelineDropCallbacks, TimelineEditOverrides {
     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 | null) => void;
     onCopyClip?: () => boolean;
     onPasteClip?: () => Promise<void>;
     onDuplicateClip?: () => Promise<boolean>;
@@ -1749,4 +1946,237 @@ declare function findElementBlock(html: string, elementId: string): {
     isSelfClosing: boolean;
 } | null;
 
-export { type AgentModalAnchorPoint, type AgentPromptElementInfo, AskAgentModal, type AskAgentModalProps, Button, type ButtonSize, type ButtonVariant, CompositionBreadcrumb, type CompositionDimensions, type CompositionLevel, CompositionThumbnail, ContextMenu, EditorShell, type EditorShellProps, type FfmpegStatus, FileTree, HyperframesLogo, IconButton, Input, type InputProps, Menu, MenuItem, type MenuItemTone, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuShortcut, NLEPreview, NumberField, type NumberFieldProps, type PatchOperation, type PersistedRenderSettings, type PickedElement, Player, PlayerControls, Popover, type PopupPreviewState, type DomEditCompositionRect as PreviewCompositionRect, type PreviewState, PropertyPanel, type RenderJob, RenderQueue, type RenderQueueProps, type ResolutionPreset, Select, type SelectOption, type SelectProps, Slider, type SliderProps, SourceEditor, type StartRenderOptions, StudioApp, Tab, TabPanel, Tabs, TabsList, Timeline, type TimelineElement, Toggle, type ToggleProps, Tooltip, VideoThumbnail, applyPatch, buildPickerAgentContextPreview, buildPickerAgentPrompt, buttonBase, buttonSizes, buttonVariants, cn, fieldBase, fieldText, findElementBlock, formatTime, getPersistedRenderSettings, liveTime, mergeStyleIntoTag, parseStyleString, persistRenderSettings, popupSurface, resolveIframe, resolveSourceFile, useElementPicker, usePlayerStore, usePreviewCompositionRect, useRenderQueue, useTimelinePlayer };
+interface EditHistoryStorageAdapter {
+    get(projectId: string): Promise<EditHistoryState | null>;
+    set(projectId: string, state: EditHistoryState): Promise<void>;
+    delete(projectId: string): Promise<void>;
+}
+
+interface RecordEditInput {
+    label: string;
+    kind: EditHistoryKind;
+    coalesceKey?: string;
+    coalesceMs?: number;
+    files: BuildEditHistoryEntryInput["files"];
+}
+interface ApplyCallbacks {
+    readFile: (path: string) => Promise<string>;
+    writeFile: (path: string, content: string) => Promise<void>;
+    serialize?: <T>(paths: readonly string[], task: () => Promise<T>) => Promise<T>;
+}
+interface UsePersistentEditHistoryOptions {
+    projectId: string | null;
+    storage?: EditHistoryStorageAdapter;
+    now?: () => number;
+}
+/**
+ * Per-file content the restore just applied. `restored` is the bytes written to
+ * disk (the undo/redo target); `previous` is what was on disk immediately before
+ * (the current live preview state). The undo preview-sync diffs these to decide
+ * whether the restore is soft-reloadable (attributes/style/GSAP-script only) or
+ * needs a full iframe reload.
+ */
+interface ApplyRestoredFile {
+    previous: string;
+    restored: string;
+}
+interface ApplyResult {
+    ok: boolean;
+    reason?: "empty" | "content-mismatch";
+    label?: string;
+    paths?: string[];
+    files?: Record<string, ApplyRestoredFile>;
+}
+declare function usePersistentEditHistory(options: UsePersistentEditHistoryOptions): {
+    recordEdit: (input: RecordEditInput) => Promise<void>;
+    undo: (callbacks: ApplyCallbacks) => Promise<ApplyResult>;
+    redo: (callbacks: ApplyCallbacks) => Promise<ApplyResult>;
+    canUndo: boolean;
+    canRedo: boolean;
+    undoLabel: string;
+    redoLabel: string;
+    undoPaths: string[];
+    redoPaths: string[];
+    state: EditHistoryState;
+    loaded: boolean;
+};
+
+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<void>;
+        setLive: (groupId: string, attr: string, value: string | null) => void;
+    };
+    setElementFxAttribute: {
+        setQuiet: (element: TimelineElement, attr: string, value: string | null, label: string) => Promise<void>;
+        setLive: (element: TimelineElement, attr: string, value: string | null) => void;
+    };
+    handleTimelineElementDelete: (element: TimelineElement) => Promise<void>;
+    handleTimelineElementsDelete: (selection: TimelineElement[]) => Promise<void>;
+    handleTimelineElementSplit: (element: TimelineElement, splitTime: number) => Promise<void>;
+    handleRazorSplit: (element: TimelineElement, splitTime: 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>;
+};
+
+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;
+declare function flushStudioPendingEdits(): Promise<StudioPendingEditsDrainResult>;
+
+interface HistoryResult {
+    ok: boolean;
+    reason?: string;
+    label?: string;
+    paths?: string[];
+    /** Per-file restored/previous content, used to soft-apply the preview. */
+    files?: Record<string, {
+        previous: string;
+        restored: string;
+    }>;
+}
+interface HistoryFileCallbacks {
+    readFile: (path: string) => Promise<string>;
+    writeFile: (path: string, content: string) => Promise<void>;
+    serialize?: <T>(paths: readonly string[], task: () => Promise<T>) => Promise<T>;
+}
+interface EditHistoryHandle {
+    undo: (cb: HistoryFileCallbacks) => Promise<HistoryResult>;
+    redo: (cb: HistoryFileCallbacks) => Promise<HistoryResult>;
+    state: {
+        undo: ReadonlyArray<{
+            createdAt: number;
+        }>;
+        redo: ReadonlyArray<{
+            createdAt: number;
+        }>;
+    };
+}
+interface UseEditHistoryActionsOptions {
+    editHistory: Pick<EditHistoryHandle, "undo" | "redo">;
+    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>;
+    waitForPendingDomEditSaves: () => Promise<void>;
+    onAfterUndoRedo?: () => 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;
+}
+/** Applies one persisted file-history step: the single owner of undo/redo over project files. */
+declare function useEditHistoryActions({ editHistory, readOptionalProjectFile, readProjectFile, writeProjectFile, showToast, syncHistoryPreviewAfterApply, 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 | 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;
+}
+declare function TimelinePane({ timelineToolbar, timelineFooter, timelineOverlay, renderClipContent, onFileDrop, onDeleteElement, onAssetDrop, onBlockDrop, onCompositionDrop, onBlockedEditAttempt, onSelectTimelineElement, onRangeSelect, onCopyClip, onPasteClip, onDuplicateClip, canPasteClip, }: TimelinePaneProps): react_jsx_runtime.JSX.Element;
+
+declare function TimelineEditProvider({ value, children, }: {
+    value: TimelineEditCallbacks;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+export { type AgentModalAnchorPoint, type AgentPromptElementInfo, AskAgentModal, type AskAgentModalProps, type BlockedTimelineEditIntent, Button, type ButtonSize, type ButtonVariant, type CanEditTimelineElement, CompositionBreadcrumb, type CompositionDimensions, type CompositionLevel, CompositionThumbnail, ContextMenu, type EditHistoryHandle, EditorShell, type EditorShellProps, type ExternalFileChangeBlockedState, type ExternalFileChangeCoordinatorHandle, ExternalFileConflictBanner, type FfmpegStatus, FileTree, HyperframesLoader, type HyperframesLoaderProps, HyperframesLogo, IconButton, Input, type InputProps, Menu, MenuItem, type MenuItemTone, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuShortcut, NLEPreview, NumberField, type NumberFieldProps, type PatchOperation, type PersistedRenderSettings, type PickedElement, Player, PlayerControls, Popover, type PopupPreviewState, type DomEditCompositionRect as PreviewCompositionRect, type PreviewState, PropertyPanel, type RenderJob, RenderQueue, type RenderQueueProps, type ResolutionPreset, Select, type SelectOption, type SelectProps, Slider, type SliderProps, SourceEditor, type StartRenderOptions, StudioApp, StudioFileConflictError, type StudioPendingEditsDrainResult, Tab, TabPanel, Tabs, TabsList, Timeline, type TimelineEditCallbacks, type TimelineEditPermission, TimelineEditProvider, type TimelineElement, TimelinePane, type TimelinePaneProps, type TimelineTimeRange, Toggle, type ToggleProps, Tooltip, type UseEditHistoryActionsOptions, type UsePersistentEditHistoryOptions, type UseProjectFileWriterOptions, type UseTimelineEditingOptions, VideoThumbnail, applyPatch, buildPickerAgentContextPreview, buildPickerAgentPrompt, buttonBase, buttonSizes, buttonVariants, cn, fieldBase, fieldText, findElementBlock, flushStudioPendingEdits, formatTime, getPersistedRenderSettings, liveTime, mergeStyleIntoTag, parseStyleString, persistRenderSettings, popupSurface, resolveIframe, resolveSourceFile, useEditHistoryActions, useElementPicker, usePersistentEditHistory, usePlayerStore, usePreviewCompositionRect, useProjectFileWriter, useRenderQueue, useTimelineEditing, useTimelinePlayer };

package/dist/studio/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <title>HyperFrames Studio</title>
-    <script type="module" crossorigin src="/assets/index-HfP3sap2.js"></script>
+    <script type="module" crossorigin src="/assets/index-DPUJoO8n.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DrHQAuGO.css">
   </head>
   <body>