@rightkit/video-ui 0.0.0-stage → 0.1.0

package/dist/editor/adapter.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Revision-bound edit session against the canonical Rust timeline.
+ *
+ * The frontend owns only transient gesture state. On gesture release the
+ * session submits one transaction (one action, or a grouped list) stamped with
+ * the revision cursor the UI last saw. Undo/redo always pass `expect_cursor`
+ * (supported by the engine today). Edits pass `expect_cursor` only when the
+ * host advertises `edit.expect_cursor`; otherwise the session verifies the
+ * returned cursor advanced exactly as expected and reports a stale
+ * acknowledgement when it did not. Stale outcomes surface through `onStale`
+ * so the host refreshes `project.show` and rebuilds — never silently
+ * re-applied.
+ */
+import type { CapabilityReport } from "./capabilities.js";
+import type { EditAction } from "./actions.js";
+export type RevisionInfo = {
+    cursor: number;
+    total: number;
+    can_undo: boolean;
+    can_redo: boolean;
+};
+export type EditResponse = {
+    status?: string;
+    seq?: number | null;
+    revision?: RevisionInfo;
+    /** undo/redo: false when expect_cursor showed the step already happened. */
+    changed?: boolean;
+};
+export type EngineCall = (method: string, params: Record<string, unknown>) => Promise<unknown>;
+export type EditError = {
+    code?: string;
+    message?: string;
+};
+export declare class StaleEditError extends Error {
+    readonly expected: number;
+    readonly actual: number | null;
+    constructor(expected: number, actual: number | null);
+}
+export declare class EngineEditError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function errorCode(e: unknown): string | undefined;
+export declare function errorText(e: unknown): string;
+export type ApplyResult = {
+    /** Actions recorded as new revisions (retries/no-ops excluded). */
+    applied: number;
+    cursor: number;
+    /** True when at least one action was already applied (idempotent retry). */
+    retried: boolean;
+};
+export declare class EditSession {
+    private readonly dir;
+    private readonly caps;
+    private readonly call;
+    private readonly onStale?;
+    private cursor;
+    private inFlight;
+    constructor(dir: string, revisionCursor: number, caps: CapabilityReport | null, call: EngineCall, onStale?: ((expected: number, actual: number | null) => void) | undefined);
+    get revisionCursor(): number;
+    get busy(): boolean;
+    /** Re-seat the session after the host refetches `project.show`. */
+    resync(revisionCursor: number): void;
+    private stale;
+    private checkAck;
+    /**
+     * Submit one action (or a gesture's grouped actions) as a single logical
+     * transaction. Without `edit.batch`, grouped actions are applied sequentially
+     * — each lands as its own engine revision; `applied` reports how many
+     * recorded. A failure aborts the rest and reports `applied` for the caller
+     * to display honestly.
+     */
+    apply(actions: EditAction | EditAction[], label?: string): Promise<ApplyResult>;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+}

package/dist/editor/adapter.js

