@cueframe/kernel 0.0.1

package/dist/_members/composition-ops/testFixtures.js

@@ -0,0 +1,19 @@
+/** A media-source clip with an EXPLICIT family `kind` (video|audio|image). */
+export const mediaClip = (id, kind) => ({
+    id,
+    startTime: 0,
+    duration: 5,
+    ...(kind ? { kind } : {}),
+    source: { kind: 'media', mediaId: 'media-1', trim: { start: 0, end: 5 } },
+});
+/** An overlay-source clip — family derives from `source.kind` (no clip.kind). */
+export const overlayClip = (id) => ({
+    id,
+    startTime: 0,
+    duration: 3,
+    source: { kind: 'overlay', primitiveId: 'cinematic-title', params: { text: 'hi' } },
+});
+/** An audio clip: a media source carried on the `audio` family. */
+export const audioClip = (id) => mediaClip(id, 'audio');
+/** A minimal valid Marker (point marker on the timeline). */
+export const marker = (id, startTime = 1) => ({ id, startTime, kind: 'note', name: `marker ${id}` });

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

@@ -0,0 +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 type { RenderInput, CompositionClip, CompositionOverlay, CompositionAudioTrack, CaptionWord, CaptionStyle, EmphasisWord, DocNode, ExportFormat, ExportQuality, ExportResolution, FormatPreset, RenderSettings, } from './render/index.js';

package/dist/_members/core/index.js

@@ -0,0 +1,5 @@
+export * from './types';
+// Re-export render module, excluding OverlayTemplate and OverlayParams which
+// are already exported from ./types with a different (generic) shape.
+// Consumers that need the Remotion-specific versions import from '@cueframe/core/render'.
+export { buildEmphasisSet, isEmphasized, extractCaptionWordsFromDoc, DEFAULT_FPS, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_RENDER_SETTINGS, FORMAT_PRESETS, RESOLUTION_PRESETS, bppToCrf, computeExportDimensions, ensureEven, } from './render';

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

