@cueframe/kernel 0.1.1 → 0.1.3

package/dist/_members/media-model/generation.d.ts

@@ -0,0 +1,314 @@
+import { z } from "zod";
+export declare const MediaId: z.ZodBranded<z.ZodString, "Id<media>">;
+export type MediaId = z.infer<typeof MediaId>;
+export declare const GenerationId: z.ZodBranded<z.ZodString, "Id<generation>">;
+export type GenerationId = z.infer<typeof GenerationId>;
+export declare const GenerationGroupId: z.ZodBranded<z.ZodString, "Id<generationGroup>">;
+export type GenerationGroupId = z.infer<typeof GenerationGroupId>;
+export declare const ClientRequestId: z.ZodBranded<z.ZodString, "Id<generationRequest>">;
+export type ClientRequestId = z.infer<typeof ClientRequestId>;
+export declare const ProjectHome: z.ZodEnum<["local", "cloud"]>;
+export type ProjectHome = z.infer<typeof ProjectHome>;
+export declare const MediaKind: z.ZodEnum<["image", "video", "audio"]>;
+export type MediaKind = z.infer<typeof MediaKind>;
+export declare const MediaGenerator: z.ZodEnum<["text-to-video", "text-to-image", "image-to-video", "text-to-music", "text-to-speech", "text-to-sfx", "auto"]>;
+export type MediaGenerator = z.infer<typeof MediaGenerator>;
+export declare const GenerationReference: z.ZodObject<{
+    role: z.ZodEnum<["first-frame", "last-frame", "image", "source"]>;
+    mediaId: z.ZodBranded<z.ZodString, "Id<media>">;
+}, "strip", z.ZodTypeAny, {
+    mediaId: string & z.BRAND<"Id<media>">;
+    role: "image" | "source" | "first-frame" | "last-frame";
+}, {
+    mediaId: string;
+    role: "image" | "source" | "first-frame" | "last-frame";
+}>;
+export type GenerationReference = z.infer<typeof GenerationReference>;
+export declare const GenerateMediaCommand: z.ZodObject<{
+    clientRequestId: z.ZodBranded<z.ZodString, "Id<generationRequest>">;
+    generator: z.ZodEnum<["text-to-video", "text-to-image", "image-to-video", "text-to-music", "text-to-speech", "text-to-sfx", "auto"]>;
+    prompt: z.ZodString;
+    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["first-frame", "last-frame", "image", "source"]>;
+        mediaId: z.ZodBranded<z.ZodString, "Id<media>">;
+    }, "strip", z.ZodTypeAny, {
+        mediaId: string & z.BRAND<"Id<media>">;
+        role: "image" | "source" | "first-frame" | "last-frame";
+    }, {
+        mediaId: string;
+        role: "image" | "source" | "first-frame" | "last-frame";
+    }>, "many">>;
+    generationGroupId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id<generationGroup>">>;
+    parentMediaId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id<media>">>;
+    variationNonce: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    clientRequestId: string & z.BRAND<"Id<generationRequest>">;
+    generator: "text-to-speech" | "text-to-image" | "image-to-video" | "text-to-video" | "text-to-music" | "text-to-sfx" | "auto";
+    references: {
+        mediaId: string & z.BRAND<"Id<media>">;
+        role: "image" | "source" | "first-frame" | "last-frame";
+    }[];
+    style?: Record<string, unknown> | undefined;
+    generationGroupId?: (string & z.BRAND<"Id<generationGroup>">) | undefined;
+    parentMediaId?: (string & z.BRAND<"Id<media>">) | undefined;
+    variationNonce?: string | undefined;
+}, {
+    prompt: string;
+    clientRequestId: string;
+    generator: "text-to-speech" | "text-to-image" | "image-to-video" | "text-to-video" | "text-to-music" | "text-to-sfx" | "auto";
+    style?: Record<string, unknown> | undefined;
+    references?: {
+        mediaId: string;
+        role: "image" | "source" | "first-frame" | "last-frame";
+    }[] | undefined;
+    generationGroupId?: string | undefined;
+    parentMediaId?: string | undefined;
+    variationNonce?: string | undefined;
+}>;
+export type GenerateMediaCommand = z.infer<typeof GenerateMediaCommand>;
+export declare const GenerationReceipt: z.ZodObject<{
+    clientRequestId: z.ZodBranded<z.ZodString, "Id<generationRequest>">;
+    generationId: z.ZodBranded<z.ZodString, "Id<generation>">;
+    mediaId: z.ZodBranded<z.ZodString, "Id<media>">;
+    generationGroupId: z.ZodBranded<z.ZodString, "Id<generationGroup>">;
+    version: z.ZodNumber;
+    providerJobId: z.ZodOptional<z.ZodString>;
+    estimateUsd: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    mediaId: string & z.BRAND<"Id<media>">;
+    clientRequestId: string & z.BRAND<"Id<generationRequest>">;
+    generationGroupId: string & z.BRAND<"Id<generationGroup>">;
+    generationId: string & z.BRAND<"Id<generation>">;
+    version: number;
+    providerJobId?: string | undefined;
+    estimateUsd?: number | undefined;
+}, {
+    mediaId: string;
+    clientRequestId: string;
+    generationGroupId: string;
+    generationId: string;
+    version: number;
+    providerJobId?: string | undefined;
+    estimateUsd?: number | undefined;
+}>;
+export type GenerationReceipt = z.infer<typeof GenerationReceipt>;
+export declare const GenerationStatus: z.ZodEnum<["draft", "submitting", "queued", "generating", "provider_complete", "materialising", "processing", "ready", "cancelling", "cancelled", "failed"]>;
+export type GenerationStatus = z.infer<typeof GenerationStatus>;
+export declare const GenerationFailure: z.ZodObject<{
+    code: z.ZodString;
+    title: z.ZodString;
+    recovery: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodBoolean;
+    correlationId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    title: string;
+    retryable: boolean;
+    recovery?: string | undefined;
+    correlationId?: string | undefined;
+}, {
+    code: string;
+    title: string;
+    retryable: boolean;
+    recovery?: string | undefined;
+    correlationId?: string | undefined;
+}>;
+export type GenerationFailure = z.infer<typeof GenerationFailure>;
+export declare const GenerationArtifact: z.ZodObject<{
+    artifactVersion: z.ZodLiteral<1>;
+    clientRequestId: z.ZodBranded<z.ZodString, "Id<generationRequest>">;
+    generationId: z.ZodBranded<z.ZodString, "Id<generation>">;
+    mediaId: z.ZodBranded<z.ZodString, "Id<media>">;
+    generationGroupId: z.ZodBranded<z.ZodString, "Id<generationGroup>">;
+    version: z.ZodNumber;
+    kind: z.ZodEnum<["image", "video", "audio"]>;
+    requestSummary: z.ZodString;
+    status: z.ZodEnum<["draft", "submitting", "queued", "generating", "provider_complete", "materialising", "processing", "ready", "cancelling", "cancelled", "failed"]>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    placementReady: z.ZodDefault<z.ZodBoolean>;
+    parentMediaId: z.ZodOptional<z.ZodBranded<z.ZodString, "Id<media>">>;
+    estimateUsd: z.ZodOptional<z.ZodNumber>;
+    failure: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        title: z.ZodString;
+        recovery: z.ZodOptional<z.ZodString>;
+        retryable: z.ZodBoolean;
+        correlationId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        correlationId?: string | undefined;
+    }, {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        correlationId?: string | undefined;
+    }>>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "video" | "audio" | "image";
+    status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+    mediaId: string & z.BRAND<"Id<media>">;
+    createdAt: number;
+    updatedAt: number;
+    clientRequestId: string & z.BRAND<"Id<generationRequest>">;
+    generationGroupId: string & z.BRAND<"Id<generationGroup>">;
+    generationId: string & z.BRAND<"Id<generation>">;
+    version: number;
+    artifactVersion: 1;
+    requestSummary: string;
+    placementReady: boolean;
+    parentMediaId?: (string & z.BRAND<"Id<media>">) | undefined;
+    estimateUsd?: number | undefined;
+    progress?: number | undefined;
+    failure?: {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        correlationId?: string | undefined;
+    } | undefined;
+}, {
+    kind: "video" | "audio" | "image";
+    status: "generating" | "processing" | "cancelled" | "ready" | "failed" | "draft" | "submitting" | "queued" | "provider_complete" | "materialising" | "cancelling";
+    mediaId: string;
+    createdAt: number;
+    updatedAt: number;
+    clientRequestId: string;
+    generationGroupId: string;
+    generationId: string;
+    version: number;
+    artifactVersion: 1;
+    requestSummary: string;
+    parentMediaId?: string | undefined;
+    estimateUsd?: number | undefined;
+    progress?: number | undefined;
+    placementReady?: boolean | undefined;
+    failure?: {
+        code: string;
+        title: string;
+        retryable: boolean;
+        recovery?: string | undefined;
+        correlationId?: string | undefined;
+    } | undefined;
+}>;
+export type GenerationArtifact = z.infer<typeof GenerationArtifact>;
+export declare const GenerationCapability: z.ZodObject<{
+    generator: z.ZodEnum<["text-to-video", "text-to-image", "image-to-video", "text-to-music", "text-to-speech", "text-to-sfx", "auto"]>;
+    outputKind: z.ZodEnum<["image", "video", "audio"]>;
+    referenceRoles: z.ZodArray<z.ZodEnum<["first-frame", "last-frame", "image", "source"]>, "many">;
+    durationSec: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        min: number;
+        max: number;
+    }, {
+        min: number;
+        max: number;
+    }>>;
+    aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    supportsCancellation: z.ZodBoolean;
+    supportsParallelAttempts: z.ZodBoolean;
+    supportsQuote: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    generator: "text-to-speech" | "text-to-image" | "image-to-video" | "text-to-video" | "text-to-music" | "text-to-sfx" | "auto";
+    outputKind: "video" | "audio" | "image";
+    referenceRoles: ("image" | "source" | "first-frame" | "last-frame")[];
+    supportsCancellation: boolean;
+    supportsParallelAttempts: boolean;
+    supportsQuote: boolean;
+    durationSec?: {
+        min: number;
+        max: number;
+    } | undefined;
+    aspectRatios?: string[] | undefined;
+}, {
+    generator: "text-to-speech" | "text-to-image" | "image-to-video" | "text-to-video" | "text-to-music" | "text-to-sfx" | "auto";
+    outputKind: "video" | "audio" | "image";
+    referenceRoles: ("image" | "source" | "first-frame" | "last-frame")[];
+    supportsCancellation: boolean;
+    supportsParallelAttempts: boolean;
+    supportsQuote: boolean;
+    durationSec?: {
+        min: number;
+        max: number;
+    } | undefined;
+    aspectRatios?: string[] | undefined;
+}>;
+export type GenerationCapability = z.infer<typeof GenerationCapability>;
+export declare const GenerationCapabilities: z.ZodArray<z.ZodObject<{
+    generator: z.ZodEnum<["text-to-video", "text-to-image", "image-to-video", "text-to-music", "text-to-speech", "text-to-sfx", "auto"]>;
+    outputKind: z.ZodEnum<["image", "video", "audio"]>;
+    referenceRoles: z.ZodArray<z.ZodEnum<["first-frame", "last-frame", "image", "source"]>, "many">;
+    durationSec: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        min: number;
+        max: number;
+    }, {
+        min: number;
+        max: number;
+    }>>;
+    aspectRatios: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    supportsCancellation: z.ZodBoolean;
+    supportsParallelAttempts: z.ZodBoolean;
+    supportsQuote: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    generator: "text-to-speech" | "text-to-image" | "image-to-video" | "text-to-video" | "text-to-music" | "text-to-sfx" | "auto";
+    outputKind: "video" | "audio" | "image";
+    referenceRoles: ("image" | "source" | "first-frame" | "last-frame")[];
+    supportsCancellation: boolean;
+    supportsParallelAttempts: boolean;
+    supportsQuote: boolean;
+    durationSec?: {
+        min: number;
+        max: number;
+    } | undefined;
+    aspectRatios?: string[] | undefined;
+}, {
+    generator: "text-to-speech" | "text-to-image" | "image-to-video" | "text-to-video" | "text-to-music" | "text-to-sfx" | "auto";
+    outputKind: "video" | "audio" | "image";
+    referenceRoles: ("image" | "source" | "first-frame" | "last-frame")[];
+    supportsCancellation: boolean;
+    supportsParallelAttempts: boolean;
+    supportsQuote: boolean;
+    durationSec?: {
+        min: number;
+        max: number;
+    } | undefined;
+    aspectRatios?: string[] | undefined;
+}>, "many">;
+export type GenerationCapabilities = z.infer<typeof GenerationCapabilities>;
+export interface GenerationStateSources {
+    attempt: {
+        status: Exclude<GenerationStatus, "materialising" | "processing" | "ready">;
+        progress?: number;
+        failure?: GenerationFailure;
+    };
+    resource: {
+        kind: MediaKind;
+        durable: boolean;
+        decodable: boolean;
+        metadataReady: boolean;
+        placementReady: boolean;
+    };
+    materialisation: {
+        required: boolean;
+        status: "not_started" | "pending_source" | "downloading" | "complete" | "failed";
+        verifiedBytes: boolean;
+        failure?: GenerationFailure;
+    };
+}
+export declare function deriveGenerationStatus(sources: GenerationStateSources): {
+    status: GenerationStatus;
+    placementReady: boolean;
+    failure?: GenerationFailure;
+};

