@tangle-network/agent-app 0.43.56 → 0.43.58

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

@@ -1 +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":[]}
+{"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\n/** Provide the default Whisper model identifier for ONNX community large v3 turbo */\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\n/** Define the structure for transcribed text output with optional segmented chunks */\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\n/** Create a Whisper-based transcription provider with optional model configuration */\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/{sso-CNOsARMJ.d.ts → sso-Cm00S61u.d.ts}

@@ -5,12 +5,14 @@
  * Session resolution is a seam; thrown Responses follow the router convention
  * of surfacing a thrown Response as the route result.
  */
+/** Define options for configuring authentication guard behavior and session retrieval */
 interface AuthGuardOptions<Session> {
     /** e.g. a better-auth `auth.api.getSession` wrapped by the app. */
     getSession(request: Request): Promise<Session | null | undefined>;
     /** Default '/login'. */
     loginPath?: string;
 }
+/** Resolve user authentication and session requirements for page and API requests */
 interface AuthGuard<Session> {
     /** Page guard — throws a 302 redirect Response to `loginPath`. */
     requireUser(request: Request): Promise<Session>;
@@ -22,7 +24,9 @@ interface AuthGuard<Session> {
     }): Promise<Session>;
     getOptionalSession(request: Request): Promise<Session | null>;
 }
+/** Create an authentication guard that enforces session presence and handles unauthorized access responses */
 declare function createAuthGuard<Session>(opts: AuthGuardOptions<Session>): AuthGuard<Session>;