@@ -0,0 +1,181 @@
+import { supports } from "./capabilities.js";
+export class StaleEditError extends Error {
+    expected;
+    actual;
+    constructor(expected, actual) {
+        super(`timeline changed underneath the edit (expected revision ${expected}${actual == null ? "" : `, engine is at ${actual}`})`);
+        this.name = "StaleEditError";
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+export class EngineEditError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "EngineEditError";
+        this.code = code;
+    }
+}
+export function errorCode(e) {
+    if (e && typeof e === "object" && "code" in e) {
+        return String(e.code);
+    }
+    return undefined;
+}
+export function errorText(e) {
+    if (e instanceof Error)
+        return e.message;
+    if (e && typeof e === "object" && "message" in e) {
+        return String(e.message);
+    }
+    return String(e);
+}
+function asEditResponse(v) {
+    return v && typeof v === "object" ? v : {};
+}
+export class EditSession {
+    dir;
+    caps;
+    call;
+    onStale;
+    cursor;
+    inFlight = 0;
+    constructor(dir, revisionCursor, caps, call, onStale) {
+        this.dir = dir;
+        this.caps = caps;
+        this.call = call;
+        this.onStale = onStale;
+        this.cursor = revisionCursor;
+    }
+    get revisionCursor() {
+        return this.cursor;
+    }
+    get busy() {
+        return this.inFlight > 0;
+    }
+    /** Re-seat the session after the host refetches `project.show`. */
+    resync(revisionCursor) {
+        this.cursor = revisionCursor;
+    }
+    stale(expected, actual) {
+        this.onStale?.(expected, actual);
+        throw new StaleEditError(expected, actual);
+    }
+    checkAck(expectedBefore, res) {
+        const next = res.revision?.cursor;
+        if (next == null)
+            return; // engine did not report a cursor; nothing to verify
+        if (res.status === "already_applied" || res.status === "no_change") {
+            if (next !== expectedBefore)
+                this.stale(expectedBefore, next);
+            return;
+        }
+        if (next !== expectedBefore + 1)
+            this.stale(expectedBefore + 1, next);
+    }
+    /**
+     * Submit one action (or a gesture's grouped actions) as a single logical
+     * transaction. Without `edit.batch`, grouped actions are applied sequentially
+     * — each lands as its own engine revision; `applied` reports how many
+     * recorded. A failure aborts the rest and reports `applied` for the caller
+     * to display honestly.
+     */
+    async apply(actions, label) {
+        const list = Array.isArray(actions) ? actions : [actions];
+        if (list.length === 0)
+            return { applied: 0, cursor: this.cursor, retried: false };
+        this.inFlight += 1;
+        try {
+            if (list.length > 1 && supports("edit.batch", this.caps)) {
+                const params = {
+                    dir: this.dir,
+                    actions: list,
+                    label: label ?? null,
+                };
+                if (supports("edit.expect_cursor", this.caps))
+                    params.expect_cursor = this.cursor;
+                const res = asEditResponse(await this.call("edit", params));
+                // A batch records at most one revision: cursor advances by 0 or 1.
+                const next = res.revision?.cursor;
+                if (next != null && next !== this.cursor && next !== this.cursor + 1) {
+                    this.stale(this.cursor + 1, next);
+                }
+                const recorded = next === this.cursor + 1;
+                if (next != null)
+                    this.cursor = next;
+                return { applied: recorded ? list.length : 0, cursor: this.cursor, retried: !recorded };
+            }
+            let applied = 0;
+            let retried = false;
+            for (const action of list) {
+                const before = this.cursor;
+                const params = { dir: this.dir, action };
+                if (supports("edit.expect_cursor", this.caps))
+                    params.expect_cursor = before;
+                let res;
+                try {
+                    res = asEditResponse(await this.call("edit", params));
+                }
+                catch (e) {
+                    if (errorCode(e) === "cursor_mismatch") {
+                        const actual = e && typeof e === "object" && "actual" in e
+                            ? Number(e.actual)
+                            : null;
+                        this.stale(before, actual);
+                    }
+                    throw e;
+                }
+                this.checkAck(before, res);
+                if (res.status === "already_applied" || res.status === "no_change") {
+                    retried = true;
+                }
+                else {
+                    applied += 1;
+                    if (res.revision)
+                        this.cursor = res.revision.cursor;
+                }
+            }
+            return { applied, cursor: this.cursor, retried };
+        }
+        finally {
+            this.inFlight -= 1;
+        }
+    }
+    async undo() {
+        this.inFlight += 1;
+        try {
+            const res = asEditResponse(await this.call("undo", { dir: this.dir, expect_cursor: this.cursor }));
+            const next = res.revision?.cursor;
+            if (next != null)
+                this.cursor = next;
+            return res.status !== "unchanged" && res.status !== "noop" && res.changed !== false;
+        }
+        catch (e) {
+            if (errorCode(e) === "cursor_mismatch")
+                this.stale(this.cursor, null);
+            throw e;
+        }
+        finally {
+            this.inFlight -= 1;
+        }
+    }
+    async redo() {
+        this.inFlight += 1;
+        try {
+            const res = asEditResponse(await this.call("redo", { dir: this.dir, expect_cursor: this.cursor }));
+            const next = res.revision?.cursor;
+            if (next != null)
+                this.cursor = next;
+            return res.status !== "unchanged" && res.status !== "noop" && res.changed !== false;
+        }
+        catch (e) {
+            if (errorCode(e) === "cursor_mismatch")
+                this.stale(this.cursor, null);
+            throw e;
+        }
+        finally {
+            this.inFlight -= 1;
+        }
+    }
+}

