@tangle-network/agent-app 0.11.1 → 0.12.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-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 };

package/dist/tools/index.d.ts

@@ -1,4 +1,6 @@
-import { b as AppToolContext, f as AppToolTaxonomy, c as AppToolHandlers, e as AppToolProducedEvent, d as AppToolOutcome } from '../types-By4B3K37.js';
+import { b as AppToolName, f as ToolHeaderNames } from '../mcp-CIupfjxV.js';
+export { A as APP_TOOL_NAMES, a as AppToolMcpServer, c as AuthenticateOptions, B as BuildHttpMcpServerOptions, d as BuildMcpServerOptions, D as DEFAULT_APP_TOOL_PATHS, e as DEFAULT_HEADER_NAMES, O as OpenAIFunctionTool, T as ToolAuthResult, g as authenticateToolRequest, h as buildAppToolMcpServer, i as buildAppToolOpenAITools, j as buildHttpMcpServer, k as isAppToolName, r as readToolArgs } from '../mcp-CIupfjxV.js';
+import { c as AppToolHandlers, f as AppToolTaxonomy, b as AppToolContext, e as AppToolProducedEvent, d as AppToolOutcome } from '../types-By4B3K37.js';
 export { A as AddCitationArgs, a as AddCitationResult, R as RenderUiArgs, g as RenderUiResult, S as ScheduleFollowupArgs, h as ScheduleFollowupResult, i as SubmitProposalArgs, j as SubmitProposalResult } from '../types-By4B3K37.js';
 
 /** A correctable bad-input error a tool handler throws; the HTTP layer maps it
@@ -39,65 +41,29 @@ declare function createCapabilityToken(userId: string, opts: CapabilityTokenOpti
 /** Verify a capability token against `userId`. Returns false (never throws) for
  *  an unconfigured secret, a wrong prefix, a malformed token, or a mismatch. */
 declare function verifyCapabilityToken(userId: string, token: string, opts: CapabilityTokenOptions): Promise<boolean>;