package/dist/_members/media-model/index.d.ts

@@ -1 +1,2 @@
 export * from "./api.js";
+export * from "./generation.js";

package/dist/_members/media-model/media-kind.d.ts

@@ -1,36 +1,9 @@
-/** `opaque` is `asset` renamed (spec §5): "asset" was the word that made two
- *  different concepts — storage furniture and a media classification — look
- *  like one. `opaque` states the contract: no pipeline, not placeable. */
 export type MediaKind = "video" | "audio" | "image" | "opaque";
 export declare const IMAGE_CONTENT_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
-/** Closed allowlist — the complete set of accepted content-types (the acceptance
- *  gate). mediaKind() routes each: video/audio/still-image do real work;
- *  fonts/json/svg/gif route to the opaque path. Unknown bytes (not here)
- *  are rejected at the edge. */
 export declare const ALLOWED_CONTENT_TYPES: readonly ["video/mp4", "video/quicktime", "video/x-matroska", "video/webm", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/aac", "image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml", "application/json", "font/ttf", "font/otf", "font/woff", "font/woff2"];
 export type AllowedContentType = (typeof ALLOWED_CONTENT_TYPES)[number];
 export declare function mediaKind(contentType: string): MediaKind;
 export declare function extensionForContentType(contentType: string): string;
-/** What a file IS, from nothing but its name — the ONE derivation the import
- *  door, the project-file parse gate, and migration 020's SQL all mirror. */
 export declare function mediaKindForFilename(filename: string): MediaKind;
-/** Every extension whose derived kind can occupy time. The import door's
- *  accept-list IS this list — derived, so the door and the authority cannot
- *  disagree (the disagreement was a thrown import for `.jpeg`/`.m4a`). */
 export declare const POOL_EXTENSIONS: readonly string[];
-/**
- * The content-type to UPLOAD a file as, given what the platform claimed and
- * what the file is called.
- *
- * WHY THIS EXISTS. The upload client used to send `file.type || "video/mp4"`.
- * Both halves are wrong: the alias case rejects real MP3s (see above), and the
- * fallback silently relabels ANY untyped file as video — so an MP3 dragged in
- * without a MIME is accepted and then routed down the VIDEO transcode path by
- * `mediaKind()`, which is a wrong pipeline rather than an honest refusal.
- *
- * Order: an already-allowed type wins, then a known alias, then the extension.
- * If none of those resolve, the ORIGINAL string is returned unchanged — never a
- * guess. The closed gate then refuses it and names the type the user actually
- * has, which is the error message they need.
- */
 export declare function contentTypeForUpload(filename: string, claimed?: string | null): string;

package/dist/_members/media-model/transcriptSearch.d.ts

@@ -1,54 +1,12 @@
-/**
- * WHAT COUNTS AS A SPOKEN-WORD HIT, AND WHAT IT IS WORTH.
- *
- * This rule is implemented TWICE and has to be — the desktop searches its local
- * `transcript_segments` table in Rust (`src-tauri/src/database/transcripts.rs`),
- * and the web searches the utterances in an R2 blob in TypeScript. Neither can
- * call the other: one is a SQL `LIKE` chain inside a Tauri command, the other
- * runs in a browser against a JSON object it just downloaded.
- *
- * SO THE RULE IS DATA, AND BOTH LANES RUN THE SAME DATA. `cases.json` beside
- * this file is the shared table: each row is a query, some spoken lines, and
- * the hits they must produce, in order. This module is the TypeScript runner;
- * `contract_transcript_search_cases` in `database/mod.rs` is the Rust one,
- * reading the same file. A rule change that lands in one lane and not the other
- * fails the table on the side that was missed.
- *
- * WHY A TABLE AND NOT A PARAMETERISED SUITE: this is a pure, stateless
- * operation — inputs in, ranking out, no store to set up — which is exactly the
- * case CLAUDE.md's decision table assigns to fixtures-as-data. A suite is for
- * stateful CRUD behind one interface.
- *
- * WHY THE SCORES MATTER RATHER THAN JUST THE ORDER: `desktopScope`'s library
- * search puts spoken hits above visual ones and says in its own comment that a
- * transcript score and a CLIP cosine are different units that must not be
- * merged by value. That reasoning only holds if a transcript score means one
- * fixed thing, so two lanes scoring the same line differently would quietly
- * make the ordering arbitrary.
- */
-/** One spoken line, as either lane holds it. */
 export interface SpokenLine {
     text: string;
     start: number;
     end: number;
 }
-/** One line that matched, with what it is worth. */
 export interface TranscriptHit extends SpokenLine {
-    /** Term coverage, 0–1. NOT comparable to a CLIP cosine. */
     score: number;
 }
-/**
- * A line containing the whole query as a PHRASE is a stronger answer than one
- * that happens to contain the same words apart. Both outrank nothing.
- */
 export declare const PHRASE_SCORE = 1;
 export declare const SCATTERED_SCORE = 0.6;
-/** The query, lowercased and split. Empty query = no terms = no hits. */
 export declare function searchTerms(query: string): string[];
-/**
- * Rank the lines that match every term.
- *
- * `limit` is applied LAST, after ranking, so the strongest hits survive a small
- * limit rather than whichever happened to be spoken first.
- */
 export declare function rankTranscriptHits(query: string, lines: readonly SpokenLine[], limit?: number): TranscriptHit[];

package/dist/_members/nle-export/fcpxml.d.ts

@@ -1,15 +1,2 @@
 import type { ClipExportInput } from "./types.js";
-/**
- * Generate FCPXML v1.11. Compatible with Final Cut Pro 11 and DaVinci Resolve 19.
- *
- * Multi-clip, multi-asset composition:
- * - One <format> per unique (w, h, fpsNum, fpsDen) across assets + sequence.
- * - One <asset> per assets[] entry.
- * - One <asset-clip> per spine[] item (offset/duration in sequence rate; start in source rate).
- * - Markers with spineItemId render inside the matching <asset-clip>, start
- *   relativized to the clip's timelineStartFrames.
- * - Markers without spineItemId render at spine root, start in sequence-absolute rate.
- * - Text overlays overlapping a spine item render as markers inside that clip
- *   (value = overlay.text). Overlays outside all clips are dropped.
- */
 export declare function generateFcpxml(input: ClipExportInput): string;

package/dist/_members/nle-export/index.d.ts

@@ -1,9 +1,3 @@
-/**
- * Root subpath — zero-dep, edge-runtime-safe. Types + pure-TS logic only.
- *
- * XML generators (which depend on xmlbuilder2) live at `@cueframe/nle-export/xml`.
- * Node-only packaging (archiver) lives at `@cueframe/nle-export/server`.
- */
 export { generateSrt } from "./srt.js";
 export { compositionToClipExportInput } from "./composition-to-input.js";
 export { compactTimeline } from "./compact-timeline.js";

package/dist/_members/nle-export/types.d.ts

@@ -1,6 +1,5 @@
 export type ExportFormat = "videoClip" | "fcpxml" | "premiere";
 export type MarkerKind = "hook" | "editorial" | "overlay" | "scene" | "custom";
-/** One entry per unique (sourceId, originInFrames, originOutFrames) triple. */
 export type ClipExportAsset = {
     id: string;
     relPath: string;
@@ -58,48 +57,23 @@ export type ClipExportInput = {
     textOverlays: ExportTextOverlay[];
     audioTracks: ExportAudioTrack[];
 };
-/**
- * Trim-activity output. One entry per unique (sourceId, inFrame, outFrame)
- * triple across all clips in a composition.
- */
 export type TrimmedRef = {
     sourceId: string;
-    /**
-     * Integer source-frame count for the clip's requested in-point. Matching
-     * key — compositionToClipExportInput resolves a clip to its ref by exact
-     * (sourceId, inFramesAtSourceRate, outFramesAtSourceRate) equality.
-     */
     inFramesAtSourceRate: number;
     outFramesAtSourceRate: number;
     r2Key: string;
     ptsStartSec: number;
     durationSec: number;
-    /** ffprobe-reported rational rate of the trimmed file. */
     sourceFpsNum: number;
     sourceFpsDen: number;
-    /**
-     * Decimal frame rate used by the trim activity to derive
-     * inFramesAtSourceRate/outFramesAtSourceRate from seconds. Preserved so
-     * the converter's round-trip uses the same formula (avoids NTSC drift
-     * when mediaItem.frameRate is decimal 29.97 but ffprobe reports rational
-     * 30000/1001).
-     */
     mediaItemFps: number;
     handleBeforeSec: number;
     handleAfterSec: number;
-    /** Human-recognizable source name (mediaItem.name). Passed through so
-     * NLE bins show "Interview A.mov" instead of a Convex id. */
     displayName: string;
     cacheHit: boolean;
 };
 export type TimelineClip = {
     id: string;
-    /**
-     * Original clip id before compactTimeline split this segment out of a
-     * bigger clip. Unset on clips that weren't split. Consumers that need
-     * to attach per-original-clip data (e.g. scene labels) should prefer
-     * this over string-parsing `id`.
-     */
     originalClipId?: string;
     poolItemId: string;
     sourceIn: number;

package/dist/_members/nle-export/xml/index.d.ts

@@ -1,10 +1,2 @@
-/**
- * NLE XML generators. Pulls `xmlbuilder2` which uses Node's Buffer, so this
- * subpath only loads cleanly in Node or full browser bundles — NOT in edge
- * runtimes (Convex V8 isolate, Cloudflare Workers without node-compat).
- *
- * Convex + edge-runtime consumers should import types + converter + srt from
- * the package root, which is xmlbuilder2-free.
- */
 export { generateFcpxml } from "../fcpxml.js";
 export { generatePremiereXml } from "../premiere.js";

package/dist/_members/nle-export/xml-utils.d.ts

@@ -1,21 +1,9 @@
 export interface FrameRateInfo {
-    /** Integer display rate (24 for 23.976, 30 for 29.97, 60 for 59.94). */
     displayRate: number;
-    /** True when fps is a classical NTSC rate (N * 1000/1001). */
     isNtsc: boolean;
-    /** FCPXML-style frame duration attribute (e.g. `1/30s` or `1001/30000s`). */
     frameDuration: string;
 }
-/**
- * Classify a frame rate. Handles integer fps and NTSC fractional rates
- * (23.976, 29.97, 59.94) which use rational time values with 1001 numerator.
- */
 export declare function getFrameRateInfo(fps: number): FrameRateInfo;
-/**
- * Convert seconds to an FCPXML rational time string.
- * For NTSC rates, emits `frames*1001 / displayRate*1000 s` so timing stays exact.
- */
 export declare function toRationalTime(seconds: number, fps: number): string;
-/** Convert seconds to an integer frame count (display frames). */
 export declare function toFrames(seconds: number, fps: number): number;
 export declare function slugify(s: string): string;

package/dist/_members/perception/activeSpeaker.d.ts

@@ -1,108 +1,14 @@
-/**
- * @cueframe/perception — `activeSpeaker` signal provider (per-angle AV active-
- * speaker FACT).
- *
- * A DECISION-FREE measurement (perception is a leaf — it produces a FACT, never a
- * choice): per-angle audio-visual active-speaker detection (TalkNet-style ASD,
- * arxiv:2107.06592) → a per-window speaking probability for THAT angle's dominant
- * tracked face, calibrated to an ABSOLUTE [0,1] scalar so the Selector core can
- * compare "who is talking" across angles (selector-abstraction spec §1.2, the
- * `activeSpeaker` signal; §9.1 P3, switch on who's-talking).
- *
- * Perception NEVER imports the Selector core (the rot-guard direction): this module
- * emits a plain `{ value, rawScore, confidence, evidence }` envelope that STRUCTURALLY
- * matches `@cueframe/core`'s `Signal`, but the type lives here (a leaf owns its own
- * fact shape; the core projects it). Adding/upgrading the model = a version stamp
- * here; the core is untouched.
- *
- * This module is the PURE FACT CONTRACT (perception is a leaf — NO node I/O here,
- * so it stays importable by every framework leaf):
- *  - `activeSpeakerSignal(series, sourceInSec, sourceOutSec)` — PURE: windows the
- *    per-frame ASD probabilities (over the angle's OWN source timeline) and maps the
- *    windowed speaking probability to the absolute [0,1] value + reasons.
- *
- * The MEASUREMENT (the TalkNet/Light-ASD model that PRODUCES an `ActiveSpeakerSeries`)
- * lives OUTSIDE the leaf — the real perception build is the Modal skill
- * (the backend services_router/skills/detect_active_speaker.py). It is PER-ANGLE:
- * one angle's audio + that angle's tracked dominant face → that angle's speaking
- * probability over time. This REPLACES the within-source Light-ASD (broken on 2+
- * faces) — each angle's track is conditioned on its own audio, never the mixed
- * podcast track (spec §10 — "Cannot be Deepgram-word-gated per-angle"). Both the
- * Modal skill and any local harness feed this one calibration.
- *
- * LANDMINE (spec §scope-1): vocal activity ≠ SPEECH. Laughing, chewing, coughing,
- * a hot reaction mic all raise audio energy and can fool a naive VAD — but a proper
- * AV-ASD model (TalkNet) keys on lip-motion↔audio SYNC, so a chewing/laughing
- * reaction shot (mouth moves, but not in speech-sync, or audio is non-speech)
- * scores LOW. The calibration here trusts the AV model's probability; it does NOT
- * re-derive "is talking" from audio energy alone (that would cut to the chewer).
- * `audioEnergy` (the hot-mic VAD) is a SEPARATE, weaker signal — never conflate the
- * two. The resolver test asserts a high-audio-energy / low-activeSpeaker fixture
- * does NOT trigger a cut.
- *
- * Pure + deterministic.
- */
-/** Bump when the ASD-probability→value calibration changes (the 3-stamp lesson — a
- *  stale cached activeSpeaker is served if a consumer doesn't bump alongside). The
- *  Modal model version is a DISTINCT stamp carried on the series (`modelVersion`). */
 export declare const ACTIVE_SPEAKER_VERSION = "active-speaker-v1-2026.06.21";
-/**
- * The raw per-angle ASD measurement — what the Modal `detect_active_speaker` skill
- * (and any local harness) produces for ONE angle. A per-frame speaking probability
- * over the angle's OWN source timeline for that angle's dominant tracked face.
- *
- * Source-independent absolutes (each value is a probability in [0,1] from the AV
- * model), never normalized across angles (the cross-source comparison is the
- * Selector's job — `switchMargin`/weights, never the signal).
- */
 export interface ActiveSpeakerSeries {
-    /** The Modal ASD model + weights version (e.g. the Light-ASD/TalkNet checkpoint).
-     *  DISTINCT from `ACTIVE_SPEAKER_VERSION` (the calibration stamp). */
     modelVersion: string;
-    /** Frames-per-second of `probs` (the model's visual rate — Light-ASD = 25). */
     fps: number;
-    /** Source-second at which `probs[0]` starts (the angle's window start). */
     windowStartSec: number;
-    /** Per-frame speaking probability ∈ [0,1] for the angle's dominant tracked face.
-     *  A frame where the model had NO face crop (the dominant face left the frame)
-     *  is `null` — NOT 0 (absence ≠ silence; a no-face frame must not dilute the mean
-     *  toward "not speaking"). */
     probs: Array<number | null>;
 }
-/** Matches `@cueframe/core`'s `Signal` shape STRUCTURALLY (perception owns its
- *  fact; the core projects `value`/`confidence`). `null` (not 0) when the angle has
- *  NO measurable face/audio over the window — absence, never "definitely silent". */
 export interface ActiveSpeakerSignal {
-    /** ABSOLUTE, calibrated ∈ [0,1] — "is this angle's subject speaking right now,"
-     *  source-independent. The talking angle scores highest. */
     value: number;
-    /** Pre-calibration raw (the mean windowed ASD probability) for legibility. */
     rawScore: number;
     confidence: number;
-    /** Reasons-only ("speaking 0.91, 18/20 frames faced"); excluded from any hash. */
     evidence: string;
 }
-/**
- * Window the per-frame ASD probabilities over `[sourceInSec, sourceOutSec)` (the
- * angle's OWN source span — the resolver has already mapped the output grid through
- * the angle's declared offset) and map them to the absolute [0,1] activeSpeaker
- * value (PURE).
- *
- * Returns `null` — NOT 0 — when the window has no measurable signal:
- *  - the angle has no ASD series at all (no detected face → no track to score), OR
- *  - every frame in the window is `null` (the dominant face was absent the whole
- *    window).
- * `null` is "not measured" (absence); a weight over an all-null activeSpeaker is
- * fail-loud upstream (`selector_signal_absent`), never silently 0
- * (`feedback_never_add_fallbacks`). A measured-but-quiet angle returns a real low
- * value (e.g. 0.05) — that IS a measurement and DOES suppress a cut.
- *
- * Calibration (absolute, NOT softmax-across-angles): the AV model's per-frame
- * probability is already an absolute speaking likelihood, so the value is the
- * face-present mean over the window. The TalkNet/Light-ASD model keys on lip↔audio
- * SYNC, so a laughing/chewing reaction (mouth moving, non-speech audio) already
- * scores low at the model — this calibration trusts that and does NOT re-inflate
- * from audio energy (the landmine). Confidence scales with face COVERAGE over the
- * window (a face present 2/20 frames is a weak vote).
- */
 export declare function activeSpeakerSignal(series: ActiveSpeakerSeries | undefined, sourceInSec: number, sourceOutSec: number): ActiveSpeakerSignal | null;