package/dist/editor/capabilities.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Explicit capability gating between the editor gestures and what the live
+ * engine actually accepts. Every gesture resolves through `supports()`;
+ * unsupported controls render inert with a reason, never toast-only success.
+ *
+ * `extensions` is the optional list of negotiated engine extensions that the
+ * engine advertises (rightkit-video-project, project.rs). A capability
+ * opens when its extension id is advertised, with no frontend change.
+ */
+export type EditorCapability = 
+/** Single-action `edit` with an `expect_cursor` optimistic guard. Needs engine hunk `edit-expect-cursor`. */
+"edit.expect_cursor"
+/** One revision for a multi-action gesture. Needs engine hunk `edit.batch`. */
+ | "edit.batch"
+/** `split_clip` action on video/audio clips. Needs timeline hunk `action-split`. */
+ | "edit.split"
+/** Slip (move source range, keep output span). Needs timeline hunk `action-slip`. */
+ | "edit.slip"
+/** `ripple_delete_range` excises an output range across video tracks. */
+ | "edit.ripple_delete"
+/** Per-source decoded peak data for waveforms. Needs engine hunk `media.waveform`. */
+ | "media.waveform"
+/** Caption-track editing on the timeline. Needs caption contract work. */
+ | "edit.captions"
+/** Revision-bound rendered/native preview frames. Host-provided callback. */
+ | "preview.frames";
+export type CapabilityReport = {
+    /** Extensions the engine advertised (e.g. via `project.show` extension). */
+    extensions?: readonly string[];
+};
+export declare function supports(cap: EditorCapability, report?: CapabilityReport | null): boolean;
+export type UnsupportedReason = {
+    capability: EditorCapability;
+    reason: string;
+};
+export declare function unsupported(capability: EditorCapability): UnsupportedReason;
+export declare function reportCapabilities(extensions?: readonly string[]): CapabilityReport;

package/dist/editor/capabilities.js

@@ -0,0 +1,33 @@
+/**
+ * Explicit capability gating between the editor gestures and what the live
+ * engine actually accepts. Every gesture resolves through `supports()`;
+ * unsupported controls render inert with a reason, never toast-only success.
+ *
+ * `extensions` is the optional list of negotiated engine extensions that the
+ * engine advertises (rightkit-video-project, project.rs). A capability
+ * opens when its extension id is advertised, with no frontend change.
+ */
+const ALWAYS_SUPPORTED = new Set([]);
+export function supports(cap, report) {
+    if (ALWAYS_SUPPORTED.has(cap))
+        return true;
+    return report?.extensions?.includes(cap) ?? false;
+}
+const REASONS = {
+    "edit.expect_cursor": "Engine does not yet guard edits by revision cursor",
+    "edit.batch": "Engine applies one action per revision; grouped undo needs an engine update",
+    "edit.split": "Clip split is not yet a timeline action",
+    "edit.slip": "Slip editing is not yet a timeline action",
+    "edit.ripple_delete": "Range ripple-delete is not yet a timeline action",
+    "media.waveform": "No waveform data endpoint on the engine yet",
+    "edit.captions": "Caption-track editing is not yet on the timeline contract",
+    "preview.frames": "No revision-bound preview host is connected",
+};
+export function unsupported(capability) {
+    return { capability, reason: REASONS[capability] };
+}
+// Compatibility shim for the in-flight editor refactor: builds a report from
+// the engine-advertised extension ids.
+export function reportCapabilities(extensions) {
+    return { extensions };
+}