-
-/**
- * Header names carrying the server-set per-turn context + the capability token.
- * Defaults are product-neutral (`X-Agent-App-*`); a product that already ships
- * a header convention (e.g. `X-Acme-User-Id`) passes its own.
- */
-interface ToolHeaderNames {
-    userId: string;
-    workspaceId: string;
-    threadId: string;
-}
-declare const DEFAULT_HEADER_NAMES: ToolHeaderNames;
-interface AuthenticateOptions {
-    /** Verify the bearer capability token belongs to `userId`. The product's
-     *  HMAC/JWT impl — the seam that keeps token crypto out of this package. */
-    verifyToken: (userId: string, bearer: string) => Promise<boolean>;
-    headerNames?: ToolHeaderNames;
-}
-type ToolAuthResult = {
-    ok: true;
-    ctx: AppToolContext;
-} | {
-    ok: false;
-    response: Response;
-};
-/**
- * Recover + verify the trusted context for a tool request. The user comes from
- * a server-set header and the bearer token MUST verify against THAT user; the
- * workspace comes from a header too — never from tool args — so the model can
- * neither forge identity nor target another workspace. Fail-closed: any missing
- * credential or a token minted for another user yields a 401/400 Response.
- */
-declare function authenticateToolRequest(request: Request, opts: AuthenticateOptions): Promise<ToolAuthResult>;
-/** Read a tool's argument object from the request body, tolerant of MCP host
- *  aliases (`args` / `arguments`) or a bare body. Returns null on non-JSON. */
-declare function readToolArgs<T>(request: Request): Promise<T | null>;
-
-/** The four canonical app-tool names. Stable identifiers the model calls in
- *  both the sandbox (MCP server name) and runtime (function-tool name) paths. */
-declare const APP_TOOL_NAMES: readonly ["submit_proposal", "schedule_followup", "render_ui", "add_citation"];
-type AppToolName = (typeof APP_TOOL_NAMES)[number];
-declare function isAppToolName(name: string): name is AppToolName;
-/** A minimal OpenAI Chat Completions function-tool shape — structurally
- *  compatible with `@tangle-network/agent-runtime`'s `OpenAIChatTool` without
- *  importing it (keeps this package runtime-free). */
-interface OpenAIFunctionTool {
-    type: 'function';
-    function: {
-        name: string;
-        description: string;
-        parameters: Record<string, unknown>;
-    };
+interface ExpiringCapabilityTokenOptions extends CapabilityTokenOptions {
+    /** Token lifetime. Expired tokens verify false regardless of signature. */
+    expiresInMs: number;
+    /** Clock injection for tests; defaults to Date.now. */
+    now?: () => number;
 }
 /**
- * Build the four app tools in OpenAI function-tool shape. `submit_proposal`'s
- * `type` enum is the product's {@link AppToolTaxonomy.proposalTypes}; the other
- * three are fixed. Pass the result to the agent-runtime backend's `tools`.
+ * Mint an EXPIRING capability token: `<prefix><base64url(payload)>.<sig>` where
+ * the payload carries `{ sub, exp, n }` (subject, epoch-ms expiry, random
+ * nonce) and the signature is HMAC-SHA256 over the encoded payload. Use this
+ * for user-initiated scoped channels (e.g. a per-sequence MCP endpoint) where
+ * a captured token must not stay valid past its window; the bare
+ * {@link createCapabilityToken} remains for turn-scoped tool bridges whose
+ * mint+verify happen inside one request cycle. Fail-closed like the bare
+ * variant: no secret → no token.
  */
-declare function buildAppToolOpenAITools(taxonomy: AppToolTaxonomy): OpenAIFunctionTool[];
+declare function createExpiringCapabilityToken(subject: string, opts: ExpiringCapabilityTokenOptions): Promise<string | undefined>;
+/** Verify an expiring token against `subject`: prefix, payload integrity,
+ *  subject match, and expiry all checked; returns false (never throws) on any
+ *  failure including a malformed payload. */
+declare function verifyExpiringCapabilityToken(subject: string, token: string, opts: CapabilityTokenOptions & {
+    now?: () => number;
+}): Promise<boolean>;
 
 interface DispatchOptions {
     handlers: AppToolHandlers;
@@ -168,54 +134,4 @@ interface HandleToolRequestOptions extends DispatchOptions {
  */
 declare function handleAppToolRequest(request: Request, opts: HandleToolRequestOptions): Promise<Response>;
 
-/** Default route path each app tool is served at. A product mounts its routes
- *  at these paths (or supplies its own via {@link BuildMcpServerOptions.paths}). */
-declare const DEFAULT_APP_TOOL_PATHS: Record<AppToolName, string>;
-/** The portable MCP server entry the sandbox SDK accepts (transport + url +
- *  headers). Matches `AgentProfileMcpServer` structurally without importing the
- *  sandbox SDK — products spread it into their profile's `mcp` map. */
-interface AppToolMcpServer {
-    transport: 'http';
-    url: string;
-    headers: Record<string, string>;
-    enabled: true;
-    metadata: {
-        description: string;
-    };
-}
-interface BuildHttpMcpServerOptions {
-    /** Route path on the app the sandbox POSTs to (e.g. `/api/tools/propose`). */
-    path: string;
-    /** App base URL the sandbox reaches back to (no trailing slash required). */
-    baseUrl: string;
-    /** Per-user capability token, baked into the Authorization header. */
-    token: string;
-    ctx: AppToolContext;
-    /** Tool description the model sees. */
-    description: string;
-    headerNames?: ToolHeaderNames;
-}
-/**
- * Build ONE HTTP MCP server entry — the generic agent→app bridge. The
- * capability token + the user/workspace/thread ids ride in server-set headers
- * (never tool args), so the model can't forge identity or target another
- * workspace. Workspace/thread headers are omitted when their `ctx` value is
- * empty/null (e.g. an integration-invoke bridge that's user-scoped only). Used
- * directly for non-app-tool bridges (integration_invoke) and via
- * {@link buildAppToolMcpServer} for the four app tools.
- */
-declare function buildHttpMcpServer(opts: BuildHttpMcpServerOptions): AppToolMcpServer;
-interface BuildMcpServerOptions {
-    tool: AppToolName;
-    baseUrl: string;
-    token: string;
-    ctx: AppToolContext;
-    description: string;
-    headerNames?: ToolHeaderNames;
-    paths?: Partial<Record<AppToolName, string>>;
-}
-/** Build one of the four app-tool MCP servers — a thin wrapper over
- *  {@link buildHttpMcpServer} that maps the tool name to its route path. */
-declare function buildAppToolMcpServer(opts: BuildMcpServerOptions): AppToolMcpServer;
-
-export { APP_TOOL_NAMES, AppToolContext, AppToolHandlers, type AppToolMcpServer, type AppToolName, AppToolOutcome, AppToolProducedEvent, type AppToolRuntimeExecutor, AppToolTaxonomy, type AuthenticateOptions, type BuildHttpMcpServerOptions, type BuildMcpServerOptions, type CapabilityTokenOptions, DEFAULT_APP_TOOL_PATHS, DEFAULT_HEADER_NAMES, type DispatchOptions, type HandleToolRequestOptions, type OpenAIFunctionTool, type RuntimeExecutorOptions, type ToolAuthResult, type ToolHeaderNames, ToolInputError, authenticateToolRequest, buildAppToolMcpServer, buildAppToolOpenAITools, buildHttpMcpServer, createAppToolRuntimeExecutor, createCapabilityToken, dispatchAppTool, handleAppToolRequest, isAppToolName, outcomeStatus, readToolArgs, verifyCapabilityToken };
+export { AppToolContext, AppToolHandlers, AppToolName, AppToolOutcome, AppToolProducedEvent, type AppToolRuntimeExecutor, AppToolTaxonomy, type CapabilityTokenOptions, type DispatchOptions, type ExpiringCapabilityTokenOptions, type HandleToolRequestOptions, type RuntimeExecutorOptions, ToolHeaderNames, ToolInputError, createAppToolRuntimeExecutor, createCapabilityToken, createExpiringCapabilityToken, dispatchAppTool, handleAppToolRequest, outcomeStatus, verifyCapabilityToken, verifyExpiringCapabilityToken };