@@ -0,0 +1,62 @@
+/**
+ * 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"];
+} | undefined, bodyFrames: number, fps: number): BookendTimeline;
+export type { Bumper };

package/dist/_members/core/render/bookends.js

@@ -0,0 +1,53 @@
+/** Card bumper default length when the kit didn't set one (mirrors the resolver). */
+export 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 const VIDEO_BOOKEND_DEFAULT_MS = 3000;
+/**
+ * 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 function bookendFrames(bumper, fps) {
+    if (!bumper)
+        return 0;
+    if (bumper.kind !== "card" && bumper.kind !== "video")
+        return 0;
+    if (!Number.isFinite(fps) || fps <= 0)
+        return 0;
+    // A video bumper with no source can't render — soft no-op.
+    if (bumper.kind === "video" &&
+        (typeof bumper.src !== "string" || bumper.src.length === 0)) {
+        return 0;
+    }
+    const fallbackMs = bumper.kind === "card" ? CARD_BOOKEND_DEFAULT_MS : VIDEO_BOOKEND_DEFAULT_MS;
+    const ms = typeof bumper.durationMs === "number" &&
+        Number.isFinite(bumper.durationMs) &&
+        bumper.durationMs > 0
+        ? bumper.durationMs
+        : fallbackMs;
+    const frames = Math.round((ms / 1000) * fps);
+    return frames > 0 ? frames : 0;
+}
+/**
+ * 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 function resolveBookendTimeline(brandKit, bodyFrames, fps) {
+    const introFrames = bookendFrames(brandKit?.intro, fps);
+    const outroFrames = bookendFrames(brandKit?.outro, fps);
+    const safeBody = Number.isFinite(bodyFrames) && bodyFrames > 0 ? bodyFrames : 0;
+    return {
+        introFrames,
+        outroFrames,
+        bodyStartFrames: introFrames,
+        bodyFrames: safeBody,
+        outroStartFrames: introFrames + safeBody,
+        totalFrames: introFrames + safeBody + outroFrames,
+    };
+}

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

@@ -0,0 +1,65 @@
+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;
+    start: number;
+    end: number;
+    words?: Array<{
+        text: string;
+        start: number;
+        end: number;
+        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/captions.js

@@ -0,0 +1,127 @@
+import { buildEmphasisSet, isEmphasized } from './emphasis';
+/**
+ * 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 function sliceTranscriptWords(utterances, fromSec, toSec) {
+    const out = [];
+    for (const utt of utterances) {
+        if (!utt.words || utt.words.length === 0)
+            continue;
+        for (const w of utt.words) {
+            if (w.end <= fromSec)
+                continue;
+            if (w.start >= toSec)
+                continue;
+            const start = Math.max(w.start, fromSec);
+            const end = Math.min(w.end, toSec);
+            const text = (w.text ?? '').trim();
+            if (!text)
+                continue;
+            out.push({
+                text,
+                startMs: Math.round((start - fromSec) * 1000),
+                endMs: Math.round((end - fromSec) * 1000),
+            });
+        }
+    }
+    return out;
+}
+/**
+ * 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 function extractCaptionWordsFromDoc(doc, emphasisWords) {
+    const captions = [];
+    const emphasisSet = buildEmphasisSet(emphasisWords);
+    function walk(node) {
+        if (node.type === 'timedWord' && node.attrs && !node.attrs.deleted) {
+            const start = node.attrs.start;
+            const end = node.attrs.end;
+            const text = node.content?.[0]?.text ?? '';
+            if (!text.trim())
+                return;
+            captions.push({
+                text,
+                startMs: start * 1000,
+                endMs: end * 1000,
+                emphasis: isEmphasized(emphasisSet, node.attrs.mediaId, node.attrs.sourceStart) || undefined,
+            });
+        }
+        if (node.content) {
+            for (const child of node.content)
+                walk(child);
+        }
+    }
+    walk(doc);
+    return captions;
+}
+// Common abbreviations whose trailing period is NOT a sentence end. Lower-cased,
+// period stripped. Not exhaustive — sentence-boundary disambiguation is
+// inherently lossy; this covers the frequent cases (titles, latin, units) so
+// captions don't false-break mid-sentence. Erring toward UNDER-splitting is
+// correct here: a missed split merges two short sentences (mildly long page),
+// whereas a false split is the exact mid-sentence cut this fix removes.
+const SENTENCE_ABBREVIATIONS = new Set([
+    'mr', 'mrs', 'ms', 'dr', 'prof', 'sr', 'jr', 'st', 'rev', 'gen', 'sen', 'gov',
+    'rep', 'capt', 'sgt', 'lt', 'col', 'vs', 'etc', 'inc', 'ltd', 'co', 'corp',
+    'mt', 'no', 'vol', 'dept', 'fig', 'al', 'approx',
+]);
+/** Whether a word's text terminates a sentence. `!`/`?` always do; a trailing
+ *  `.` does NOT when the token is an initialism (`U.S.`, `e.g.`, `a.m.`) or a
+ *  known abbreviation (`Dr.`, `etc.`). A number like "3.14" ends in a digit. */
+function isSentenceEnd(text) {
+    const t = text.trim();
+    if (/[!?]$/.test(t))
+        return true;
+    if (!t.endsWith('.'))
+        return false;
+    // Initialism / dotted abbreviation: every letter followed by a period
+    // (U.S., e.g., i.e., a.m., p.m.) — internal periods mark it as not-a-stop.
+    if (/^(\p{L}\.)+$/u.test(t))
+        return false;
+    if (SENTENCE_ABBREVIATIONS.has(t.slice(0, -1).toLowerCase()))
+        return false;
+    return true;
+}
+/**
+ * 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 function splitIntoSentences(words) {
+    const segments = [];
+    let current = [];
+    for (const word of words) {
+        current.push(word);
+        if (isSentenceEnd(word.text)) {
+            segments.push(current);
+            current = [];
+        }
+    }
+    if (current.length > 0)
+        segments.push(current);
+    return segments;
+}

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

@@ -0,0 +1,190 @@
+/**
+ * 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";
+/**
+ * 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;
+}> | undefined): Array<{
+    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>): 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 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;