@cueframe/kernel 0.1.1 → 0.1.2

package/dist/_members/composition-ops/materializeGrid.d.ts

@@ -1,54 +1,26 @@
 import type { Marker } from '../composition/validators/index.js';
-/** The three grid kinds a clip's source media can carry. */
 export type GridKind = 'beat' | 'word' | 'shot';
-/** The author-fixable failure classes, matching the error-registry codes. */
 export type GridErrorCode = 'grid_unavailable' | 'shot_grid_unavailable' | 'grid_cap_exceeded' | 'grid_target_invalid';
-/**
- * Fail-loud carrier for the materializeGrid guards. `code` is a registered
- * ErrorCode the op route re-throws as an `ApiError` (422) or folds into a
- * `dry_run` verdict. `opIndex` is stamped by the route (it knows the batch
- * position); the pure mapper leaves it undefined.
- */
 export declare class GridError extends Error {
     readonly code: GridErrorCode;
     opIndex?: number | undefined;
     constructor(code: GridErrorCode, message: string, opIndex?: number | undefined);
 }
-/** Default marker cap (soft — a caller may raise it up to the hard ceiling). */
 export declare const GRID_DEFAULT_MAX_MARKERS = 500;
-/** Hard ceiling on markers materialized from one grid (never exceeded). */
 export declare const GRID_HARD_MAX_MARKERS = 2000;
-/** The subset of a media clip's placement the projection reads. */
 export interface GridPlacement {
-    /** Timeline seconds where the clip starts. */
     startTime: number;
-    /** Timeline seconds the clip occupies. */
     duration: number;
-    /** Source-seconds trim window; absent = whole source from 0. */
     trim?: {
         start: number;
         end: number;
     };
-    /** Source→timeline speed; absent = 1. */
     playbackRate?: number;
-    /** Source-seconds spans excluded (sorted, non-overlapping). */
     excludedRanges?: Array<{
         start: number;
         end: number;
     }>;
 }