package/dist/editor/gesture.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Pure gesture → action planning. Pointer handlers report transient deltas
+ * here; on release the planned actions go through `EditSession.apply` as one
+ * transaction. Nothing here mutates the canonical timeline — the returned
+ * `EditAction`s are proposals the engine validates.
+ */
+import type { EditAction } from "./actions.js";
+import type { EditorClip, EditorModel } from "./model.js";
+export type Edge = "in" | "out";
+/** Snap `t` to the nearest grid step, or to a clip edge within `threshold` s. */
+export declare function snapTime(t: number, gridStep: number, edges: readonly number[], threshold: number): number;
+export declare function clipEdges(model: EditorModel, exclude: ReadonlySet<string>): number[];
+/**
+ * Video tracks are gapless: a horizontal drag is a reorder, never a free
+ * position. Returns the index the dragged clip occupies once removed, from the
+ * lane position of `dropTime`.
+ */
+export declare function videoDropIndex(lane: {
+    clips: EditorClip[];
+}, clipId: string, dropTime: number): number;
+/** Plan a completed move gesture for one clip. */
+export declare function planMove(model: EditorModel, clip: EditorClip, target: {
+    time?: number;
+    index?: number;
+}): EditAction[];
+/** Plan a completed multi-clip move: one action per clip (grouped transaction). */
+export declare function planMoveMany(model: EditorModel, clips: readonly EditorClip[], deltaS: number): EditAction[];
+/** Plan a completed edge trim. Returns [] when the trim is a no-op. */
+export declare function planTrim(model: EditorModel, clip: EditorClip, edge: Edge, deltaS: number): EditAction[];

package/dist/editor/gesture.js

@@ -0,0 +1,119 @@
+import { moveAudioClip, moveClip, moveTitle, trimAudioClip, trimClip, trimTitle, } from "./actions.js";
+/** Snap `t` to the nearest grid step, or to a clip edge within `threshold` s. */
+export function snapTime(t, gridStep, edges, threshold) {
+    let best = gridStep > 0 ? Math.round(t / gridStep) * gridStep : t;
+    let bestDist = Math.abs(best - t);
+    for (const e of edges) {
+        const d = Math.abs(e - t);
+        if (d <= threshold && d < bestDist) {
+            best = e;
+            bestDist = d;
+        }
+    }
+    return Math.max(0, best);
+}
+export function clipEdges(model, exclude) {
+    const out = [0];
+    for (const lane of model.lanes) {
+        for (const c of lane.clips) {
+            if (exclude.has(c.id))
+                continue;
+            out.push(c.start, c.start + c.duration);
+        }
+    }
+    return out;
+}
+/**
+ * Video tracks are gapless: a horizontal drag is a reorder, never a free
+ * position. Returns the index the dragged clip occupies once removed, from the
+ * lane position of `dropTime`.
+ */
+export function videoDropIndex(lane, clipId, dropTime) {
+    const clips = lane.clips.filter((c) => c.id !== clipId);
+    const idx = clips.findIndex((c) => dropTime < c.start + c.duration / 2);
+    return idx < 0 ? clips.length : idx;
+}
+/** Plan a completed move gesture for one clip. */
+export function planMove(model, clip, target) {
+    const lane = model.lanes.find((l) => l.id === clip.ref.trackId);
+    switch (clip.ref.kind) {
+        case "video": {
+            const index = target.index ??
+                (lane && target.time != null ? videoDropIndex(lane, clip.id, target.time) : clip.ref.index);
+            if (index === clip.ref.index)
+                return [];
+            return [moveClip(clip.id, index)];
+        }
+        case "audio": {
+            if (target.time == null)
+                return [];
+            return [moveAudioClip(clip.id, target.time)];
+        }
+        case "title": {
+            if (target.time == null)
+                return [];
+            return [moveTitle(clip.id, target.time * model.fps)];
+        }
+    }
+}
+/** Plan a completed multi-clip move: one action per clip (grouped transaction). */
+export function planMoveMany(model, clips, deltaS) {
+    const out = [];
+    for (const c of clips) {
+        if (c.ref.kind === "audio") {
+            out.push(...planMove(model, c, { time: Math.max(0, c.start + deltaS) }));
+        }
+        else if (c.ref.kind === "title") {
+            out.push(...planMove(model, c, { time: Math.max(0, c.start + deltaS) }));
+        }
+        // Video clips ignore pure time deltas — gapless track; reorder via drop index.
+    }
+    return out;
+}
+/** Plan a completed edge trim. Returns [] when the trim is a no-op. */
+export function planTrim(model, clip, edge, deltaS) {
+    if (deltaS === 0 || clip.duration <= 0)
+        return [];
+    switch (clip.ref.kind) {
+        case "video": {
+            const inS = clip.ref.clip.source_in / TICKS;
+            const outS = clip.ref.clip.source_out / TICKS;
+            const sourceDur = sourceDuration(model, clip.ref.clip.source);
+            const [lo, hi] = edge === "in"
+                ? [Math.max(0, Math.min(inS + deltaS, outS - MIN_CLIP_S)), outS]
+                : [inS, Math.min(sourceDur ?? Infinity, Math.max(outS + deltaS, inS + MIN_CLIP_S))];
+            if (lo === inS && hi === outS)
+                return [];
+            return [trimClip(clip.id, lo, hi)];
+        }
+        case "audio": {
+            const inS = clip.ref.clip.trim_in / TICKS;
+            const outS = clip.ref.clip.trim_out / TICKS;
+            const sourceDur = sourceDuration(model, clip.ref.clip.source);
+            const [lo, hi] = edge === "in"
+                ? [Math.max(0, Math.min(inS + deltaS, outS - MIN_CLIP_S)), outS]
+                : [inS, Math.min(sourceDur ?? Infinity, Math.max(outS + deltaS, inS + MIN_CLIP_S))];
+            if (lo === inS && hi === outS)
+                return [];
+            return [trimAudioClip(clip.id, lo, hi)];
+        }
+        case "title": {
+            const startF = clip.ref.clip.start_frame;
+            const frames = clip.ref.clip.frames;
+            const d = Math.round(deltaS * model.fps);
+            const [sf, fr] = edge === "in"
+                ? [startF + d, frames - d]
+                : [startF, frames + d];
+            if (fr < 1)
+                return [];
+            if (sf === startF && fr === frames)
+                return [];
+            return [trimTitle(clip.id, sf, fr)];
+        }
+    }
+}
+const TICKS = 705_600_000;
+const MIN_CLIP_S = 1 / 60;
+function sourceDuration(model, sourceId) {
+    return model.sourceDurationS.get(sourceId) ?? null;
+}

