@tangle-network/agent-app 0.11.1 → 0.13.0

package/dist/sequences-react/index.js

@@ -0,0 +1,241 @@
+import {
+  COMMAND_HISTORY_LIMIT,
+  DEFAULT_MAX_MEDIA_ELEMENTS,
+  PreviewCanvas,
+  SEEK_TIMEOUT_MS,
+  SEEK_TOLERANCE_SECONDS,
+  SEQUENCE_MEDIA_DRAG_TYPE,
+  SnapIndicatorLine,
+  TimelineClipChip,
+  TimelineEditor,
+  TimelinePlayhead,
+  TimelineRuler,
+  TimelineTrackRow,
+  ZoomControl,
+  addCaptionCommand,
+  applySnap,
+  captionFontPx,
+  chooseMoveSnap,
+  classifyMediaUrl,
+  clipChipGeometry,
+  collectSnapPoints,
+  compositeCommand,
+  computeWaveform,
+  containFitRect,
+  createCommandStack,
+  createImageFrameProvider,
+  createMediaElementPool,
+  createPlaybackClock,
+  createVideoElementFrameProvider,
+  createZoomMath,
+  deleteClipCommand,
+  drawWaveform,
+  frameToPixel,
+  framesFromPixelDelta,
+  letterboxRect,
+  loadWaveform,
+  moveClipCommand,
+  moveDragStartFrame,
+  needsSeek,
+  pixelToFrame,
+  placeClipCommand,
+  selectTickStepSeconds,
+  setClipTextCommand,
+  snapPixel,
+  splitClipCommand,
+  toggleClipDisabledCommand,
+  trimClipCommand,
+  trimEndDrag,
+  trimStartDrag
+} from "../chunk-IHR6K3GF.js";
+import "../chunk-ZYBWGSAZ.js";
+
+// src/sequences-react/media/transcription.ts
+var DEFAULT_WHISPER_MODEL = "onnx-community/whisper-large-v3-turbo";
+var WHISPER_SAMPLE_RATE = 16e3;
+var TRANSCRIPTION_PEER = "@huggingface/transformers";
+var PEER_MISSING_MESSAGE = "transcription requires optional peer @huggingface/transformers";
+function mixdownToMono(buffer) {
+  if (buffer.numberOfChannels < 1) throw new Error("audio buffer has no channels \u2014 cannot mix down");
+  if (buffer.numberOfChannels === 1) return buffer.getChannelData(0);
+  const mono = new Float32Array(buffer.length);
+  for (let channel = 0; channel < buffer.numberOfChannels; channel++) {
+    const data = buffer.getChannelData(channel);
+    if (data.length !== buffer.length) {
+      throw new Error(`channel ${channel} has ${data.length} samples, expected ${buffer.length}`);
+    }
+    for (let i = 0; i < data.length; i++) {
+      mono[i] = mono[i] + data[i];
+    }
+  }
+  const scale = 1 / buffer.numberOfChannels;
+  for (let i = 0; i < mono.length; i++) {
+    mono[i] = mono[i] * scale;
+  }
+  return mono;
+}
+function mapWhisperOutput(output, durationSeconds, mediaUrl) {
+  const first = Array.isArray(output) ? output[0] : output;
+  if (first === void 0) throw new Error(`whisper produced no output for ${mediaUrl}`);
+  const chunks = first.chunks;
+  if (chunks === void 0 || chunks.length === 0) {
+    const text = first.text.trim();
+    return text.length === 0 ? [] : [{ text, startSeconds: 0, endSeconds: durationSeconds }];
+  }
+  const segments = [];
+  for (const chunk of chunks) {
+    const text = chunk.text.trim();
+    if (text.length === 0) continue;
+    const [start, end] = chunk.timestamp;
+    if (!Number.isFinite(start)) {
+      throw new Error(`whisper returned a non-numeric start timestamp for "${text}" in ${mediaUrl}`);
+    }
+    segments.push({ text, startSeconds: start, endSeconds: end === null ? durationSeconds : end });
+  }
+  return segments;
+}
+async function loadTransformers() {
+  try {
+    return await import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      TRANSCRIPTION_PEER
+    );
+  } catch (error) {
+    throw new Error(PEER_MISSING_MESSAGE, { cause: error });
+  }
+}
+async function fetchMonoAudio(mediaUrl) {
+  const response = await fetch(mediaUrl);
+  if (!response.ok) {
+    throw new Error(`failed to fetch media for transcription: ${response.status} ${response.statusText} from ${mediaUrl}`);
+  }
+  const bytes = await response.arrayBuffer();
+  if (typeof OfflineAudioContext === "undefined") {
+    throw new Error("transcription requires Web Audio (OfflineAudioContext) \u2014 call transcribe() from a browser");
+  }
+  const context = new OfflineAudioContext(1, 1, WHISPER_SAMPLE_RATE);
+  const decoded = await context.decodeAudioData(bytes);
+  return { samples: mixdownToMono(decoded), durationSeconds: decoded.duration };
+}
+function createWhisperTranscriptionProvider(opts) {
+  const model = opts?.model ?? DEFAULT_WHISPER_MODEL;
+  let availability = null;
+  let pipelinePromise = null;
+  const probeAvailability = () => {
+    if (availability !== null) return availability;
+    const resolve = import.meta.resolve;
+    if (typeof resolve !== "function") {
+      availability = false;
+      return availability;
+    }
+    try {
+      resolve.call(import.meta, TRANSCRIPTION_PEER);
+      availability = true;
+    } catch {
+      availability = false;
+    }
+    return availability;
+  };
+  const getPipeline = (transformers, onProgress) => {
+    if (pipelinePromise === null) {
+      const device = typeof navigator !== "undefined" && "gpu" in navigator ? "webgpu" : "wasm";
+      pipelinePromise = transformers.pipeline("automatic-speech-recognition", model, {
+        dtype: "q4",
+        device,
+        // Model download progress only — it dwarfs inference time on first
+        // use, and only the first transcribe ever sees a download.
+        progress_callback: (event) => {
+          if (event.status === "progress" && typeof event.progress === "number" && onProgress !== void 0) {
+            onProgress(Math.min(1, Math.max(0, event.progress / 100)));
+          }
+        }
+      });
+      pipelinePromise.catch(() => {
+        pipelinePromise = null;
+      });
+    }
+    return pipelinePromise;
+  };
+  return {
+    get available() {
+      return probeAvailability();
+    },
+    async transcribe(mediaUrl, transcribeOpts) {
+      const transformers = await loadTransformers();
+      availability = true;
+      const audio = await fetchMonoAudio(mediaUrl);
+      const transcriber = await getPipeline(transformers, transcribeOpts?.onProgress);
+      const options = {
+        return_timestamps: true,
+        chunk_length_s: 30,
+        stride_length_s: 5
+      };
+      if (transcribeOpts?.language !== void 0) options.language = transcribeOpts.language;
+      const output = await transcriber(audio.samples, options);
+      const segments = mapWhisperOutput(output, audio.durationSeconds, mediaUrl);
+      transcribeOpts?.onProgress?.(1);
+      return segments;
+    }
+  };
+}
+
+// src/sequences-react/lazy.tsx
+import React from "react";
+var SequenceTimelineEditorLazy = React.lazy(() => import("../TimelineEditor-OXPJZDP2.js"));
+export {
+  COMMAND_HISTORY_LIMIT,
+  DEFAULT_MAX_MEDIA_ELEMENTS,
+  DEFAULT_WHISPER_MODEL,
+  PreviewCanvas,
+  SEEK_TIMEOUT_MS,
+  SEEK_TOLERANCE_SECONDS,
+  SEQUENCE_MEDIA_DRAG_TYPE,
+  SequenceTimelineEditorLazy,
+  SnapIndicatorLine,
+  TimelineClipChip,
+  TimelineEditor,
+  TimelinePlayhead,
+  TimelineRuler,
+  TimelineTrackRow,
+  ZoomControl,
+  addCaptionCommand,
+  applySnap,
+  captionFontPx,
+  chooseMoveSnap,
+  classifyMediaUrl,
+  clipChipGeometry,
+  collectSnapPoints,
+  compositeCommand,
+  computeWaveform,
+  containFitRect,
+  createCommandStack,
+  createImageFrameProvider,
+  createMediaElementPool,
+  createPlaybackClock,
+  createVideoElementFrameProvider,
+  createWhisperTranscriptionProvider,
+  createZoomMath,
+  deleteClipCommand,
+  drawWaveform,
+  frameToPixel,
+  framesFromPixelDelta,
+  letterboxRect,
+  loadWaveform,
+  mapWhisperOutput,
+  mixdownToMono,
+  moveClipCommand,
+  moveDragStartFrame,
+  needsSeek,
+  pixelToFrame,
+  placeClipCommand,
+  selectTickStepSeconds,
+  setClipTextCommand,
+  snapPixel,
+  splitClipCommand,
+  toggleClipDisabledCommand,
+  trimClipCommand,
+  trimEndDrag,
+  trimStartDrag
+};
+//# sourceMappingURL=index.js.map