+/** Resolve a value or an HTTP response indicating failure in a guarded operation */
 type GuardResolution<T> = {
     ok: true;
     value: T;
@@ -40,6 +44,7 @@ type GuardResolution<T> = {
 declare function guardResolution<T>(run: () => Promise<T>): Promise<GuardResolution<T>>;
 /** Comma/whitespace separated → trimmed, lowercased, empties dropped. */
 declare function parseAdminEmails(raw: string | null | undefined): string[];
+/** Define options to resolve user session and control access based on allowed admin emails */
 interface AdminGuardOptions<Session> {
     requireUser(request: Request): Promise<Session>;
     emailOf(session: Session): string | null | undefined;
@@ -49,10 +54,12 @@ interface AdminGuardOptions<Session> {
 /** Non-admins (and empty allowlists) get 404, keeping the route invisible —
  *  better than a "forbidden" footprint that advertises its existence. */
 declare function createAdminGuard<Session>(opts: AdminGuardOptions<Session>): (request: Request) => Promise<Session>;
+/** Describe the billable balance state including overage permission and remaining USD balance */
 interface BillableBalanceState {
     overageAllowed: boolean;
     remainingBalanceUsd: number;
 }
+/** Define options to assert and customize billable balance enforcement behavior */
 interface AssertBillableBalanceOptions {
     env?: Record<string, string | undefined>;
     /** App-specific enforcement override flag (e.g. 'GTM_BILLING_ENFORCEMENT'),
@@ -79,6 +86,7 @@ declare function assertBillableBalance(state: BillableBalanceState, opts?: Asser
  * never imports agent-runtime, an auth framework, or a database driver.
  * WebCrypto only — runs in workerd without node compatibility flags.
  */
+/** Define configuration options for managing SSO state including secret, lifetime, and clock injection */
 interface SsoStateConfig {
     /** HMAC-SHA256 secret (e.g. the app's auth secret). */
     secret: string;
@@ -92,6 +100,7 @@ interface SsoStateConfig {
 declare function createSignedSsoState(config: SsoStateConfig): Promise<string>;
 /** Verify the MAC (constant-time) and the signed TTL. */
 declare function verifySignedSsoState(state: string, config: SsoStateConfig): Promise<boolean>;
+/** Describe the result of exchanging SSO credentials including API key, user info, and optional plan details */
 interface TangleSsoExchangeResult {
     apiKey: string;
     user: {
@@ -201,6 +210,7 @@ interface BetterAuthSessionCookieSource {
         };
     }>;
 }
+/** Define options to customize warning behavior for shadowed cookie names in authentication sessions */
 interface BetterAuthSessionCookieMinterOptions {
     /** Receives the shadowed-cookie-name warning (see below). Default
      *  console.warn. */
@@ -227,6 +237,7 @@ interface BetterAuthSessionCookieMinterOptions {
  * `Domain=`-wide session cookie is exactly the shadowing footgun.
  */
 declare function createBetterAuthSessionCookieMinter(auth: BetterAuthSessionCookieSource, options?: BetterAuthSessionCookieMinterOptions): (args: TangleSsoSessionCookieArgs) => Promise<string[]>;
+/** Define configuration options for handling Tangle SSO authentication and session management */
 interface TangleSsoHandlerOptions {
     auth: TangleSsoAuthClient;
     store: TangleSsoAccountStore;
@@ -269,6 +280,7 @@ interface TangleSsoHandlerOptions {
     log?: (message: string, error?: unknown) => void;
     now?: () => number;
 }
+/** Define handlers for SSO start and callback routes managing authentication flow and session cookies */
 interface TangleSsoHandlers {
     /** GET start route: mint + sign state, set the state cookie, 302 to the
      *  platform authorize URL. `?redirect=` carries the post-login path. */
@@ -280,6 +292,7 @@ interface TangleSsoHandlers {
      *  302s to `loginPath?error=…` with the state cookie cleared. */
     callback(request: Request): Promise<Response>;
 }
+/** Create Tangle SSO handlers to manage authentication state, callbacks, and session cookies */
 declare function createTangleSsoHandlers(opts: TangleSsoHandlerOptions): TangleSsoHandlers;
 
 export { type AuthGuard as A, type BetterAuthSessionCookieMinterOptions as B, type GuardResolution as G, type SsoStateConfig as S, type TangleSsoHandlers as T, type TangleSsoAuthClient as a, type TangleSsoAccountStore as b, type AdminGuardOptions as c, type AssertBillableBalanceOptions as d, type AuthGuardOptions as e, type BetterAuthSessionCookieSource as f, type BillableBalanceState as g, type TangleSsoExchangeResult as h, type TangleSsoHandlerOptions as i, type TangleSsoSessionCookieArgs as j, TangleSsoUserCreateError as k, assertBillableBalance as l, createAdminGuard as m, createAuthGuard as n, createBetterAuthSessionCookieMinter as o, createSignedSsoState as p, createTangleSsoHandlers as q, guardResolution as r, parseAdminEmails as s, signSessionCookieValue as t, verifySignedSsoState as v };

package/dist/{stale-turn-lock-C8Na1cFZ.d.ts → stale-turn-lock-DucQzvXu.d.ts}

@@ -95,6 +95,7 @@ declare const DEFAULT_STALE_TURN_LOCK_GRACE_MS: number;
  * crashed turn; lowering it narrows the registration window it protects.
  */
 declare const DEFAULT_TERMINAL_TURN_LOCK_GRACE_MS: number;
+/** Resolve options for probing and releasing stale TURN locks based on lock start time and sandbox state */
 interface ReconcileStaleTurnLockOptions {
     /** When the held lock was acquired (epoch ms). The grace period is measured
      *  from here, so it must be the LOCK's start, not the turn's. */
@@ -132,6 +133,7 @@ interface ReconcileStaleTurnLockOptions {
     /** Injectable clock, for tests. */
     now?(): number;
 }
+/** Describe the outcome of reconciling a stale turn lock including release status and diagnostics */
 interface ReconcileStaleTurnLockResult {
     released: boolean;
     /** Why the policy decided what it did — the probe's own diagnostics on the

package/dist/store/index.d.ts

@@ -26,6 +26,7 @@ interface DatabaseProvider<DB> {
     /** Clear the injected database (next access throws again). Mainly for tests. */
     reset(): void;
 }
+/** Define options for configuring database provider behavior including error messaging */
 interface DatabaseProviderOptions {
     /** Error thrown when `db` is accessed before injection. Keep the product's
      *  existing wording so callers see a familiar message. */
@@ -37,6 +38,7 @@ interface DatabaseProviderOptions {
  * typing and their existing query syntax.
  */
 declare function createDatabaseProvider<DB extends object>(options?: DatabaseProviderOptions): DatabaseProvider<DB>;
+/** Describe the result of listing keys with completion status and optional pagination cursor */
 interface KVListResult {
     keys: {
         name: string;
@@ -44,15 +46,18 @@ interface KVListResult {
     list_complete: boolean;
     cursor?: string;
 }
+/** Define options for storing a key-value pair with expiration and metadata settings */
 interface KVPutOptions {
     expiration?: number;
     expirationTtl?: number;
     metadata?: unknown;
 }
+/** Resolve a key-value pair retrieval including its associated metadata and value */
 interface KVGetWithMetadataResult {
     value: string | null;
     metadata: unknown | null;
 }
+/** Define a key-value store interface for asynchronous data retrieval, storage, deletion, and listing */
 interface KVStore {
     get(key: string): Promise<string | null>;
     /** Read a value with its stored metadata (e.g. the vault's encrypted/hasPII flags). */

package/dist/store/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/store/index.ts"],"sourcesContent":["/**\n * Swappable database provider — the seam that decouples the agent's persistence\n * from any one driver.\n *\n * The agent core (and the app's server modules) import a single `db` and use it\n * directly. That `db` is a lazy proxy: it forwards to whatever database instance\n * the runtime injects via {@link DatabaseProvider.setDatabase}. So the SAME core\n * runs on:\n *   - Cloudflare D1            (`setDatabase(drizzle(d1, schema))`)        — prod\n *   - SQLite / miniflare       (`setDatabase(drizzle(betterSqlite, schema))`) — eval / the portable inner shell\n *   - libsql / Turso, Postgres (`setDatabase(drizzle(client, schema))`)    — a future hosted DB\n *\n * Adding a new database is one adapter (a drizzle instance over a new driver) +\n * a `setDatabase` call. None of the modules importing `db` change. Substrate-\n * free and driver-agnostic: this module knows nothing about D1, drizzle, or any\n * schema — it only forwards property access to the injected instance.\n */\n\nexport interface DatabaseProvider<DB> {\n  /** The injected database, as a lazy proxy. Throws (with `notReadyMessage`)\n   *  on any access before {@link setDatabase} is called. */\n  readonly db: DB\n  /** Inject the active database instance (any driver's client). */\n  setDatabase(database: DB): void\n  /** True once a database has been injected. */\n  isReady(): boolean\n  /** Clear the injected database (next access throws again). Mainly for tests. */\n  reset(): void\n}\n\nexport interface DatabaseProviderOptions {\n  /** Error thrown when `db` is accessed before injection. Keep the product's\n   *  existing wording so callers see a familiar message. */\n  notReadyMessage?: string\n}\n\n/**\n * Create a swappable database provider. `DB` is the injected instance's type\n * (e.g. a drizzle `Database`); the proxy is typed as `DB` so callers keep full\n * typing and their existing query syntax.\n */\nexport function createDatabaseProvider<DB extends object>(\n  options: DatabaseProviderOptions = {},\n): DatabaseProvider<DB> {\n  const message = options.notReadyMessage ?? 'Database not initialized — call setDatabase() first.'\n  let current: DB | null = null\n\n  const db = new Proxy({} as DB, {\n    get(_target, prop) {\n      if (!current) throw new Error(message)\n      const value = (current as Record<string | symbol, unknown>)[prop]\n      // Bind methods to the real instance so `this` resolves correctly through\n      // the proxy (works for drizzle's query builders and class-based stores).\n      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(current) : value\n    },\n    has(_target, prop) {\n      return current !== null && prop in (current as object)\n    },\n  })\n\n  return {\n    db,\n    setDatabase(database: DB) {\n      current = database\n    },\n    isReady() {\n      return current !== null\n    },\n    reset() {\n      current = null\n    },\n  }\n}\n\n// ── KV store port (the vault backend) ───────────────────────────────────────\n//\n// The vault (workspace files) is a key/value store. In production it's a\n// Cloudflare `KVNamespace`; the portable inner shell injects an in-memory (or\n// other) implementation. This is the subset of the KV API the vault uses —\n// `KVNamespace` satisfies it structurally, so prod passes the binding unchanged,\n// and `createInMemoryKV()` supplies the portable adapter for sandbox/eval.\n\nexport interface KVListResult {\n  keys: { name: string }[]\n  list_complete: boolean\n  cursor?: string\n}\n\nexport interface KVPutOptions {\n  expiration?: number\n  expirationTtl?: number\n  metadata?: unknown\n}\n\nexport interface KVGetWithMetadataResult {\n  value: string | null\n  metadata: unknown | null\n}\n\nexport interface KVStore {\n  get(key: string): Promise<string | null>\n  /** Read a value with its stored metadata (e.g. the vault's encrypted/hasPII flags). */\n  getWithMetadata(key: string): Promise<KVGetWithMetadataResult>\n  put(key: string, value: string, options?: KVPutOptions): Promise<void>\n  delete(key: string): Promise<void>\n  list(options?: { prefix?: string; cursor?: string; limit?: number }): Promise<KVListResult>\n}\n\n/**\n * In-memory {@link KVStore} — the portable vault backend for sandbox/eval runs.\n * Backed by a Map; `list` returns all prefix-matched keys in one complete page\n * (no real pagination needed in-process). Seed with `initial` entries if useful.\n */\nexport function createInMemoryKV(initial?: Record<string, string>): KVStore {\n  const store = new Map<string, { value: string; metadata: unknown }>(\n    initial ? Object.entries(initial).map(([k, v]) => [k, { value: v, metadata: null }]) : [],\n  )\n  return {\n    async get(key) {\n      return store.get(key)?.value ?? null\n    },\n    async getWithMetadata(key) {\n      const entry = store.get(key)\n      return { value: entry?.value ?? null, metadata: entry?.metadata ?? null }\n    },\n    async put(key, value, options) {\n      store.set(key, { value, metadata: options?.metadata ?? null })\n    },\n    async delete(key) {\n      store.delete(key)\n    },\n    async list(options) {\n      const prefix = options?.prefix ?? ''\n      const keys = [...store.keys()]\n        .filter((k) => k.startsWith(prefix))\n        .sort()\n        .map((name) => ({ name }))\n      return { keys, list_complete: true }\n    },\n  }\n}\n"],"mappings":";AAyCO,SAAS,uBACd,UAAmC,CAAC,GACd;AACtB,QAAM,UAAU,QAAQ,mBAAmB;AAC3C,MAAI,UAAqB;AAEzB,QAAM,KAAK,IAAI,MAAM,CAAC,GAAS;AAAA,IAC7B,IAAI,SAAS,MAAM;AACjB,UAAI,CAAC,QAAS,OAAM,IAAI,MAAM,OAAO;AACrC,YAAM,QAAS,QAA6C,IAAI;AAGhE,aAAO,OAAO,UAAU,aAAc,MAA0C,KAAK,OAAO,IAAI;AAAA,IAClG;AAAA,IACA,IAAI,SAAS,MAAM;AACjB,aAAO,YAAY,QAAQ,QAAS;AAAA,IACtC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,YAAY,UAAc;AACxB,gBAAU;AAAA,IACZ;AAAA,IACA,UAAU;AACR,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,QAAQ;AACN,gBAAU;AAAA,IACZ;AAAA,EACF;AACF;AAyCO,SAAS,iBAAiB,SAA2C;AAC1E,QAAM,QAAQ,IAAI;AAAA,IAChB,UAAU,OAAO,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,KAAK,CAAC,CAAC,IAAI,CAAC;AAAA,EAC1F;AACA,SAAO;AAAA,IACL,MAAM,IAAI,KAAK;AACb,aAAO,MAAM,IAAI,GAAG,GAAG,SAAS;AAAA,IAClC;AAAA,IACA,MAAM,gBAAgB,KAAK;AACzB,YAAM,QAAQ,MAAM,IAAI,GAAG;AAC3B,aAAO,EAAE,OAAO,OAAO,SAAS,MAAM,UAAU,OAAO,YAAY,KAAK;AAAA,IAC1E;AAAA,IACA,MAAM,IAAI,KAAK,OAAO,SAAS;AAC7B,YAAM,IAAI,KAAK,EAAE,OAAO,UAAU,SAAS,YAAY,KAAK,CAAC;AAAA,IAC/D;AAAA,IACA,MAAM,OAAO,KAAK;AAChB,YAAM,OAAO,GAAG;AAAA,IAClB;AAAA,IACA,MAAM,KAAK,SAAS;AAClB,YAAM,SAAS,SAAS,UAAU;AAClC,YAAM,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC,EAC1B,OAAO,CAAC,MAAM,EAAE,WAAW,MAAM,CAAC,EAClC,KAAK,EACL,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE;AAC3B,aAAO,EAAE,MAAM,eAAe,KAAK;AAAA,IACrC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/store/index.ts"],"sourcesContent":["/**\n * Swappable database provider — the seam that decouples the agent's persistence\n * from any one driver.\n *\n * The agent core (and the app's server modules) import a single `db` and use it\n * directly. That `db` is a lazy proxy: it forwards to whatever database instance\n * the runtime injects via {@link DatabaseProvider.setDatabase}. So the SAME core\n * runs on:\n *   - Cloudflare D1            (`setDatabase(drizzle(d1, schema))`)        — prod\n *   - SQLite / miniflare       (`setDatabase(drizzle(betterSqlite, schema))`) — eval / the portable inner shell\n *   - libsql / Turso, Postgres (`setDatabase(drizzle(client, schema))`)    — a future hosted DB\n *\n * Adding a new database is one adapter (a drizzle instance over a new driver) +\n * a `setDatabase` call. None of the modules importing `db` change. Substrate-\n * free and driver-agnostic: this module knows nothing about D1, drizzle, or any\n * schema — it only forwards property access to the injected instance.\n */\n\nexport interface DatabaseProvider<DB> {\n  /** The injected database, as a lazy proxy. Throws (with `notReadyMessage`)\n   *  on any access before {@link setDatabase} is called. */\n  readonly db: DB\n  /** Inject the active database instance (any driver's client). */\n  setDatabase(database: DB): void\n  /** True once a database has been injected. */\n  isReady(): boolean\n  /** Clear the injected database (next access throws again). Mainly for tests. */\n  reset(): void\n}\n\n/** Define options for configuring database provider behavior including error messaging */\nexport interface DatabaseProviderOptions {\n  /** Error thrown when `db` is accessed before injection. Keep the product's\n   *  existing wording so callers see a familiar message. */\n  notReadyMessage?: string\n}\n\n/**\n * Create a swappable database provider. `DB` is the injected instance's type\n * (e.g. a drizzle `Database`); the proxy is typed as `DB` so callers keep full\n * typing and their existing query syntax.\n */\nexport function createDatabaseProvider<DB extends object>(\n  options: DatabaseProviderOptions = {},\n): DatabaseProvider<DB> {\n  const message = options.notReadyMessage ?? 'Database not initialized — call setDatabase() first.'\n  let current: DB | null = null\n\n  const db = new Proxy({} as DB, {\n    get(_target, prop) {\n      if (!current) throw new Error(message)\n      const value = (current as Record<string | symbol, unknown>)[prop]\n      // Bind methods to the real instance so `this` resolves correctly through\n      // the proxy (works for drizzle's query builders and class-based stores).\n      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(current) : value\n    },\n    has(_target, prop) {\n      return current !== null && prop in (current as object)\n    },\n  })\n\n  return {\n    db,\n    setDatabase(database: DB) {\n      current = database\n    },\n    isReady() {\n      return current !== null\n    },\n    reset() {\n      current = null\n    },\n  }\n}\n\n// ── KV store port (the vault backend) ───────────────────────────────────────\n//\n// The vault (workspace files) is a key/value store. In production it's a\n// Cloudflare `KVNamespace`; the portable inner shell injects an in-memory (or\n// other) implementation. This is the subset of the KV API the vault uses —\n// `KVNamespace` satisfies it structurally, so prod passes the binding unchanged,\n// and `createInMemoryKV()` supplies the portable adapter for sandbox/eval.\n\n/** Describe the result of listing keys with completion status and optional pagination cursor */\nexport interface KVListResult {\n  keys: { name: string }[]\n  list_complete: boolean\n  cursor?: string\n}\n\n/** Define options for storing a key-value pair with expiration and metadata settings */\nexport interface KVPutOptions {\n  expiration?: number\n  expirationTtl?: number\n  metadata?: unknown\n}\n\n/** Resolve a key-value pair retrieval including its associated metadata and value */\nexport interface KVGetWithMetadataResult {\n  value: string | null\n  metadata: unknown | null\n}\n\n/** Define a key-value store interface for asynchronous data retrieval, storage, deletion, and listing */\nexport interface KVStore {\n  get(key: string): Promise<string | null>\n  /** Read a value with its stored metadata (e.g. the vault's encrypted/hasPII flags). */\n  getWithMetadata(key: string): Promise<KVGetWithMetadataResult>\n  put(key: string, value: string, options?: KVPutOptions): Promise<void>\n  delete(key: string): Promise<void>\n  list(options?: { prefix?: string; cursor?: string; limit?: number }): Promise<KVListResult>\n}\n\n/**\n * In-memory {@link KVStore} — the portable vault backend for sandbox/eval runs.\n * Backed by a Map; `list` returns all prefix-matched keys in one complete page\n * (no real pagination needed in-process). Seed with `initial` entries if useful.\n */\nexport function createInMemoryKV(initial?: Record<string, string>): KVStore {\n  const store = new Map<string, { value: string; metadata: unknown }>(\n    initial ? Object.entries(initial).map(([k, v]) => [k, { value: v, metadata: null }]) : [],\n  )\n  return {\n    async get(key) {\n      return store.get(key)?.value ?? null\n    },\n    async getWithMetadata(key) {\n      const entry = store.get(key)\n      return { value: entry?.value ?? null, metadata: entry?.metadata ?? null }\n    },\n    async put(key, value, options) {\n      store.set(key, { value, metadata: options?.metadata ?? null })\n    },\n    async delete(key) {\n      store.delete(key)\n    },\n    async list(options) {\n      const prefix = options?.prefix ?? ''\n      const keys = [...store.keys()]\n        .filter((k) => k.startsWith(prefix))\n        .sort()\n        .map((name) => ({ name }))\n      return { keys, list_complete: true }\n    },\n  }\n}\n"],"mappings":";AA0CO,SAAS,uBACd,UAAmC,CAAC,GACd;AACtB,QAAM,UAAU,QAAQ,mBAAmB;AAC3C,MAAI,UAAqB;AAEzB,QAAM,KAAK,IAAI,MAAM,CAAC,GAAS;AAAA,IAC7B,IAAI,SAAS,MAAM;AACjB,UAAI,CAAC,QAAS,OAAM,IAAI,MAAM,OAAO;AACrC,YAAM,QAAS,QAA6C,IAAI;AAGhE,aAAO,OAAO,UAAU,aAAc,MAA0C,KAAK,OAAO,IAAI;AAAA,IAClG;AAAA,IACA,IAAI,SAAS,MAAM;AACjB,aAAO,YAAY,QAAQ,QAAS;AAAA,IACtC;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA,YAAY,UAAc;AACxB,gBAAU;AAAA,IACZ;AAAA,IACA,UAAU;AACR,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,QAAQ;AACN,gBAAU;AAAA,IACZ;AAAA,EACF;AACF;AA6CO,SAAS,iBAAiB,SAA2C;AAC1E,QAAM,QAAQ,IAAI;AAAA,IAChB,UAAU,OAAO,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,KAAK,CAAC,CAAC,IAAI,CAAC;AAAA,EAC1F;AACA,SAAO;AAAA,IACL,MAAM,IAAI,KAAK;AACb,aAAO,MAAM,IAAI,GAAG,GAAG,SAAS;AAAA,IAClC;AAAA,IACA,MAAM,gBAAgB,KAAK;AACzB,YAAM,QAAQ,MAAM,IAAI,GAAG;AAC3B,aAAO,EAAE,OAAO,OAAO,SAAS,MAAM,UAAU,OAAO,YAAY,KAAK;AAAA,IAC1E;AAAA,IACA,MAAM,IAAI,KAAK,OAAO,SAAS;AAC7B,YAAM,IAAI,KAAK,EAAE,OAAO,UAAU,SAAS,YAAY,KAAK,CAAC;AAAA,IAC/D;AAAA,IACA,MAAM,OAAO,KAAK;AAChB,YAAM,OAAO,GAAG;AAAA,IAClB;AAAA,IACA,MAAM,KAAK,SAAS;AAClB,YAAM,SAAS,SAAS,UAAU;AAClC,YAAM,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC,EAC1B,OAAO,CAAC,MAAM,EAAE,WAAW,MAAM,CAAC,EAClC,KAAK,EACL,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE;AAC3B,aAAO,EAAE,MAAM,eAAe,KAAK;AAAA,IACrC;AAAA,EACF;AACF;","names":[]}

package/dist/{store-gckrNq-g.d.ts → store-B7LLlk9p.d.ts}

@@ -15,10 +15,15 @@ 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';
+/** Define sequence status as one of the specific lifecycle stages draft, active, exporting, or archived */
 type SequenceStatus = 'draft' | 'active' | 'exporting' | 'archived';
+/** Define export formats available for sequence data including video, subtitle, and metadata types */
 type SequenceExportFormat = 'mp4' | 'otio' | 'xml' | 'edl' | 'vtt' | 'srt' | 'contact_sheet';
+/** Represent export status of a sequence as queued, processing, completed, failed, or cancelled */
 type SequenceExportStatus = 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
+/** Define media types allowed in a sequence including video, image, and audio */
 type SequenceMediaKind = 'video' | 'image' | 'audio';
+/** Describe metadata and properties of a media sequence including dimensions, duration, and status */
 interface SequenceMeta {
     id: string;
     title: string;
@@ -30,6 +35,7 @@ interface SequenceMeta {
     status: SequenceStatus;
     metadata: Record<string, unknown>;
 }
+/** Define properties and state for a sequence track including id, kind, name, order, and flags */
 interface SequenceTrack {
     id: string;
     kind: SequenceTrackKind;
@@ -50,6 +56,7 @@ interface SequenceClipMedia {
     /** Provider job state for media still rendering upstream. */
     providerStatus?: 'queued' | 'processing' | 'completed' | 'failed';
 }
+/** Define properties for a media sequence clip including timing, source, track, and caption details */
 interface SequenceClip {
     id: string;
     trackId: string;
@@ -85,6 +92,7 @@ interface SequenceDecision {
     metadata: Record<string, unknown>;
     createdAt: Date;
 }
+/** Describe a record representing the export details and status of a sequence */
 interface SequenceExportRecord {
     id: string;
     format: SequenceExportFormat;
@@ -117,29 +125,37 @@ interface SequenceFrameSnapshot {
         clipId: string;
     }>;
 }
+/** Convert seconds to the nearest whole number of frames based on frames per second */
 declare function secondsToFrames(seconds: number, fps: number): number;
+/** Convert a frame count to seconds based on the given frames per second rate */
 declare function framesToSeconds(frames: number, fps: number): number;
+/** Format a number of seconds into a string with integer or two-decimal precision suffix s */
 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;
+/** Define the start frame and duration in frames for a timeline clip's bounds */
 interface TimelineClipBounds {
     startFrame: number;
     durationFrames: number;
 }
+/** Define a time range with inclusive start and end frame numbers */
 interface TimelineInterval {
     startFrame: number;
     endFrame: number;
 }
+/** Clamp the clip start frame within the valid range of the sequence duration and clip length */
 declare function clampClipStart(input: {
     startFrame: number;
     durationFrames: number;
     sequenceDurationFrames: number;
 }): number;
+/** Clamp clip duration to fit within sequence bounds and minimum length constraints */
 declare function clampClipDuration(input: {
     startFrame: number;
     durationFrames: number;
     sequenceDurationFrames: number;
 }): number;
+/** Validate that a clip's start and duration fit within the sequence duration without overflow */
 declare function assertClipFitsSequence(input: {
     startFrame: number;
     durationFrames: number;
@@ -177,11 +193,13 @@ declare function trackIntervals(timeline: SequenceTimeline, trackId: string): Ti
  * driven by the UI can batch their own decision entries.
  */
 
+/** Define properties for a new sequence track including kind, name, and optional sort order */
 interface NewSequenceTrack {
     kind: SequenceTrackKind;
     name: string;
     sortOrder?: number;
 }
+/** Define properties for a new sequence clip including timing, labels, and optional metadata */
 interface NewSequenceClip {
     trackId: string;
     label: string;
@@ -195,6 +213,7 @@ interface NewSequenceClip {
     assetId?: string;
     metadata?: Record<string, unknown>;
 }
+/** Define optional properties to update or patch a sequence clip's attributes in a timeline */
 interface SequenceClipPatch {
     trackId?: string;
     label?: string;
@@ -207,6 +226,7 @@ interface SequenceClipPatch {
     language?: string;
     metadata?: Record<string, unknown>;
 }
+/** Define the structure for a new sequence decision with optional metadata and acceptance status */
 interface NewSequenceDecision {
     clipId?: string | null;
     kind: SequenceDecision['kind'];
@@ -215,6 +235,7 @@ interface NewSequenceDecision {
     accepted?: boolean | null;
     metadata?: Record<string, unknown>;
 }
+/** Manage sequences by providing methods to get timelines, clips, and modify tracks and clips */
 interface SequenceStore {
     /** Full aggregate: sequence meta + tracks + clips with resolved media. */
     getTimeline(): Promise<SequenceTimeline>;
@@ -239,4 +260,4 @@ interface SequenceStoreScope {
     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 };
+export { snapshotFrame as A, trackIntervals as B, MIN_SEQUENCE_CLIP_FRAMES as M, type NewSequenceClip as N, type SequenceStoreScope as S, type TimelineClipBounds as T, type SequenceClipMedia as a, type SequenceStore as b, type SequenceTrackKind as c, type SequenceExportFormat as d, type SequenceTrack as e, type SequenceTimeline as f, type SequenceClip as g, type SequenceExportRecord as h, type SequenceMeta as i, type SequenceMediaKind as j, type TimelineInterval as k, type NewSequenceDecision as l, type NewSequenceTrack as m, type SequenceClipPatch as n, type SequenceDecision as o, type SequenceExportStatus as p, type SequenceFrameSnapshot as q, type SequenceStatus 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/{store-CFyxgTlD.d.ts → store-CqfDtnPQ.d.ts}

@@ -1,4 +1,4 @@
-import { c as SceneDocument } from './model-BBwyOuWG.js';
+import { c as SceneDocument } from './model-DnfO_PdJ.js';
 
 /**
  * Storage contract for design-canvas documents. Unlike sequences (row per
@@ -14,11 +14,13 @@ import { c as SceneDocument } from './model-BBwyOuWG.js';
  * structured tool errors.
  */
 
+/** Represent a scene document with its current revision number for version tracking */
 interface SceneDocumentRecord {
     document: SceneDocument;
     /** Monotonic revision; increments on every successful save. */
     rev: number;
 }
+/** Define the structure for decisions made within a scene including type, instructions, and metadata */
 interface SceneDecision {
     id: string;
     kind: 'human_edit' | 'agent_edit' | 'agent_proposal' | 'export' | 'note';
@@ -27,13 +29,16 @@ interface SceneDecision {
     metadata: Record<string, unknown>;
     createdAt: Date;
 }
+/** Define the structure for decisions related to creating a new scene with instructions and optional details */
 interface NewSceneDecision {
     kind: SceneDecision['kind'];
     instruction: string;
     reasoningSummary?: string | null;
     metadata?: Record<string, unknown>;
 }
+/** Define supported formats for exporting a scene including image and JSON options */
 type SceneExportFormat = 'png' | 'jpeg' | 'json';
+/** Describe a scene export with its status, format, metadata, and result information */
 interface SceneExportRecord {
     id: string;
     format: SceneExportFormat;
@@ -42,6 +47,7 @@ interface SceneExportRecord {
     metadata: Record<string, unknown>;
     createdAt: Date;
 }
+/** Manage scene documents, decisions, and exports with atomic save and revision control */
 interface SceneStore {
     /** Current document + revision. */
     getDocument(): Promise<SceneDocumentRecord>;
@@ -61,4 +67,4 @@ interface SceneStoreScope {
     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 };
+export type { NewSceneDecision as N, SceneStoreScope as S, SceneStore as a, SceneDocumentRecord as b, SceneDecision as c, SceneExportFormat as d, SceneExportRecord as e };

package/dist/stream/index.d.ts

@@ -1,24 +1,30 @@
-import { J as JsonRecord } from '../stream-normalizer-DWvtmY6F.js';
-export { M as MISSING_TOOL_TERMINAL_ERROR, a as MISSING_TOOL_TERMINAL_REASON, S as StreamEvent, b as asRecord, c as asString, d as attachmentPartKey, e as collapseRedundantTextParts, f as encodeEvent, g as finalizeAssistantParts, h as finalizePendingInteractionParts, i as getPartKey, m as mergePersistedPart, n as normalizePersistedPart, j as normalizeTime, k as normalizeToolEvent, r as resolveToolId, l as resolveToolName, t as terminalizeDanglingAssistantToolUpdates, o as terminalizeDanglingToolPart, p as terminalizeDanglingToolParts } from '../stream-normalizer-DWvtmY6F.js';
-export { B as BufferedTurnEvent, a as BufferedTurnOptions, b as BufferedTurnTap, D as D1LikeForTurns, P as PumpBufferedTurnOptions, R as ReplayTurnEventsOptions, T as TURN_EVENTS_MIGRATION_SQL, c as TURN_STATUS_SCOPE_MIGRATION_SQL, d as TurnEventStore, e as TurnStatus, f as coalesceChatStreamEvents, g as coalesceDeltas, h as createBufferedTurnTap, i as createD1TurnEventStore, j as createMemoryTurnEventStore, p as pumpBufferedTurn, r as replayTurnEvents } from '../turn-buffer-C9mEgoop.js';
-import '../contract-KfqJh_au.js';
+import { J as JsonRecord } from '../stream-normalizer-C3M--r6y.js';
+export { M as MISSING_TOOL_TERMINAL_ERROR, a as MISSING_TOOL_TERMINAL_REASON, S as StreamEvent, b as asRecord, c as asString, d as attachmentPartKey, e as collapseRedundantTextParts, f as encodeEvent, g as finalizeAssistantParts, h as finalizePendingInteractionParts, i as getPartKey, m as mergePersistedPart, n as normalizePersistedPart, j as normalizeTime, k as normalizeToolEvent, r as resolveToolId, l as resolveToolName, t as terminalizeDanglingAssistantToolUpdates, o as terminalizeDanglingToolPart, p as terminalizeDanglingToolParts } from '../stream-normalizer-C3M--r6y.js';
+export { B as BufferedTurnEvent, a as BufferedTurnOptions, b as BufferedTurnTap, D as D1LikeForTurns, P as PumpBufferedTurnOptions, R as ReplayTurnEventsOptions, T as TURN_EVENTS_MIGRATION_SQL, c as TURN_STATUS_SCOPE_MIGRATION_SQL, d as TurnEventStore, e as TurnStatus, f as coalesceChatStreamEvents, g as coalesceDeltas, h as createBufferedTurnTap, i as createD1TurnEventStore, j as createMemoryTurnEventStore, p as pumpBufferedTurn, r as replayTurnEvents } from '../turn-buffer-DGnAPKwa.js';
+import '../contract-TjB68uqA.js';
 import '@tangle-network/agent-interface';
 
+/** Define the structure of a chat message stored for a specific conversation turn */
 interface PersistedChatMessageForTurn {
     id: string;
     role: 'user' | 'assistant' | 'system' | 'tool';
     content: string;
     parts: Array<Record<string, unknown>> | null;
 }
+/** Represent a chat turn with resolved user message insertion and prior message context */
 interface ResolvedChatTurn {
     turnIndex: number;
     shouldInsertUserMessage: boolean;
     priorMessages: PersistedChatMessageForTurn[];
     userParts: JsonRecord[];
 }
+/** Normalize and validate a client turn ID string ensuring it meets format and length requirements */
 declare function normalizeClientTurnId(value: unknown): string | undefined;
+/** Build an array of text parts with optional turn ID for user input */
 declare function buildUserTextParts(text: string, turnId: string | undefined): JsonRecord[];
+/** Resolve whether a message contains any part with the specified turn ID */
 declare function messageHasTurnId(message: PersistedChatMessageForTurn, turnId: string): boolean;
+/** Resolve a chat turn by determining message reuse and constructing user message parts */
 declare function resolveChatTurn(input: {
     existingMessages: PersistedChatMessageForTurn[];
     userContent: string;

package/dist/stream/index.js

@@ -12,7 +12,7 @@ import {
   pumpBufferedTurn,
   replayTurnEvents,
   resolveChatTurn
-} from "../chunk-23LUHHHN.js";
+} from "../chunk-VCOD5AOR.js";
 import {
   MISSING_TOOL_TERMINAL_ERROR,
   MISSING_TOOL_TERMINAL_REASON,
@@ -33,9 +33,9 @@ import {
   terminalizeDanglingAssistantToolUpdates,
   terminalizeDanglingToolPart,
   terminalizeDanglingToolParts
-} from "../chunk-5MG74GVQ.js";
-import "../chunk-XAWFPMAR.js";
-import "../chunk-SIXYZ2FB.js";
+} from "../chunk-IG46XCZM.js";
+import "../chunk-YKOM4ZLQ.js";
+import "../chunk-YJMCRXQQ.js";
 export {
   MISSING_TOOL_TERMINAL_ERROR,
   MISSING_TOOL_TERMINAL_REASON,

package/dist/{stream-normalizer-DWvtmY6F.d.ts → stream-normalizer-C3M--r6y.d.ts}

@@ -1,30 +1,44 @@
-import { b as ChatInteractionStatus } from './contract-KfqJh_au.js';
+import { b as ChatInteractionStatus } from './contract-TjB68uqA.js';
 
+/** Represent a JSON-compatible object with string keys and values of any type */
 type JsonRecord = Record<string, unknown>;
+/** Define an event object carrying a type and optional JSON data payload */
 interface StreamEvent {
     type: string;
     data?: JsonRecord;
 }
+/** Resolve an unknown value to a JsonRecord if it is a non-array object or return undefined */
 declare function asRecord(value: unknown): JsonRecord | undefined;
+/** Resolve a non-empty string from a value or return undefined */
 declare function asString(value: unknown): string | undefined;
+/** Resolve a unique tool identifier from various possible properties or generate a fallback ID */
 declare function resolveToolId(part: JsonRecord): string;
+/** Resolve the tool name from a JSON record using tool, name, or a default value */
 declare function resolveToolName(part: JsonRecord): string;
+/** Resolve time properties from various keys into a normalized record with numeric start and end fields */
 declare function normalizeTime(value: unknown): JsonRecord | undefined;
+/** Normalize tool-related events into a standardized message.part.updated format */
 declare function normalizeToolEvent(event: StreamEvent): StreamEvent;
+/** Normalize a persisted part object by standardizing its structure and fields */
 declare function normalizePersistedPart(rawPart: JsonRecord): JsonRecord | null;
 /** Stream/transcript part key for a promoted (path-bearing) attachment,
  *  keyed on its storage path — re-emitting the same path folds into the same
  *  segment instead of duplicating it. */
 declare function attachmentPartKey(path: string): string;
+/** Resolve a unique key string for a part based on its type and identifying properties */
 declare function getPartKey(part: JsonRecord): string;
+/** Merge incoming JSON with existing persisted data, applying delta for text types when provided */
 declare function mergePersistedPart(existing: JsonRecord | undefined, incoming: JsonRecord, delta?: string): JsonRecord;
+/** Resolve errors when a tool fails to report a terminal result before the assistant turn ends */
 declare const MISSING_TOOL_TERMINAL_ERROR = "Tool did not report a terminal result before the assistant turn completed.";
+/** Provide the reason identifier for a missing tool in the terminal environment */
 declare const MISSING_TOOL_TERMINAL_REASON = "missing-tool-terminal";
 /** Closes a tool part left `running` when a stream ended abnormally: settles
  *  it as a terminal `error` and stamps `state.metadata.terminalized` so the
  *  synthetic settlement is distinguishable from a real tool failure. Parts
  *  that already settled (and non-tool parts) pass through untouched. */
 declare function terminalizeDanglingToolPart(part: JsonRecord): JsonRecord;
+/** Resolve dangling tool parts into terminal forms within the given JSON records array */
 declare function terminalizeDanglingToolParts(parts: JsonRecord[]): JsonRecord[];
 /** Settles still-pending interaction parts at persist time. The broker
  *  guarantees a resolved question either answered (run unblocked, no cancel
@@ -38,11 +52,13 @@ declare function finalizePendingInteractionParts(parts: JsonRecord[], outcome: E
  *  segments survive as blank parts. Consecutive identical text parts merge
  *  into one; empty text parts drop when any non-empty text part exists. */
 declare function collapseRedundantTextParts(parts: JsonRecord[]): JsonRecord[];
+/** Resolve and clean up assistant parts by terminalizing and collapsing redundant segments */
 declare function finalizeAssistantParts(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
 /** Finalizes, then folds each synthetic tool settlement back into `partMap`
  *  and returns just those updates — the shape a streaming loop needs to emit
  *  closing `message.part.updated` frames for tools the stream never settled. */
 declare function terminalizeDanglingAssistantToolUpdates(partOrder: string[], partMap: Map<string, JsonRecord>, finalText: string): JsonRecord[];
+/** Encode a StreamEvent object into a Uint8Array using the provided TextEncoder */
 declare function encodeEvent(encoder: TextEncoder, event: StreamEvent): Uint8Array;
 
 export { type JsonRecord as J, MISSING_TOOL_TERMINAL_ERROR as M, type StreamEvent as S, MISSING_TOOL_TERMINAL_REASON as a, asRecord as b, asString as c, attachmentPartKey as d, collapseRedundantTextParts as e, encodeEvent as f, finalizeAssistantParts as g, finalizePendingInteractionParts as h, getPartKey as i, normalizeTime as j, normalizeToolEvent as k, resolveToolName as l, mergePersistedPart as m, normalizePersistedPart as n, terminalizeDanglingToolPart as o, terminalizeDanglingToolParts as p, resolveToolId as r, terminalizeDanglingAssistantToolUpdates as t };