package/dist/editor/index.d.ts

@@ -0,0 +1,10 @@
+export { TimelineEditorView, type PreviewHost } from "./TimelineEditorView.js";
+export { Timeline } from "./Timeline.js";
+export { Inspector } from "./Inspector.js";
+export { EditSession, StaleEditError, EngineEditError } from "./adapter.js";
+export type { EditAction } from "./actions.js";
+export * as actions from "./actions.js";
+export { buildEditorModel, findClip } from "./model.js";
+export type { EditorModel, EditorClip, EditorLane } from "./model.js";
+export { supports, unsupported } from "./capabilities.js";
+export type { EditorCapability, CapabilityReport } from "./capabilities.js";

package/dist/editor/index.js

@@ -0,0 +1,7 @@
+export { TimelineEditorView } from "./TimelineEditorView.js";
+export { Timeline } from "./Timeline.js";
+export { Inspector } from "./Inspector.js";
+export { EditSession, StaleEditError, EngineEditError } from "./adapter.js";
+export * as actions from "./actions.js";
+export { buildEditorModel, findClip } from "./model.js";
+export { supports, unsupported } from "./capabilities.js";

package/dist/editor/keys.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from "react";
+import type { ShortcutDef } from "@rightkit/react-shell";
+/**
+ * Editor key bindings. The chords and labels are authored once here and registered on the
+ * shell's shortcut registry (by DesktopWorkspace), so Settings and the shortcut help list the
+ * real bindings. The timeline that is on screen supplies the actions through
+ * `useEditorKeys`; with none mounted, or focus outside it, a press is left to the page.
+ */
+export type EditorKeyId = "undo" | "redo" | "redoY" | "stepBack" | "stepForward" | "shuttleBack" | "pause" | "shuttleForward" | "remove" | "split";
+/** An action returns `false` when it did not handle the key, so the page default still runs. */
+export type EditorKeyHandlers = Partial<Record<EditorKeyId, (event: KeyboardEvent) => void | boolean>>;
+/** The registry definitions for the editor keys (register once, at the workspace). */
+export declare function editorShortcuts(): ShortcutDef[];
+/** Makes this editor the one the keys act on while focus is inside `scope`. */
+export declare function useEditorKeys(scope: RefObject<HTMLElement | null>, handlers: EditorKeyHandlers): void;

package/dist/editor/keys.js