-/**
- * Project media-time grid points (ms, in the source's own time) onto the
- * timeline through `placement`, minting one marker per VISIBLE point. Points
- * outside the clip's visible window (before/after the trim, or inside an
- * excluded range) are SKIPPED. Markers are named deterministically
- * (`<grid>-<n>`, id `grid-<grid>-<clipId>-<n>`, `n` = the running visible index)
- * so a re-run reproduces the exact set; `metadata.sourceClipId` records the
- * origin clip so the route can replace a prior materialization idempotently.
- *
- * Fails loud (`grid_cap_exceeded`) when the visible count exceeds `maxMarkers`
- * (default 500) — no silent truncation.
- */
 export declare function materializeGridMarkers(placement: GridPlacement, gridPointsMs: readonly number[], opts: {
     grid: GridKind;
     clipId: string;

package/dist/_members/composition-ops/opRecorder.d.ts

@@ -1,24 +1,5 @@
-/**
- * wrapWithOpRecorder — THE mutation→op mapping, extracted from
- * recordingStore so it has exactly one home and two consumers:
- *
- *   - `createRecordingStore` (compose bench/eval): wraps the headless store.
- *   - the EDITOR's compositionOps delegate (apps/studio/src/store): wraps the
- *     zustand-backed op surface, so every user gesture records the same wire
- *     op an agent would send — the P0.5 "editor writes are ops" seam.
- *
- * The wrapper intercepts every mutation of the shared op surface: records
- * the corresponding {@link CompositionOp} (with the BEFORE composition, for
- * invertOp), then applies to `base` (optimistic local fold, unchanged UX). Replay contracts (id pinning, track
- * pre-emit, the family-stamp on addClip, the playbackRate refusal) are the
- * SAME rules recordingStore always enforced — see the per-method comments.
- */
 import type { Composition, TimelineClip, Marker, Track, Format, ReframeSegment, CaptionSegment, CaptionStyle, PerClipEffect } from '../composition/validators/index.js';
 import type { CompositionOp } from './index.js';
-/** The mutation surface the recorder knows how to map (the shared op set). No
- *  count here on purpose: it went stale ("31") the moment ops were consolidated,
- *  and the authoritative pairing is enforced by GUARD 1
- *  (`opFactoryVocabulary.test.ts`), not by a number in a comment. */
 export interface RecordableOps {
     addClip(clip: TimelineClip, options?: {
         newTrack?: boolean;
@@ -55,23 +36,8 @@ export interface RecordableOps {
     removeExcludedRange(clipId: string, rangeIdx: number): void;
 }
 export interface OpRecorderOpts {
-    /**
-     * Called for every recorded op with the composition AS OF BEFORE the op
-     * applied — consumers that need inverses compute `invertOp(before, op)`
-     * without replaying history. Ops are recorded BEFORE the base mutation
-     * runs (every mapping derives from args + before-state only), so `before`
-     * is simply the current composition at call time.
-     */
     record: (op: CompositionOp, before: Composition) => void;
-    /** Current composition — pre-emit checks + the `before` snapshot read it. */
     getComposition: () => Composition;
-    /**
-     * A mutation the op vocabulary cannot serialize (today: setClipProperties
-     * with playbackRate — a cross-field ripple). When provided, the mutation
-     * APPLIES locally and this fires instead of an op (the editor journals a
-     * guarded snapshot barrier). When absent, the wrapper THROWS — the compose
-     * bench's op-log must stay byte-faithfully replayable.
-     */
     onUnjournalable?: (reason: string) => void;
 }
 export declare function wrapWithOpRecorder<T extends RecordableOps>(base: T, opts: OpRecorderOpts): T;

package/dist/_members/composition-ops/recordingStore.d.ts

@@ -1,23 +1,7 @@
-/**
- * createRecordingStore — the op-recording seam over the HEADLESS store.
- *
- * The mutation→op mapping itself lives in {@link wrapWithOpRecorder}
- * (opRecorder.ts) — ONE mapping shared with the editor's compositionOps
- * delegate (P0.5: editor writes are ops). This module only binds it to
- * `createHeadlessStore` and exposes the accumulated log.
- *
- * The recorded op-log replays byte-faithfully:
- * `ops.reduce(applyOp, seed)` reproduces `getState().composition` exactly —
- * the wrapper PINS ids the store would otherwise mint (addClip newTrackId,
- * overlay/audio track pre-emit, addTrack id). Selection ops pass through
- * unrecorded (UI state, not in the op vocabulary). `duplicateClip` replays
- * render-equivalent, not byte-identical (non-pinned minted id).
- */
 import type { Composition } from '../composition/validators/index.js';
 import { type HeadlessStore, type CompositionOpsState } from '../composition/ops/index.js';
 import type { CompositionOp } from './index.js';
 export interface RecordingStore extends HeadlessStore {
-    /** The faithful op-log of every mutation, in order. */
     getOps(): CompositionOp[];
 }
 export declare function createRecordingStore(initial?: Composition | CompositionOpsState): RecordingStore;

package/dist/_members/composition-ops/replaceRegion.d.ts

@@ -1,65 +1,17 @@
-/**
- * `replaceRegion` — the NON-RIPPLING cut/overlay lowering (selector-abstraction
- * spec §6.2). The genuinely-new timeline primitive the switch instance needs:
- * neither existing authoring mode fits a same-track temporal cut —
- *   - `add_clip mode:"layer"` makes a FRESH track (b-roll over A-roll), and
- *   - `add_clip mode:"ripple-insert"` SHIFTS downstream content.
- * A multicam switch is an OVERWRITE: A→B→C occupy the SAME region of the SAME
- * track, back to back, with nothing rippling.
- *
- * PLACEMENT: this lives in `@cueframe/composition-ops` (NOT framework-bound; it
- * already depends on `@cueframe/composition` + `@cueframe/core`). It does NOT
- * import the Selector core — it consumes a plain `CutSchedule` (the resolver's
- * lowered advisory), so the source-only concepts (`programAudioSourceId`, cut vs
- * overlay, source-window placement) live HERE, never in the core.
- *
- * Two kinds (spec §6.2):
- *  - `kind:"cut"` (synced angles): video follows the chosen source; AUDIO FOLLOWS
- *    the video UNLESS `programAudioSourceId` is set, in which case audio is pinned
- *    to one continuous bed on a separate audio track while video cuts (topology-i).
- *  - `kind:"overlay"` (b-roll cutaway): video-over on a NEW overlay/video track,
- *    primary audio continues (this defers to the existing layer semantics; the
- *    presence-gate authored its windows). The switch instance authors `cut`.
- *
- * Validates fail-loud: the authored segments tile the region without overlap/gap
- * (the `Gap.strict()` lesson) and every source window is in-media; the result
- * round-trips `Composition.parse` + `validateComposition`. Pure + deterministic.
- */
 import { type Composition } from '../composition/validators/index.js';
-/** One authored cut span (the resolver's lowered advisory, source-only shape). */
 export interface CutSpan {
     startSec: number;
     endSec: number;
-    /** The chosen angle's stable id (legible, round-trips as the clip's mediaId's
-     *  companion — used only for diagnostics here). */
     candidateId: string;
-    /** The branded mediaItems id of the chosen angle's source. */
     mediaId: string;
-    /** The chosen angle's SOURCE window (timebase already resolved by the resolver). */
     sourceInSec: number;
     sourceOutSec: number;
 }
 export interface ReplaceRegionInput {
-    /** The base composition to author onto. */
     composition: Composition;
-    /** The video cut schedule (tiles [regionStart, regionEnd), back-to-back). */
     cutSchedule: CutSpan[];
-    /**
-     * GROUP-SCOPED program audio (spec A1): when set, the video cuts A→B→C but the
-     * audio is PINNED to this one source for the whole region on a separate audio
-     * track (topology-i — one continuous mic over multicam). When omitted, audio
-     * FOLLOWS the video (the `kind:"cut"` literal meaning) — each cut clip carries
-     * its own audio.
-     */
     programAudioSourceId?: string;
-    /**
-     * Source duration per mediaId (seconds) — for the audio-bed clip's window + the
-     * in-media guard on the pinned audio. The resolver supplies it.
-     */
     durationByMediaId: Record<string, number>;
-    /** Track name for the authored video cut track. */
     trackName?: string;
 }
-/** Author a non-rippling cut schedule (+ optional pinned audio bed) onto a fresh
- *  video track of the composition. Returns the new composition (pure). */
 export declare function replaceRegion(input: ReplaceRegionInput): Composition;

package/dist/_members/composition-ops/testFixtures.d.ts

@@ -1,19 +1,5 @@
-/**
- * Test fixtures — minimal valid `TimelineClip`s per family, for the
- * `clip.add` kind-dispatch tests. Each builds the smallest clip that
- * `TimelineClip.strict()` accepts for its source kind.
- *
- * `kind` (the clip's family hint) is set ONLY where the source is ambiguous
- * (a `media` source can land on video / audio / image): `mediaClip` takes an
- * explicit family. Overlay-source clips need no `kind` — the family derives
- * from `source.kind` (overlay → overlay).
- */
 import type { TimelineClip } from '../composition/validators/index.js';
-/** A media-source clip with an EXPLICIT family `kind` (video|audio|image). */
 export declare const mediaClip: (id: string, kind?: "video" | "audio" | "image") => TimelineClip;
-/** An overlay-source clip — family derives from `source.kind` (no clip.kind). */
 export declare const overlayClip: (id: string) => TimelineClip;
-/** An audio clip: a media source carried on the `audio` family. */
 export declare const audioClip: (id: string) => TimelineClip;
-/** A minimal valid Marker (point marker on the timeline). */
 export declare const marker: (id: string, startTime?: number) => import("../composition/validators/index.js").Marker;

package/dist/_members/convex-api/api.d.ts

@@ -1,5 +1,2 @@
 import type { api as GeneratedApi } from "./api.generated.js";
-/** The client-facing function-reference proxy. Runtime-identical to the
- *  backend's generated `api` (which IS `anyApi`); typed by the vendored
- *  declarations with the internal.* surface stripped. */
 export declare const api: typeof GeneratedApi;

package/dist/_members/convex-api/dataModel.d.ts

@@ -1,6 +1,4 @@
 import type { GenericId } from "convex/values";
 import type { SystemTableNames } from "convex/server";
-/** Table NAMES only — the vendored surface deliberately omits document
- *  shapes (Doc/DataModel). Public consumers use exclusively `Id<...>`. */
 export type TableNames = "agentMessages" | "agentThreads" | "apiAuditLog" | "billingPlanState" | "brandKits" | "briefs" | "checkpoints" | "clips" | "clipSuggestionRuns" | "componentVersions" | "composeJobs" | "compositionEvents" | "compositionRuns" | "compositions" | "compositionVersions" | "contextFiles" | "conversations" | "corrections" | "critics" | "dashboardInsights" | "directorProfiles" | "directorWorkflows" | "enrichmentCandidates" | "exports" | "idempotencyKeys" | "installedComponents" | "jobs" | "markers" | "mediaItems" | "mediaUnderstanding" | "overlays" | "pricingPolicy" | "processingEvents" | "projects" | "providerStates" | "renderJobs" | "resourceQueryCache" | "resourceRateBuckets" | "restorePoints" | "runs" | "searchQueries" | "sessions" | "sessionTokens" | "settings" | "socialAccounts" | "socialInsights" | "socialMediaItems" | "templateEmbeddings" | "templates" | "timelineClips" | "tracks" | "transcripts" | "uploadTokens" | "usageEvents" | "userSettings" | "videoChunkEmbeddings" | "webhookDeliveries" | "webhookProjectUpdateDebounce" | "webhooks" | "x402Payments";
 export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;

package/dist/_members/core/index.d.ts

@@ -1,3 +1,3 @@
 export * from './types.js';
-export { buildEmphasisSet, isEmphasized, extractCaptionWordsFromDoc, DEFAULT_FPS, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_RENDER_SETTINGS, FORMAT_PRESETS, RESOLUTION_PRESETS, bppToCrf, computeExportDimensions, ensureEven, } from './render/index.js';
+export { buildEmphasisSet, isEmphasized, extractCaptionWordsFromDoc, DEFAULT_FPS, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_RENDER_SETTINGS, FORMAT_PRESETS, RESOLUTION_PRESETS, bppToCrf, ensureEven, } from './render/index.js';
 export type { RenderInput, CompositionClip, CompositionOverlay, CompositionAudioTrack, CaptionWord, CaptionStyle, EmphasisWord, DocNode, ExportFormat, ExportQuality, ExportResolution, FormatPreset, RenderSettings, } from './render/index.js';

package/dist/_members/core/render/bookends.d.ts

@@ -1,60 +1,16 @@
-/**
- * Brand intro/outro BOOKEND timeline math — pure, fps-driven, never throws.
- *
- * Phase 2 of the brand-consistent demo pipeline: when the resolved brand kit
- * carries an `intro`/`outro` bumper, the render prepends the intro and appends
- * the outro to the body composition. This module owns the ONE timeline
- * calculation both sides of the render share:
- *
- *   - `compositionToRenderInput` (this package) reads it FORWARD — body duration
- *     in, extended total out — to size the Remotion composition's
- *     `durationInFrames`.
- *   - `MainComposition` (cueframe renderer) reads `bookendFrames` to place the
- *     intro at frame 0, shift the body forward by the intro, and append the
- *     outro — so the math can't diverge between "how long is the video" and
- *     "where does each piece sit."
- *
- * SOFT by construction (mirrors the brand cascade's "never crash the render"
- * rule): a missing/odd bumper, a video bumper with no source, or a non-positive
- * fps yields 0 reserved frames — no bookend, never a throw, never negative.
- * Fail-loud belongs at BrandKit PUT-time validation, not render-time placement.
- */
 import type { ResolvedBrandKit } from "../../composition/projection/index.js";
-/** Card bumper default length when the kit didn't set one (mirrors the resolver). */
 export declare const CARD_BOOKEND_DEFAULT_MS = 1500;
-/**
- * Video bumper fallback length when the kit set no `durationMs`. The resolver
- * forces no default for `kind:'video'` ("clip length governs"), but the pure
- * timeline math can't probe the clip's intrinsic length, so the renderer
- * reserves this deterministic window. A kit that sets `durationMs` overrides it.
- */
 export declare const VIDEO_BOOKEND_DEFAULT_MS = 3000;
 type Bumper = NonNullable<ResolvedBrandKit["intro"]>;
-/**
- * Frames a single intro/outro bumper reserves on the timeline, or 0 when it is
- * absent/odd (soft). `card` always reserves (defaults to 1.5s); `video` reserves
- * only with a usable `src` (else there is nothing to play).
- */
 export declare function bookendFrames(bumper: ResolvedBrandKit["intro"] | undefined, fps: number): number;
 export interface BookendTimeline {
-    /** Frames the intro reserves at the head (0 = no intro). */
     introFrames: number;
-    /** Frames the outro reserves at the tail (0 = no outro). */
     outroFrames: number;
-    /** First body frame on the extended timeline (= introFrames). */
     bodyStartFrames: number;
-    /** Body length in frames — unchanged from the un-bookended timeline. */
     bodyFrames: number;
-    /** First outro frame (= introFrames + bodyFrames). */
     outroStartFrames: number;
-    /** Extended composition total: intro + body + outro. */
     totalFrames: number;
 }
-/**
- * Forward timeline math: given the resolved kit's bumpers and the body's frame
- * length, place the bookends and compute the extended total. fps-driven; a
- * non-positive body folds to 0 (the total is then just the bookends).
- */
 export declare function resolveBookendTimeline(brandKit: {
     intro?: ResolvedBrandKit["intro"];
     outro?: ResolvedBrandKit["outro"];

package/dist/_members/core/render/captions.d.ts

@@ -1,11 +1,5 @@
 import type { CaptionWord } from './types.js';
 import type { EmphasisWord } from './emphasis.js';
-/**
- * Word-timed transcript utterance — minimal shape covering Deepgram /
- * AssemblyAI / legacy-Whisper outputs. Times are seconds (provider
- * convention); the slicer rebases to milliseconds for the Captions
- * primitive.
- */
 export interface TranscriptUtterance {
     speaker?: string | null;
     text?: string;
@@ -18,48 +12,12 @@ export interface TranscriptUtterance {
         confidence?: number;
     }>;
 }
-/**
- * Slice a transcript's word stream to a clip window.
- *
- * Source: `utterances[].words[]` with second-precision `start` / `end`.
- * Output: `CaptionWord[]` with millisecond timings rebased so the
- * first word's `startMs` is 0 (relative to the clip, not the source).
- * Words wholly outside `[fromSec, toSec)` are dropped; words that
- * straddle either edge are clamped to the boundary.
- *
- * Pure function — no I/O, no DB. Caller fetches the transcript blob
- * (typically from R2) and feeds the parsed `utterances` here.
- */
 export declare function sliceTranscriptWords(utterances: TranscriptUtterance[], fromSec: number, toSec: number): CaptionWord[];
-/** ProseMirror/TipTap document node — generic to avoid @tiptap/core dependency. */
 export interface DocNode {
     type?: string;
     text?: string;
     attrs?: Record<string, unknown>;
     content?: DocNode[];
 }
-/**
- * Walk a TipTap doc JSONContent and extract non-deleted timedWord nodes
- * as CaptionWord[].
- *
- * In v2 the wire-shape composition encodes cuts physically (clip
- * startTime/duration), so caption timings are taken straight off the
- * timedWord attrs without any deletion-range shift.
- *
- * This makes the ProseMirror doc the single source of truth for caption text,
- * instead of re-reading raw Whisper transcripts.
- */
 export declare function extractCaptionWordsFromDoc(doc: DocNode, emphasisWords: EmphasisWord[]): CaptionWord[];
-/**
- * Group a flat word stream into sentence-bounded segments — start a new segment
- * after any word that ends a sentence (`isSentenceEnd`). Caption words carry
- * punctuation from Deepgram's `punctuated_word`, so the trailing-character test
- * is reliable; abbreviations and initialisms are guarded so they don't
- * false-split mid-sentence.
- *
- * This is how a raw transcript slice becomes `composition.captions.segments`:
- * the renderer treats each segment as a hard caption-page boundary, so
- * sentence-bounded segments make captions cut at sentence ends. A stream with
- * no terminal punctuation yields a single segment; an empty stream yields none.
- */
 export declare function splitIntoSentences(words: CaptionWord[]): CaptionWord[][];

package/dist/_members/core/render/compositionRender.d.ts

@@ -1,88 +1,12 @@
-/**
- * Wire-shape `Composition` → `RenderInput` translator.
- *
- * `Composition` is the canonical multi-track wire shape from
- * `@cueframe/composition`. It crosses the API boundary
- * (PUT /v1/projects/:id/composition), gets snapshotted onto
- * `renderJobs.composition`, and is what the Remotion worker reads
- * before kicking off a render.
- *
- * This module is the single bridge from that wire shape to the
- * frame-based `RenderInput` Remotion consumes:
- *
- *   {format, tracks[]: [{kind, contents[]: TimelineClip[]}]}
- *      ↓
- *   compositionToRenderInput(composition, srcUrls)
- *      ↓
- *   { clips, overlays, audioTracks, effects, width, height, fps,
- *     durationInFrames }
- *
- * Track-kind handling:
- *   - `video` → `CompositionClip[]`. Each clip's wire startTime/duration
- *     map to timelineStartFrames/durationInFrames; `source.trim`'s
- *     source-relative seconds map to sourceInFrames/sourceOutFrames.
- *     Clips on multiple video tracks layer in track order (z-order
- *     follows the wire array).
- *   - `audio` → `CompositionAudioTrack[]`. `source.volumeDb` (if set)
- *     converts to linear gain via `10^(dB/20)`; `source.fadeInMs` /
- *     `source.fadeOutMs` convert to frames.
- *   - `image` → `CompositionClip[]` with `mediaType: 'image'`. Stills
- *     have no source timeline (sourceIn/Out are zero); `source.kenBurns`
- *     flows through as a convenience that the renderer's <StillCrop> lowers
- *     to a `reframe` (kenBurnsToReframe) and runs through the UNIFIED crop
- *     renderer, so a still gets the same per-frame point-zoom video does.
- *     Sub-frame durations are dropped (would crash Remotion's <Sequence>).
- *   - `overlay` → `CompositionOverlay[]`. Wire `source.primitiveId`
- *     becomes `template`; `source.params` flow through to the renderer.
- *   - `effect` → `CompositionEffect[]` with `target.kind: 'global'`,
- *     scoped to the effect clip's wire start/duration.
- *
- * `srcUrls` is a `mediaId → presigned URL` map. The caller (Temporal
- * activity) pre-signs every unique mediaId before calling this. A
- * referenced mediaId missing from `srcUrls` throws — silent fallbacks
- * are forbidden (the v0 path's silent-fallback bug class).
- */
 import type { Composition, Format } from "../../composition/validators/index.js";
 import type { RenderInput } from "./types.js";
 import type { TrajectoryData } from "../../composition/reframe/trajectory.js";
-/**
- * Resolve `Format` (`aspectRatio`, optional `fps` + `resolution`) to
- * concrete pixel dimensions. Mirrors the public-composition path's
- * `publicFormatDimensions` so a Composition with `format: { aspectRatio:
- * "9:16", fps: 30, resolution: "fhd" }` lands at the same 1080×1920
- * regardless of which translator the worker traversed.
- */
 export declare function compositionFormatDimensions(format: Format): {
     width: number;
     height: number;
     fps: number;
 };
-/**
- * Runtime-validate an untrusted value as a `Composition`. The Temporal
- * activity reads `renderJobs.composition` which is stored as
- * `v.optional(v.any())` — Convex doesn't enforce shape at read time. A
- * schema drift or a manual DB edit could leave a malformed value here,
- * and the renderer would crash later in the pipeline with a less
- * actionable error.
- *
- * Returns the validated composition or throws with a specific error
- * message. Call this at the activity boundary before passing the
- * composition to `compositionToRenderInput`. Pure JS validation — no
- * Zod runtime — so this module ships into the Temporal worker without
- * dragging the package's Zod surface along.
- */
 export declare function validateComposition(raw: unknown): Composition;
-/**
- * Given a clip's effective trim window [trimStart, trimEnd] and an
- * optional sorted+non-overlapping list of excluded ranges (all in source
- * coordinates), return the playable spans in order. Each span is a
- * contiguous source range that should render as a sub-clip.
- *
- * Invariant (enforced upstream): Σ(span.end - span.start) === clip.duration.
- */
-/** The clip's playable spans (seconds) = [trimStart, trimEnd] minus
- *  excludedRanges. SSOT for section splitting — exported so the Director derives
- *  the SAME sections the render uses when it builds structure-first keep-outs. */
 export declare function playableSpans(trimStart: number, trimEnd: number, excluded: Array<{
     start: number;
     end: number;
@@ -90,117 +14,14 @@ export declare function playableSpans(trimStart: number, trimEnd: number, exclud
     start: number;
     end: number;
 }>;
-/**
- * Every unique mediaId the composition references — the SAME references
- * `compositionToRenderInput` resolves through `srcUrls` (any clip whose
- * `source.kind === 'media'`, on any track family). Interactive hosts (the
- * editor preview) gate on this BEFORE converting: a referenced id without a
- * URL yet is a LOADING state there, while the converter's fail-loud throw
- * stays correct for export/server paths where every URL must already exist.
- * Living next to the converter keeps the two walks from drifting.
- */
 export declare function referencedMediaIds(composition: Composition): string[];
-/**
- * Every component-REFERENCE `custom` overlay clip, as `clipId → componentId` —
- * the SAME references `compositionToRenderInput` resolves through
- * `jsSourceByClipId` (bakeless live lane). Clips carrying their own inline
- * `params.sourceCode` (desktop-authored customs) need no materialization and
- * are excluded. Interactive hosts (the editor preview) gate on this BEFORE
- * converting and feed the fetched live `jsSource`s in — the converter's
- * fail-loud `custom_missing_sourcecode` throw stays correct for export/server
- * paths. Living next to the converter keeps the walks from drifting.
- */
 export declare function componentRefsByClipId(composition: Composition): Record<string, string>;
-/**
- * Translate a wire-shape `Composition` to a frame-based `RenderInput`.
- *
- * The output's `durationInFrames` is the max content end across all
- * tracks (clips + overlays + effects). An empty composition produces
- * an empty RenderInput with duration 0 — caller decides whether that
- * should error or render a black frame; we don't make a policy call
- * here.
- */
-export declare function compositionToRenderInput(composition: Composition, srcUrls: Record<string, string>, 
-/**
- * Optional parallel map: `clipId → presigned crop-trajectory JSON URL`
- * (keyed PER CLIP since Phase 2 — two clips of one media with different
- * framing each carry their own trajectory). Populated by the caller
- * (Temporal activity) when the mediaItem has a baked variant for the
- * clip's window-qualified (intentHash, aspect). The renderer fetches the
- * JSON at composition time and applies a per-frame CSS transform on the
- * raw video to produce the cropped output. When unset for a given clipId,
- * the renderer plays the raw source un-cropped.
- */
-trajectoryUrls?: Record<string, string>, 
-/**
- * Optional parallel map: `mediaId → presigned frame-packed co-view URL`
- * (scene over matte, one opaque H.264). Populated by the caller for any clip
- * whose timeline range overlaps a behind-subject caption window and whose
- * matte the gate baked (content-driven, Phase 6). Matte PRESENCE is the gate —
- * the render splits it into scene background + subject cut-out for the z-split.
- */
-coViewUrls?: Record<string, string>, 
-/**
- * Optional parallel map: `clipId → baked-alpha file URL/path` for alpha-layer
- * clips (2.6b). The box bake (renderComponentAlpha) writes the transparent
- * video; the caller (session daemon / director) threads the path here. The
- * renderer mounts it as an alpha overlay at the clip's zPlane.
- */
-alphaUrls?: Record<string, string>, 
-/**
- * Optional parallel map: `clipId → FRESH transpiled jsSource` for
- * component-backed `custom` overlays (bakeless live lane). Materialized per
- * render from `installedComponents` (renders.ts) — the live-lane peer of
- * `alphaUrls`. The overlay projection prefers it over any stored
- * `params.sourceCode`, so a component edit is reflected on the next render
- * with no composition re-save.
- */
-jsSourceByClipId?: Record<string, string>, 
-/**
- * Compound-clip resolution: `compositionId → Composition` for every
- * `{kind:'composition'}` source the composition (transitively) embeds.
- * Flattening happens HERE, at the one translator every render lane flows
- * through, so an embedded sequence renders identically on desktop, cloud
- * and still lanes. A compound clip with no entry FAILS LOUD
- * (`compound_unresolved`) rather than rendering a deliverable that is
- * silently missing a sequence.
- */
-subCompositions?: Record<string, Composition>, 
-/**
- * Optional parallel map: `clipId → an ALREADY-DERIVED crop trajectory`, the
- * in-memory peer of `trajectoryUrls`.
- *
- * The editor supplies this. `deriveTrajectory` is pure and the subject track
- * it reads arrives presigned on the media row, so a preview surface can
- * derive exactly what the render will derive — same function, same track,
- * same authored reframe — with no round trip and nothing to store. That is
- * what lets a follow-the-speaker clip move in the preview instead of only in
- * an output someone has already paid for.
- *
- * Server renders keep using `trajectoryUrls`: their trajectory is written to
- * R2 by an action, and inlining a per-frame series would bloat the snapshot.
- */
-trajectories?: Record<string, TrajectoryData>): RenderInput;
-/**
- * Assemble a RenderInput from an ALREADY-validated (and brand-ref-resolved)
- * composition plus PRE-RESOLVED asset URL maps. This is the pure core shared by
- * the director's `resolveRenderEnvironment` (which resolves the URLs with R2/S3
- * creds, host-side) AND the in-container session daemon (which is handed the URLs
- * and holds no creds). One builder ⇒ render and capture cannot diverge on the
- * composition→RenderInput translation.
- *
- * `fontAssets` (when present) are the host-presigned brand font faces; they are
- * attached to the RenderInput's brandKit so the renderer can `@font-face` them.
- * The caller does the cred-bound URL/font resolution; this only assembles.
- */
+export declare function compositionToRenderInput(composition: Composition, srcUrls: Record<string, string>, trajectoryUrls?: Record<string, string>, coViewUrls?: Record<string, string>, alphaUrls?: Record<string, string>, jsSourceByClipId?: Record<string, string>, subCompositions?: Record<string, Composition>, trajectories?: Record<string, TrajectoryData>): RenderInput;
 export declare function assembleRenderInput(composition: Composition, resolved: {
     srcUrls: Record<string, string>;
     trajectoryUrls?: Record<string, string>;
     coViewUrls?: Record<string, string>;
-    /** clipId → baked-alpha file URL/path for alpha-layer clips (2.6b). */
     alphaUrls?: Record<string, string>;
-    /** clipId → FRESH transpiled jsSource for component-backed `custom` overlays
-     *  (bakeless live lane; live-lane peer of `alphaUrls`). */
     jsSourceByClipId?: Record<string, string>;
     fontAssets?: NonNullable<RenderInput["brandKit"]>["fontAssets"];
 }): RenderInput;