package/dist/sequences-react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/sequences-react/media/transcription.ts","../../src/sequences-react/lazy.tsx"],"sourcesContent":["/**\n * Whisper transcription behind the `TranscriptionProvider` seam, powered by\n * the OPTIONAL peer `@huggingface/transformers`. The peer is loaded with a\n * dynamic variable-specifier import inside `transcribe()` so bundlers leave\n * it external and apps that never transcribe never pay for it. `available`\n * is the sync UI affordance signal; `transcribe()` re-verifies with the real\n * import and is the source of truth.\n */\n\nimport type { TranscriptionProvider, TranscriptionSegment } from '../contracts'\nimport type { AudioBufferLike } from './waveform'\n\nexport const DEFAULT_WHISPER_MODEL = 'onnx-community/whisper-large-v3-turbo'\n\n/** Whisper models are trained on 16 kHz mono — decoding through a 16 kHz\n *  OfflineAudioContext resamples any source rate in one step. */\nconst WHISPER_SAMPLE_RATE = 16_000\n\nconst TRANSCRIPTION_PEER = '@huggingface/transformers'\nconst PEER_MISSING_MESSAGE = 'transcription requires optional peer @huggingface/transformers'\n\ninterface WhisperChunk {\n  text: string\n  timestamp: [number, number | null]\n}\n\nexport interface WhisperOutput {\n  text: string\n  chunks?: WhisperChunk[]\n}\n\ntype WhisperPipeline = (\n  audio: Float32Array,\n  options: Record<string, unknown>,\n) => Promise<WhisperOutput | WhisperOutput[]>\n\ninterface TransformersProgressEvent {\n  status: string\n  progress?: number\n}\n\ninterface TransformersModule {\n  pipeline(\n    task: 'automatic-speech-recognition',\n    model: string,\n    options?: Record<string, unknown>,\n  ): Promise<WhisperPipeline>\n}\n\n/** Mean-mixdown to mono. Single-channel buffers return the live channel data\n *  without copying — callers must treat the result as read-only. */\nexport function mixdownToMono(buffer: AudioBufferLike): Float32Array {\n  if (buffer.numberOfChannels < 1) throw new Error('audio buffer has no channels — cannot mix down')\n  if (buffer.numberOfChannels === 1) return buffer.getChannelData(0)\n  const mono = new Float32Array(buffer.length)\n  for (let channel = 0; channel < buffer.numberOfChannels; channel++) {\n    const data = buffer.getChannelData(channel)\n    if (data.length !== buffer.length) {\n      throw new Error(`channel ${channel} has ${data.length} samples, expected ${buffer.length}`)\n    }\n    for (let i = 0; i < data.length; i++) {\n      // in range by the length assertion above; casts silence noUncheckedIndexedAccess\n      mono[i] = (mono[i] as number) + (data[i] as number)\n    }\n  }\n  const scale = 1 / buffer.numberOfChannels\n  for (let i = 0; i < mono.length; i++) {\n    mono[i] = (mono[i] as number) * scale\n  }\n  return mono\n}\n\n/** Map whisper chunk output to contract segments. A `null` end timestamp is\n *  whisper's \"ran past the end of the audio\" sentinel on the final chunk and\n *  resolves to the audio duration. */\nexport function mapWhisperOutput(\n  output: WhisperOutput | WhisperOutput[],\n  durationSeconds: number,\n  mediaUrl: string,\n): TranscriptionSegment[] {\n  const first = Array.isArray(output) ? output[0] : output\n  if (first === undefined) throw new Error(`whisper produced no output for ${mediaUrl}`)\n  const chunks = first.chunks\n  if (chunks === undefined || chunks.length === 0) {\n    const text = first.text.trim()\n    return text.length === 0 ? [] : [{ text, startSeconds: 0, endSeconds: durationSeconds }]\n  }\n  const segments: TranscriptionSegment[] = []\n  for (const chunk of chunks) {\n    const text = chunk.text.trim()\n    if (text.length === 0) continue\n    const [start, end] = chunk.timestamp\n    if (!Number.isFinite(start)) {\n      throw new Error(`whisper returned a non-numeric start timestamp for \"${text}\" in ${mediaUrl}`)\n    }\n    segments.push({ text, startSeconds: start, endSeconds: end === null ? durationSeconds : end })\n  }\n  return segments\n}\n\nasync function loadTransformers(): Promise<TransformersModule> {\n  try {\n    // Variable specifier + ignore pragmas keep bundlers from statically\n    // resolving an optional peer that may not be installed.\n    return (await import(/* @vite-ignore */ /* webpackIgnore: true */ TRANSCRIPTION_PEER)) as TransformersModule\n  } catch (error) {\n    throw new Error(PEER_MISSING_MESSAGE, { cause: error })\n  }\n}\n\nasync function fetchMonoAudio(mediaUrl: string): Promise<{ samples: Float32Array; durationSeconds: number }> {\n  const response = await fetch(mediaUrl)\n  if (!response.ok) {\n    throw new Error(`failed to fetch media for transcription: ${response.status} ${response.statusText} from ${mediaUrl}`)\n  }\n  const bytes = await response.arrayBuffer()\n  if (typeof OfflineAudioContext === 'undefined') {\n    throw new Error('transcription requires Web Audio (OfflineAudioContext) — call transcribe() from a browser')\n  }\n  // decodeAudioData resamples to the context rate per the Web Audio spec, so\n  // a 16 kHz context yields whisper-ready samples from any source rate.\n  const context = new OfflineAudioContext(1, 1, WHISPER_SAMPLE_RATE)\n  const decoded = await context.decodeAudioData(bytes)\n  return { samples: mixdownToMono(decoded), durationSeconds: decoded.duration }\n}\n\nexport function createWhisperTranscriptionProvider(opts?: { model?: string }): TranscriptionProvider {\n  const model = opts?.model ?? DEFAULT_WHISPER_MODEL\n  let availability: boolean | null = null\n  let pipelinePromise: Promise<WhisperPipeline> | null = null\n\n  const probeAvailability = (): boolean => {\n    if (availability !== null) return availability\n    const resolve = (import.meta as ImportMeta & { resolve?: (specifier: string) => string }).resolve\n    if (typeof resolve !== 'function') {\n      // No sync resolver in this runtime — report unavailable rather than\n      // guess; transcribe() still attempts the real import either way.\n      availability = false\n      return availability\n    }\n    try {\n      resolve.call(import.meta, TRANSCRIPTION_PEER)\n      availability = true\n    } catch {\n      availability = false\n    }\n    return availability\n  }\n\n  const getPipeline = (\n    transformers: TransformersModule,\n    onProgress?: (fraction: number) => void,\n  ): Promise<WhisperPipeline> => {\n    if (pipelinePromise === null) {\n      const device = typeof navigator !== 'undefined' && 'gpu' in navigator ? 'webgpu' : 'wasm'\n      pipelinePromise = transformers.pipeline('automatic-speech-recognition', model, {\n        dtype: 'q4',\n        device,\n        // Model download progress only — it dwarfs inference time on first\n        // use, and only the first transcribe ever sees a download.\n        progress_callback: (event: TransformersProgressEvent) => {\n          if (event.status === 'progress' && typeof event.progress === 'number' && onProgress !== undefined) {\n            onProgress(Math.min(1, Math.max(0, event.progress / 100)))\n          }\n        },\n      })\n      // A failed load must not poison the cache — the next transcribe retries.\n      pipelinePromise.catch(() => {\n        pipelinePromise = null\n      })\n    }\n    return pipelinePromise\n  }\n\n  return {\n    get available() {\n      return probeAvailability()\n    },\n    async transcribe(mediaUrl, transcribeOpts) {\n      const transformers = await loadTransformers()\n      // A successful import is ground truth and overrides a false probe.\n      availability = true\n      const audio = await fetchMonoAudio(mediaUrl)\n      const transcriber = await getPipeline(transformers, transcribeOpts?.onProgress)\n      const options: Record<string, unknown> = {\n        return_timestamps: true,\n        chunk_length_s: 30,\n        stride_length_s: 5,\n      }\n      if (transcribeOpts?.language !== undefined) options.language = transcribeOpts.language\n      const output = await transcriber(audio.samples, options)\n      const segments = mapWhisperOutput(output, audio.durationSeconds, mediaUrl)\n      transcribeOpts?.onProgress?.(1)\n      return segments\n    },\n  }\n}\n","/**\n * Code-split entry for the timeline editor. The editor pulls in canvas\n * painting, waveform decode, and gesture machinery products only need on the\n * sequence route — `React.lazy` keeps it out of their main bundle. Mount\n * inside a `<Suspense>` boundary.\n */\n\nimport React from 'react'\n\nexport const SequenceTimelineEditorLazy = React.lazy(() => import('./components/TimelineEditor'))\n"],"mappings":"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","names":[]}

package/dist/store-CUStmtdH.d.ts

@@ -0,0 +1,64 @@
+import { c as SceneDocument } from './model-BHLN208Z.js';
+
+/**
+ * Storage contract for design-canvas documents. Unlike sequences (row per
+ * clip), a scene document persists as ONE JSON value with a monotonic
+ * revision counter — saves are atomic and optimistic: a save carrying a
+ * stale `expectedRev` throws, the caller refetches and replays. That keeps
+ * concurrent editors (human + agent in the same document) from silently
+ * clobbering each other without needing row-level merge machinery.
+ *
+ * The product constructs one store per (workspace, document, actor) request
+ * scope — RBAC runs BEFORE construction; the store never re-checks identity.
+ * Every method throws on failure; the MCP dispatcher converts throws into
+ * structured tool errors.
+ */
+
+interface SceneDocumentRecord {
+    document: SceneDocument;
+    /** Monotonic revision; increments on every successful save. */
+    rev: number;
+}
+interface SceneDecision {
+    id: string;
+    kind: 'human_edit' | 'agent_edit' | 'agent_proposal' | 'export' | 'note';
+    instruction: string;
+    reasoningSummary: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+interface NewSceneDecision {
+    kind: SceneDecision['kind'];
+    instruction: string;
+    reasoningSummary?: string | null;
+    metadata?: Record<string, unknown>;
+}
+type SceneExportFormat = 'png' | 'jpeg' | 'json';
+interface SceneExportRecord {
+    id: string;
+    format: SceneExportFormat;
+    status: 'queued' | 'processing' | 'completed' | 'failed';
+    resultUrl: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+interface SceneStore {
+    /** Current document + revision. */
+    getDocument(): Promise<SceneDocumentRecord>;
+    /** Atomic full-document save. Throws when `expectedRev` is stale — the
+     *  caller must refetch, reapply, and retry; never merge silently. */
+    saveDocument(document: SceneDocument, expectedRev: number): Promise<SceneDocumentRecord>;
+    recordDecision(input: NewSceneDecision): Promise<SceneDecision>;
+    createExport(format: SceneExportFormat, metadata?: Record<string, unknown>): Promise<SceneExportRecord>;
+    listDecisions(limit?: number): Promise<SceneDecision[]>;
+    listExports(limit?: number): Promise<SceneExportRecord[]>;
+}
+/** Per-request scope a product binds at store construction; decision and
+ *  export rows attribute to the acting user — never trusted from tool args. */
+interface SceneStoreScope {
+    workspaceId: string;
+    documentId: string;
+    userId: string;
+}
+
+export type { NewSceneDecision as N, SceneDecision as S, SceneDocumentRecord as a, SceneExportFormat as b, SceneExportRecord as c, SceneStore as d, SceneStoreScope as e };

package/dist/store-gckrNq-g.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Frame-accurate sequence timeline model — the product-agnostic spine of the
+ * sequences surface. A sequence is a fixed-fps, fixed-duration timeline of
+ * tracks; clips sit on tracks at integer frame positions with non-destructive
+ * source in/out points. Products bind this model to their own storage through
+ * `SequenceStore` (./store) and surface it to agents through the MCP toolset
+ * (./mcp).
+ *
+ * All positions and durations are integer FRAMES at the sequence's fps.
+ * Seconds appear only at the API edge (agent tools speak seconds; the
+ * dispatcher converts exactly once). Nothing here touches a database, the DOM,
+ * or React.
+ */
+declare const MIN_SEQUENCE_CLIP_FRAMES = 1;
+/** Track kinds. `reference` holds non-rendered guide media; `agent` holds the
+ *  agent-decision lane rendered as markers, never as media. */
+type SequenceTrackKind = 'video' | 'audio' | 'caption' | 'reference' | 'agent';
+type SequenceStatus = 'draft' | 'active' | 'exporting' | 'archived';
+type SequenceExportFormat = 'mp4' | 'otio' | 'xml' | 'edl' | 'vtt' | 'srt' | 'contact_sheet';
+type SequenceExportStatus = 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
+type SequenceMediaKind = 'video' | 'image' | 'audio';
+interface SequenceMeta {
+    id: string;
+    title: string;
+    fps: number;
+    width: number;
+    height: number;
+    aspectRatio: string;
+    durationFrames: number;
+    status: SequenceStatus;
+    metadata: Record<string, unknown>;
+}
+interface SequenceTrack {
+    id: string;
+    kind: SequenceTrackKind;
+    name: string;
+    sortOrder: number;
+    locked: boolean;
+    muted: boolean;
+    metadata: Record<string, unknown>;
+}
+/** Resolved playable media behind a clip. The store resolves product-specific
+ *  references (generation rows, asset rows) into this shape; the core model
+ *  never sees the product's tables. */
+interface SequenceClipMedia {
+    url: string;
+    kind: SequenceMediaKind;
+    /** Natural duration of the source media when known. */
+    durationSeconds?: number;
+    /** Provider job state for media still rendering upstream. */
+    providerStatus?: 'queued' | 'processing' | 'completed' | 'failed';
+}
+interface SequenceClip {
+    id: string;
+    trackId: string;
+    label: string;
+    startFrame: number;
+    durationFrames: number;
+    /** Source-relative in point (frames into the source media). */
+    sourceInFrame: number;
+    /** Source-relative out point; null = natural end of the source. */
+    sourceOutFrame: number | null;
+    disabled: boolean;
+    /** Caption/text body for clips on caption tracks. */
+    text?: string;
+    /** BCP-47 language tag for caption clips (e.g. 'en', 'es', 'ja'). */
+    language?: string;
+    /** Opaque product reference to a generation row, when the clip came from one. */
+    generationId?: string;
+    /** Opaque product reference to an asset row, when the clip came from one. */
+    assetId?: string;
+    media?: SequenceClipMedia;
+    metadata: Record<string, unknown>;
+}
+/** One entry in the sequence's decision log — human edits, agent proposals,
+ *  agent edits, exports, and notes all land here so the edit history is a
+ *  single auditable lane. */
+interface SequenceDecision {
+    id: string;
+    clipId: string | null;
+    kind: 'human_edit' | 'agent_proposal' | 'agent_edit' | 'export' | 'note';
+    instruction: string;
+    reasoningSummary: string | null;
+    accepted: boolean | null;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+interface SequenceExportRecord {
+    id: string;
+    format: SequenceExportFormat;
+    status: SequenceExportStatus;
+    resultUrl: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+/** The full timeline aggregate — what `get_timeline_state` returns and what
+ *  every operation validates against. */
+interface SequenceTimeline {
+    sequence: SequenceMeta;
+    tracks: SequenceTrack[];
+    clips: SequenceClip[];
+}
+/** What is on screen/audible at a single frame — the answer shape for
+ *  "what is happening at 0:34". */
+interface SequenceFrameSnapshot {
+    frame: number;
+    seconds: number;
+    /** Active (enabled, in-range) clips at this frame, with their track. */
+    active: Array<{
+        track: SequenceTrack;
+        clip: SequenceClip;
+    }>;
+    /** Caption text visible at this frame, in track sort order. */
+    captions: Array<{
+        text: string;
+        language?: string;
+        clipId: string;
+    }>;
+}
+declare function secondsToFrames(seconds: number, fps: number): number;
+declare function framesToSeconds(frames: number, fps: number): number;
+declare function formatSeconds(seconds: number): string;
+/** `m:ss.ff` timecode for UI and agent-readable frame references. */
+declare function formatTimecode(frames: number, fps: number): string;
+interface TimelineClipBounds {
+    startFrame: number;
+    durationFrames: number;
+}
+interface TimelineInterval {
+    startFrame: number;
+    endFrame: number;
+}
+declare function clampClipStart(input: {
+    startFrame: number;
+    durationFrames: number;
+    sequenceDurationFrames: number;
+}): number;
+declare function clampClipDuration(input: {
+    startFrame: number;
+    durationFrames: number;
+    sequenceDurationFrames: number;
+}): number;
+declare function assertClipFitsSequence(input: {
+    startFrame: number;
+    durationFrames: number;
+    sequenceDurationFrames: number;
+    label: string;
+}): void;
+/** Place a caption near the playhead inside FREE space only — the caption
+ *  track never double-books. Prefers fps*3 frames, floors at fps. The gap
+ *  holding (or first after) the playhead wins; with everything ahead occupied
+ *  the latest earlier gap is used instead. Throws when no gap can hold the
+ *  minimum — the caller must supply explicit bounds or clear space. */
+declare function chooseCaptionPlacement(input: {
+    playheadFrame: number;
+    fps: number;
+    sequenceDurationFrames: number;
+    occupiedIntervals: TimelineInterval[];
+}): TimelineClipBounds;
+/** Resolve everything active at one frame — the core of `get_frame_at_time`. */
+declare function snapshotFrame(timeline: SequenceTimeline, frame: number): SequenceFrameSnapshot;
+/** Occupied intervals on one track, for placement collision checks. */
+declare function trackIntervals(timeline: SequenceTimeline, trackId: string): TimelineInterval[];
+
+/**
+ * Storage contract binding the sequence model to a product's database. The
+ * product constructs one store per (workspace, sequence, actor) request scope —
+ * RBAC and workspace isolation happen BEFORE construction (the product's
+ * `requireWorkspaceAccess` equivalent); the store never re-checks identity.
+ *
+ * Every method throws on failure — no silent nulls, no `{ ok: false }` wrappers
+ * at this layer. The MCP dispatcher (./mcp) is the boundary that converts
+ * thrown errors into structured tool errors the model can read and react to.
+ *
+ * Mutations append to the decision log themselves only when the operation
+ * dispatcher asks (`recordDecision`); plain CRUD stays log-free so human edits
+ * driven by the UI can batch their own decision entries.
+ */
+
+interface NewSequenceTrack {
+    kind: SequenceTrackKind;
+    name: string;
+    sortOrder?: number;
+}
+interface NewSequenceClip {
+    trackId: string;
+    label: string;
+    startFrame: number;
+    durationFrames: number;
+    sourceInFrame?: number;
+    sourceOutFrame?: number | null;
+    text?: string;
+    language?: string;
+    generationId?: string;
+    assetId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SequenceClipPatch {
+    trackId?: string;
+    label?: string;
+    startFrame?: number;
+    durationFrames?: number;
+    sourceInFrame?: number;
+    sourceOutFrame?: number | null;
+    disabled?: boolean;
+    text?: string;
+    language?: string;
+    metadata?: Record<string, unknown>;
+}
+interface NewSequenceDecision {
+    clipId?: string | null;
+    kind: SequenceDecision['kind'];
+    instruction: string;
+    reasoningSummary?: string | null;
+    accepted?: boolean | null;
+    metadata?: Record<string, unknown>;
+}
+interface SequenceStore {
+    /** Full aggregate: sequence meta + tracks + clips with resolved media. */
+    getTimeline(): Promise<SequenceTimeline>;
+    getClip(clipId: string): Promise<SequenceClip>;
+    createTrack(input: NewSequenceTrack): Promise<SequenceTrack>;
+    createClip(input: NewSequenceClip): Promise<SequenceClip>;
+    updateClip(clipId: string, patch: SequenceClipPatch): Promise<SequenceClip>;
+    deleteClip(clipId: string): Promise<void>;
+    /** Grow (or shrink, never below the last clip end) the sequence duration. */
+    updateSequenceDuration(durationFrames: number): Promise<SequenceMeta>;
+    recordDecision(input: NewSequenceDecision): Promise<SequenceDecision>;
+    createExport(format: SequenceExportFormat, metadata?: Record<string, unknown>): Promise<SequenceExportRecord>;
+    listDecisions(limit?: number): Promise<SequenceDecision[]>;
+    listExports(limit?: number): Promise<SequenceExportRecord[]>;
+}
+/** Per-request scope a product binds when constructing its store. Carried so
+ *  decision rows and export rows attribute to the acting user; never trusted
+ *  from tool arguments. */
+interface SequenceStoreScope {
+    workspaceId: string;
+    sequenceId: string;
+    userId: string;
+}
+
+export { snapshotFrame as A, trackIntervals as B, MIN_SEQUENCE_CLIP_FRAMES as M, type NewSequenceClip as N, type SequenceClip as S, type TimelineClipBounds as T, type NewSequenceDecision as a, type NewSequenceTrack as b, type SequenceClipMedia as c, type SequenceClipPatch as d, type SequenceDecision as e, type SequenceExportFormat as f, type SequenceExportRecord as g, type SequenceExportStatus as h, type SequenceFrameSnapshot as i, type SequenceMediaKind as j, type SequenceMeta as k, type SequenceStatus as l, type SequenceStore as m, type SequenceStoreScope as n, type SequenceTimeline as o, type SequenceTrack as p, type SequenceTrackKind as q, type TimelineInterval as r, assertClipFitsSequence as s, chooseCaptionPlacement as t, clampClipDuration as u, clampClipStart as v, formatSeconds as w, formatTimecode as x, framesToSeconds as y, secondsToFrames as z };