@@ -0,0 +1,42 @@
+import { useEffect, useRef } from "react";
+const BINDINGS = [
+    { id: "undo", chord: "mod+z", label: "Undo" },
+    { id: "redo", chord: "shift+mod+z", label: "Redo" },
+    { id: "redoY", chord: "mod+y", label: "Redo", hidden: true },
+    { id: "stepBack", chord: "left", label: "Step back one frame" },
+    { id: "stepForward", chord: "right", label: "Step forward one frame" },
+    { id: "shuttleBack", chord: "j", label: "Shuttle back" },
+    { id: "pause", chord: "k", label: "Stop shuttle" },
+    { id: "shuttleForward", chord: "l", label: "Shuttle forward" },
+    { id: "remove", chord: ["backspace", "delete"], label: "Ripple-delete selection" },
+    { id: "split", chord: "s", label: "Split at playhead" },
+];
+let active = null;
+/** The registry definitions for the editor keys (register once, at the workspace). */
+export function editorShortcuts() {
+    return BINDINGS.map(({ id, chord, label, hidden }) => ({
+        id: `cr.editor.${id}`,
+        chord,
+        label,
+        group: "Editor",
+        hidden,
+        when: () => active !== null && active.inScope() && active.handlers()[id] !== undefined,
+        run: (event) => active?.handlers()[id]?.(event),
+    }));
+}
+/** Makes this editor the one the keys act on while focus is inside `scope`. */
+export function useEditorKeys(scope, handlers) {
+    const latest = useRef(handlers);
+    latest.current = handlers;
+    useEffect(() => {
+        const entry = {
+            handlers: () => latest.current,
+            inScope: () => scope.current?.contains(document.activeElement) ?? false,
+        };
+        active = entry;
+        return () => {
+            if (active === entry)
+                active = null;
+        };
+    }, [scope]);
+}

package/dist/editor/model.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Read model: folds `project.show` (`ProjectShow`) into flat editor lanes with
+ * second-based geometry. Rust owns canonical ticks/frames — this model only
+ * translates for display and gesture maths, and converts back on commit.
+ */
+import { type AudioClip, type OverlayClip, type ProjectShow, type VideoClip } from "../lib/project.js";
+export type LaneKind = "video" | "audio" | "overlay";
+export type EditorClipRef = {
+    kind: "video";
+    clip: VideoClip;
+    trackId: string;
+    index: number;
+} | {
+    kind: "audio";
+    clip: AudioClip;
+    trackId: string;
+    role: string;
+} | {
+    kind: "title";
+    clip: OverlayClip;
+    trackId: string;
+};
+export type EditorClip = {
+    id: string;
+    kind: LaneKind;
+    /** Timeline start in seconds. */
+    start: number;
+    /** Timeline duration in seconds. */
+    duration: number;
+    label: string;
+    ref: EditorClipRef;
+    /** Audio clip linked narration target (video clip id). */
+    link?: string | null;
+};
+export type EditorLane = {
+    id: string;
+    kind: LaneKind;
+    /** e.g. "V1", "Narr", "Music", "Titles". */
+    label: string;
+    clips: EditorClip[];
+};
+export type TextPosition = {
+    x: number;
+    y: number;
+};
+export type CaptionCorrection = {
+    text: string;
+    start_frame: number;
+    frames: number;
+    position: TextPosition;
+};
+export type EditorCaption = CaptionCorrection & {
+    id: string;
+    original_text: string;
+    corrected?: boolean;
+};
+export type EditorCorrections = {
+    captions: Record<string, CaptionCorrection>;
+    positions: Record<string, TextPosition>;
+    audio: Record<string, {
+        gain: number;
+        muted: boolean;
+    }>;
+};
+export type CorrectionShow = ProjectShow & {
+    editor_captions?: EditorCaption[];
+    timeline: ProjectShow["timeline"] & {
+        corrections?: EditorCorrections;
+    };
+};
+export type EditorModel = {
+    corrections: EditorCorrections;
+    captions: EditorCaption[];
+    sources: ProjectShow["sources"];
+    fps: number;
+    durationS: number;
+    revisionCursor: number;
+    revisionTotal: number;
+    canUndo: boolean;
+    canRedo: boolean;
+    lanes: EditorLane[];
+    clipCount: number;
+    /** Source id → duration in seconds (from registered source info ticks). */
+    sourceDurationS: ReadonlyMap<string, number>;
+};
+export declare function buildEditorModel(show: ProjectShow): EditorModel;
+export declare function findClip(model: EditorModel, id: string): EditorClip | null;
+export declare const buildModel: typeof buildEditorModel;