@cueframe/kernel 0.1.1 → 0.1.2

package/dist/_members/mcp/x402Meta.d.ts

@@ -1,50 +1,6 @@
-/**
- * x402-over-MCP wire constants + helpers, VENDORED from the first-party
- * `@x402/mcp` package and pinned to it by `x402Meta.conformance.test.ts`.
- *
- * Why vendored instead of `import … from "@x402/mcp"`: the published `@x402/mcp`
- * dist is a single bundle that imports `@x402/core/client` + `/server`
- * (viem/Buffer) at MODULE scope, so importing even a constant drags Buffer into
- * the Convex V8 isolate — the exact failure `x402Facilitator.ts` is `"use node"`
- * to avoid. This module is plain-JSON + `btoa` only, so it is V8-safe and runs in
- * both the hosted (V8 isolate) and stdio (Node) transports. Same generator/runtime
- * split as `x402Discovery` (a Node test tracks the spec; the runtime reads plain
- * data). The conformance test fails if these drift from `@x402/mcp`.
- *
- * The convention (Cloudflare/Coinbase/Vercel + `@x402/mcp`): over MCP, payment
- * rides in the JSON-RPC `_meta` field, NOT an HTTP header — MCP is transport-
- * agnostic (stdio has no HTTP layer). The `PaymentPayload` / `PaymentRequired`
- * objects are byte-identical to CueFrame's REST v2 envelope; only the carrier
- * differs (`_meta` key vs `PAYMENT-SIGNATURE`/`Payment-Required` header).
- */
-/** Client → server: the signed EIP-3009 `PaymentPayload`, on the tools/call `_meta`. */
 export declare const MCP_PAYMENT_META_KEY = "x402/payment";
-/** JSON-RPC error code a paid tool returns when called unpaid. */
 export declare const MCP_PAYMENT_REQUIRED_CODE = 402;
-/** Loose `_meta` bag as seen on a tools/call request (SDK `extra._meta`). */
 export type RequestMeta = Record<string, unknown> | undefined;
-/**
- * True iff a parsed body is a canonical x402 `PaymentRequired` challenge (has a
- * numeric `x402Version` and an `accepts` array) — matching the @x402/mcp client's
- * `isPaymentRequiredStructure`. Used to tell the REAL 402 payment challenge apart
- * from the OTHER errors that share HTTP 402 (billing_required,
- * generation_budget_exceeded, payment_invalid, …), which must surface as typed
- * errors, not an x402 "sign a payment" prompt.
- */
 export declare function isX402PaymentRequired(body: unknown): body is Record<string, unknown>;
-/**
- * Read the client's signed payment (a `PaymentPayload` object) off a tools/call
- * `_meta`. Returns the raw object or null; the STRUCTURE is validated downstream
- * by the facilitator's EIP-3009 decode (single source of truth), so this is a
- * presence/shape gate only — never trust it as verified payment.
- */
 export declare function extractPaymentFromMeta(meta: RequestMeta): Record<string, unknown> | null;
-/**
- * Encode a `PaymentPayload` object into the base64 `PAYMENT-SIGNATURE` header
- * value the REST x402 middleware decodes (`@x402/core` `encodePaymentSignatureHeader`
- * = `safeBase64Encode(JSON.stringify(payload))`). `btoa`-based → V8-safe; mirrors
- * `@x402/core`'s own `safeBase64Encode` (which is also btoa-first). This lets an
- * MCP tool call forward its `_meta` payment INTO the unchanged REST verify/settle
- * path via the inner `app.fetch`, reusing all money-safety.
- */
 export declare function encodePaymentSignature(payload: unknown): string;

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;