@cueframe/kernel 0.0.1

package/dist/_members/render-harness/cardRender.d.ts

@@ -0,0 +1,64 @@
+/** The Remotion composition id the generated card Root registers. */
+export declare const CARD_COMPOSITION_ID = "CueFrameCardStill";
+/** Generated Remotion Root filename, written into the card render's out dir. */
+export declare const CARD_ROOT_FILENAME = "card.Root.local.tsx";
+/** Generated Remotion entry filename (the card bundle's entryPoint). */
+export declare const CARD_ENTRY_FILENAME = "card.entry.local.tsx";
+/**
+ * The generated Remotion Root source for a single-card still. PURE (no IO, no
+ * Chrome) so it is unit-testable. Verbatim mirror of OverlayContent.tsx
+ * `case 'card'`: a full-bleed box, brand tokens as inherited `--cf-*` custom
+ * properties (`cssVars`), the authored html via `dangerouslySetInnerHTML`. The
+ * card's own CSS positions itself (the inspiration motifs use `position:absolute`),
+ * so no region box is applied here — this is the ISOLATION preview.
+ */
+export declare function generateCardRootSource(opts: {
+    width: number;
+    height: number;
+    fps: number;
+}): string;
+/** The generated Remotion entry source (registers the Root). PURE. */
+export declare function generateCardEntrySource(): string;
+/**
+ * Minimal webpack override for the card bundle. The generated entry lives in an
+ * out dir with NO node_modules of its own, so anchor module resolution to
+ * renderEntryRoot's node_modules (where `react` + `remotion` live). NOTHING else —
+ * a card Root imports ONLY react + remotion (no @cueframe packages, no sandbox
+ * globals, no tauri shim), which is exactly why the card path is this much
+ * simpler than buildLocalWebpackOverride.
+ */
+export declare function buildCardWebpackOverride(renderEntryRoot: string): (config: any) => any;
+export interface RenderCardStillOpts {
+    /** Authored card HTML — rendered VERBATIM (script-free). */
+    html: string;
+    /**
+     * Brand tokens pre-resolved to `--cf-*` custom properties (the output of
+     * OverlayContent's `cssLayoutVars`). Optional — a card with literal inline
+     * colors needs none. The tool layer (buildLocalCardToolSet), which has the
+     * resolved brand kit, computes these; renderCardStill stays a pure html+vars
+     * → PNG step with no brand-kit dependency.
+     */
+    cssVars?: Record<string, string>;
+    /** Out dir for the generated bundle + the PNG (the card has no component Workspace). */
+    outDir: string;
+    /** Frame width. Default 1080 (the inspiration lane's 9:16). */
+    width?: number;
+    /** Frame height. Default 1920. */
+    height?: number;
+    fps?: number;
+    /** Frame to render. Default 0 — a static card iterates fine on frame 0. */
+    frame?: number;
+    /** The render-entry package root (Remotion toolchain owner). Default via resolveRenderEntryRoot. */
+    renderEntryRoot?: string;
+}
+/**
+ * Render a `{kind:'card', html}` to a still PNG via a LOCAL Remotion bundle —
+ * NO cloud. Requires an installed Chrome via REMOTION_CHROME_EXECUTABLE (the
+ * chrome-headless-shell auto-download hangs on macOS — see localRender.ts). The
+ * output PNG is transparent where the card doesn't paint (the isolation preview);
+ * composite it over a footage frame only when checking contrast.
+ */
+export declare function renderCardStill(opts: RenderCardStillOpts): Promise<{
+    pngPath: string;
+}>;
+//# sourceMappingURL=cardRender.d.ts.map

package/dist/_members/render-harness/cardRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardRender.d.ts","sourceRoot":"","sources":["../src/cardRender.ts"],"names":[],"mappings":"AAwBA,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,sBAAsB,CAAC;AACvD,gFAAgF;AAChF,eAAO,MAAM,kBAAkB,wBAAwB,CAAC;AACxD,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,yBAAyB,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA6BnG;AAED,sEAAsE;AACtE,wBAAgB,uBAAuB,IAAI,MAAM,CAMhD;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,MAAM,IAEtD,QAAQ,GAAG,SAOpB;AAED,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,wFAAwF;IACxF,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oGAAoG;IACpG,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAuC7F"}

package/dist/_members/render-harness/contractRender.d.ts

@@ -0,0 +1,43 @@
+/** The Remotion composition id the generated contract Root registers. */
+export declare const CONTRACT_COMPOSITION_ID = "CueFrameContractFrames";
+export declare const CONTRACT_ROOT_FILENAME = "contract.Root.local.tsx";
+export declare const CONTRACT_ENTRY_FILENAME = "contract.entry.local.tsx";
+/**
+ * The generated Remotion Root source. PURE (no IO, no Chrome) — unit-testable.
+ * The contract source is embedded via an IIFE (`export default` → `return`), so
+ * named/anonymous function or expression defaults all evaluate. `cssVars` wrap
+ * the component the same way OverlayContent's card branch wraps a card.
+ */
+export declare function generateContractRootSource(opts: {
+    jsxSource: string;
+    width: number;
+    height: number;
+    fps: number;
+    durationInFrames: number;
+}): string;
+/** The generated Remotion entry source. PURE. */
+export declare function generateContractEntrySource(): string;
+export interface RenderContractFramesOpts {
+    /** Contract-shaped component source (motion shell / scratch component). */
+    jsxSource: string;
+    /** Frame indices to render (e.g. entrance/exit samples). */
+    frames: number[];
+    durationInFrames: number;
+    params?: Record<string, unknown>;
+    /** Brand tokens pre-resolved to --cf-* vars (cssLayoutVars output). */
+    cssVars?: Record<string, string>;
+    outDir: string;
+    width?: number;
+    height?: number;
+    fps?: number;
+    renderEntryRoot?: string;
+}
+/**
+ * Render a contract component at N frame indices → N PNGs (one Chrome bundle,
+ * one selectComposition, N stills). Same local toolchain contract as
+ * renderCardStill: REMOTION_CHROME_EXECUTABLE + the renderEntryRoot's Remotion.
+ */
+export declare function renderContractFrames(opts: RenderContractFramesOpts): Promise<{
+    pngPaths: string[];
+}>;
+//# sourceMappingURL=contractRender.d.ts.map

package/dist/_members/render-harness/contractRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contractRender.d.ts","sourceRoot":"","sources":["../src/contractRender.ts"],"names":[],"mappings":"AAuBA,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,2BAA2B,CAAC;AAChE,eAAO,MAAM,sBAAsB,4BAA4B,CAAC;AAChE,eAAO,MAAM,uBAAuB,6BAA6B,CAAC;AAElE;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE,MAAM,CAAC;CAC1B,GAAG,MAAM,CAmDT;AAED,iDAAiD;AACjD,wBAAgB,2BAA2B,IAAI,MAAM,CAMpD;AAED,MAAM,WAAW,wBAAwB;IACvC,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAuDjC"}

package/dist/_members/render-harness/extractSegments.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Extract clip segments from source videos via ffmpeg.
+ *
+ * Remotion's OffthreadVideo downloads the entire source file for each frame.
+ * For large files (91MB+), this causes timeouts. Pre-extracting only the
+ * needed segments makes rendering fast regardless of source file size.
+ *
+ * Uses `ffmpeg -c copy` (packet copy) — no re-encoding, sub-second extraction.
+ *
+ * Private cloud render-harness module — used only by materializeSources for the
+ * Modal render sandbox (no desktop/OSS consumers).
+ */
+export interface SegmentResult {
+    /** Map: poolItemId → extracted segment file path */
+    segments: Record<string, string>;
+    /**
+     * Map: poolItemId → the SOURCE second at frame 0 of the served file — the
+     * exact `-ss` hull start ffmpeg was given (0 for the local-fallback path,
+     * which serves the UNTRIMMED original). The caller's seek/trajectory rebase
+     * MUST use this instead of re-deriving the hull math: an independent
+     * recomputation silently desynchronizes the seek window AND the crop
+     * mapping the moment this module's range math changes (review 2026-07-07),
+     * and the local fallback's origin is 0, not the computed hull start.
+     */
+    origins: Record<string, number>;
+    /** Temp directory containing all segments */
+    dir: string;
+    /** Clean up all segment files and the temp directory */
+    cleanup: () => Promise<void>;
+}
+interface ClipRange {
+    poolItemId: string;
+    /** Start time in seconds */
+    sourceIn: number;
+    /** End time in seconds */
+    sourceOut: number;
+}
+/**
+ * Extract needed segments from source video files.
+ *
+ * Groups clips by poolItemId, computes the union of ranges per source,
+ * and extracts one segment per source covering all needed ranges.
+ *
+ * @param clips - clips with source time ranges
+ * @param sourceFiles - map from poolItemId to local file path
+ * @param opts.padding - extra seconds before/after each range (default 1)
+ * @returns segment file paths keyed by poolItemId
+ */
+export declare function extractSegments(clips: ClipRange[], sourceFiles: Record<string, string>, opts?: {
+    padding?: number;
+}): Promise<SegmentResult>;
+export {};
+//# sourceMappingURL=extractSegments.d.ts.map

package/dist/_members/render-harness/extractSegments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractSegments.d.ts","sourceRoot":"","sources":["../src/extractSegments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC;;;;;;;;OAQG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,UAAU,SAAS;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,SAAS,EAAE,EAClB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1B,OAAO,CAAC,aAAa,CAAC,CAyExB"}

package/dist/_members/render-harness/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @cueframe/render-harness — the PRIVATE cloud render-execution layer.
+ *
+ * Everything here is cloud-render infra that used to sit in the OSS submodule
+ * (@cueframe/core/render + /server) but has zero OSS/desktop consumers — the
+ * "shared with desktop export" headers were stale. It localizes a RenderInput's
+ * remote assets into a render sandbox (Modal) and reads/asserts the
+ * asset surface. Creds-free, generic plumbing; the creds-bearing resolution
+ * (R2 presign / S3 mirror / Convex) lives separately in the director
+ * (lib/render-env). The OSS engine (compositionToRenderInput, render.mjs, the
+ * Remotion compositions) stays in the submodule for WYSIWYG + desktop export.
+ */
+export { materializeSources } from './materializeSources.js';
+export type { MaterializeResult } from './materializeSources.js';
+export { extractSegments } from './extractSegments.js';
+export type { SegmentResult } from './extractSegments.js';
+export { startMediaServer } from './mediaServer.js';
+export type { MediaServer } from './mediaServer.js';
+export { resolveAssets } from './resolveAssets.js';
+export type { AssetMap } from './resolveAssets.js';
+export { renderInputAssets, assertNoRemoteRefs, assetSlots, isRemoteUrl, assetUrlKey, } from './renderInputAssets.js';
+export type { AssetRole, AssetRef, AssetSlot } from './renderInputAssets.js';
+export { generateLocalRegistry, renderComponentStill, renderComponentAlpha, alphaRenderConfig, alphaExt, buildLocalWebpackOverride, buildBoxGlobalsProvideMap, LOCAL_REGISTRY_FILENAME, LOCAL_ROOT_FILENAME, LOCAL_ENTRY_FILENAME, LOCAL_COMPOSITION_ID, } from './localRender.js';
+export type { RenderComponentStillOpts, RenderComponentAlphaOpts, AlphaCodec, SandboxGlobalSpec, } from './localRender.js';
+export { importFromRenderEntry, resolveRenderEntryRoot } from './localRender.js';
+export { renderCardStill, generateCardRootSource, generateCardEntrySource, buildCardWebpackOverride, CARD_COMPOSITION_ID, CARD_ROOT_FILENAME, CARD_ENTRY_FILENAME, } from './cardRender.js';
+export type { RenderCardStillOpts } from './cardRender.js';
+export { renderContractFrames, generateContractRootSource, generateContractEntrySource, CONTRACT_COMPOSITION_ID, CONTRACT_ROOT_FILENAME, CONTRACT_ENTRY_FILENAME, } from './contractRender.js';
+export type { RenderContractFramesOpts } from './contractRender.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_members/render-harness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,UAAU,EACV,WAAW,EACX,WAAW,GACZ,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,QAAQ,EACR,yBAAyB,EACzB,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,wBAAwB,EACxB,wBAAwB,EACxB,UAAU,EACV,iBAAiB,GAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AACjF,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,2BAA2B,EAC3B,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/_members/render-harness/localRender.d.ts

@@ -0,0 +1,167 @@
+import { type Workspace } from '../primitives/workspace.js';
+import { type SandboxGlobalSpec } from './sandboxGlobalSpecs.js';
+export type { SandboxGlobalSpec };
+/** The generated registry filename, written into the `.cueframe/` derived cache. */
+export declare const LOCAL_REGISTRY_FILENAME = "registry.local.tsx";
+/** The generated Remotion Root filename, written alongside the registry. */
+export declare const LOCAL_ROOT_FILENAME = "Root.local.tsx";
+/** The generated Remotion entry filename, the local bundle's entryPoint. */
+export declare const LOCAL_ENTRY_FILENAME = "entry.local.tsx";
+/** The Remotion composition id the generated Root registers. */
+export declare const LOCAL_COMPOSITION_ID = "CueFrameLocalStill";
+/**
+ * Generate the local override registry into the workspace's HIDDEN `.cueframe/`
+ * derived cache (NEVER the visible source dir — it's regenerable, gitignored).
+ *
+ * For every discovered component it emits a side-import of that component's
+ * `config` (the 2.2 create_graphic-generated config.ts) and a
+ * `registerPrimitiveOverride(config)` call. Imports are resolved RELATIVE to the
+ * cache dir (so the generated file is location-independent of the absolute repo
+ * path) and target the VISIBLE component source under `<componentsDir>/<id>/`.
+ *
+ * Returns the absolute path of the written `registry.local.tsx`.
+ *
+ * The 2.2 config.ts (id/component/name/category/kind/version/paramsSchema) is a
+ * STRUCTURAL SUBSET of @cueframe/primitives PrimitiveMeta — it omits the many
+ * required fields (intent/useWhen/tags/mood/tokens/durationInFrames/fps/width/
+ * height/preview/...). So registerPrimitiveOverride (typed `PrimitiveMeta`)
+ * cannot accept it without a widening cast. We register through the loose
+ * `LocalPrimitiveConfig` shape declared in the generated module rather than
+ * sprinkling `as any`: the renderer only reads `id` + `component` + the optional
+ * `paramsSchema`, so the subset is sound at runtime; the cast is named, narrow,
+ * and lives in one generated place.
+ */
+export declare function generateLocalRegistry(ws: Workspace): string;
+/**
+ * Build the `webpack.ProvidePlugin` map for the box bundle from the shared SSOT:
+ * every desktop-sandbox endowment (EXCEPT `console`) becomes a FREE identifier so
+ * a no-import component renders in the box exactly as it does on the desktop
+ * (`evaluateInSandbox` scope injection). ProvidePlugin only fills FREE
+ * identifiers, so importing components are untouched.
+ *
+ *   - `React` → `'react'` (a STRING = whole-module/default, so classic-JSX
+ *     `React.createElement` + bare `React` resolve to the react default export).
+ *   - a named export → `[moduleSpecifier, exportName]`.
+ *   - a LOCAL module (`./fonts`) or a GLOBALS_MODULE wrapper (SandboxVideo/Audio)
+ *     → `[<absolute path under renderEntryRoot>, exportName]` so it resolves in the
+ *     box (whose resolution root is renderEntryRoot).
+ *   - the `@cueframe/animate` `sandboxScope` keys (DYNAMIC — full on pro, empty
+ *     on the OSS/box stub) → `[<@cueframe/animate>, key]` for each `animateName`.
+ *
+ * `console` is intentionally absent — the box keeps the real Node console.
+ */
+export declare function buildBoxGlobalsProvideMap(args: {
+    renderEntryRoot: string;
+    specs: Readonly<Record<string, SandboxGlobalSpec>>;
+    animateNames: readonly string[];
+}): Record<string, string | [string, string]>;
+/**
+ * Build the webpack override for the LOCAL bundle — the spike's
+ * `buildWebpackOverride`: alias the `@cueframe/animate` package (or its stub) +
+ * the `@` source root, shim `@tauri-apps/*` (the desktop bridge the compositions
+ * import but which has no place in a headless render), AND inject the Remotion
+ * sandbox globals via `webpack.ProvidePlugin` so no-import components render in
+ * the box (no-import parity with the desktop sandbox). `renderEntryRoot` is the
+ * @cueframe/render-entry package dir that holds the Remotion deps + the
+ * composition sources + the shim. Mirrors packages/execution/render-entry/scripts/build-remotion-bundle.mjs so the local
+ * bundle behaves identically to the dev-fallback bundle.
+ *
+ * `globals` carries the SSOT spec + the resolved @cueframe/animate names + the
+ * webpack module (defaults to `require('webpack')`, resolved from the box /
+ * @remotion/bundler's webpack at call time; injectable for unit tests).
+ */
+export declare function buildLocalWebpackOverride(renderEntryRoot: string, globals: {
+    specs: Readonly<Record<string, SandboxGlobalSpec>>;
+    animateNames: readonly string[];
+    webpack?: any;
+}): (config: any) => any;
+export interface RenderComponentStillOpts {
+    ws: Workspace;
+    /** The component's flat-string primitiveId (matches its config.ts `id`). */
+    id: string;
+    /** Params spread into the resolved component (forwarded via Remotion inputProps). */
+    params: Record<string, unknown>;
+    /** Frame to render. Default 0 — static graphics iterate fine on frame 0. */
+    frame?: number;
+    /** Composition dimensions (full-bleed default). */
+    width?: number;
+    height?: number;
+    fps?: number;
+    durationInFrames?: number;
+    /**
+     * The @cueframe/render-entry package dir holding the Remotion deps + the
+     * tauri shim (webpack alias root). Defaults to RENDER_ENTRY_ROOT, else the
+     * sibling render-entry package derived from this file.
+     */
+    renderEntryRoot?: string;
+}
+/**
+ * Import a Remotion toolchain module (@remotion/bundler, @remotion/renderer)
+ * from the `renderEntryRoot` that OWNS it — not from this harness's own context.
+ * render-harness deliberately does not depend on @remotion/* (see the d.ts
+ * header); the local render environment (the render-entry package) provides them, so
+ * a bare `import('@remotion/bundler')` resolves against render-harness and fails
+ * with ERR_MODULE_NOT_FOUND. Anchoring to renderEntryRoot (the same root used for
+ * the webpack alias) keeps the harness self-contained on one render root.
+ */
+export declare function importFromRenderEntry<T>(renderEntryRoot: string, spec: string): Promise<T>;
+/**
+ * Resolve the @cueframe/render-entry package root that OWNS the Remotion
+ * toolchain + the composition sources + the webpack shim: explicit override →
+ * RENDER_ENTRY_ROOT → the sibling `render-entry` package derived from this
+ * file's path (src/ → render-harness → packages/execution → render-entry).
+ * Shared by the component render (prepareLocalBundle) and the card render
+ * (cardRender.ts) so both anchor to one root.
+ */
+export declare function resolveRenderEntryRoot(override?: string): string;
+/**
+ * Render an owned `.cueframe` component to a still PNG via the LOCAL Remotion
+ * bundle. Requires an installed Chrome via REMOTION_CHROME_EXECUTABLE (the
+ * chrome-headless-shell auto-download hangs).
+ */
+export declare function renderComponentStill(opts: RenderComponentStillOpts): Promise<{
+    pngPath: string;
+}>;
+/** Alpha codec for the bake. ProRes 4444 = pixel-identical alpha (heavier);
+ *  VP9 = ~75× smaller, near-identical (spike-alpha q_compare.png). */
+export type AlphaCodec = 'prores' | 'vp9';
+/**
+ * Pure (Chrome-free, unit-testable) renderMedia config for an alpha bake, from
+ * the proven spike-alpha settings: ProRes 4444 → `yuva444p10le`; VP9 → `yuva420p`.
+ * `imageFormat:'png'` carries the alpha channel out of Chromium in both.
+ */
+export declare function alphaRenderConfig(codec: AlphaCodec): {
+    codec: AlphaCodec;
+    pixelFormat: 'yuva444p10le' | 'yuva420p';
+    imageFormat: 'png';
+    proResProfile?: '4444';
+};
+/** File extension for a baked alpha video by codec. */
+export declare function alphaExt(codec: AlphaCodec): 'mov' | 'webm';
+export interface RenderComponentAlphaOpts {
+    ws: Workspace;
+    /** The component's flat-string primitiveId (matches its config.ts `id`). */
+    id: string;
+    /** Params spread into the resolved component (forwarded via Remotion inputProps). */
+    params: Record<string, unknown>;
+    /** Alpha codec. Default 'prores' (pixel-identical); 'vp9' for a small file. */
+    codec?: AlphaCodec;
+    width?: number;
+    height?: number;
+    fps?: number;
+    /** Clip length in frames. Default fps×3 (a 3s alpha clip). */
+    durationInFrames?: number;
+    renderEntryRoot?: string;
+}
+/**
+ * Bake an owned `.cueframe` component to an ALPHA (transparent) video via the
+ * LOCAL Remotion bundle — the "trusted pixels" a cloud render later composites
+ * (Task 2.6b) WITHOUT running the component's code in the shared render. Mirrors
+ * the proven cueframe/scripts/spike-alpha renderMedia settings. Requires an
+ * installed Chrome via REMOTION_CHROME_EXECUTABLE. Output → the `.cueframe/` cache
+ * (an R2-upload step for the cloud path is the 2.6b follow-up).
+ */
+export declare function renderComponentAlpha(opts: RenderComponentAlphaOpts): Promise<{
+    videoPath: string;
+}>;
+//# sourceMappingURL=localRender.d.ts.map

package/dist/_members/render-harness/localRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localRender.d.ts","sourceRoot":"","sources":["../src/localRender.ts"],"names":[],"mappings":"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"}

package/dist/_members/render-harness/materializeSources.d.ts

@@ -0,0 +1,29 @@
+/**
+ * materializeSources — make a RenderInput's REMOTE assets fast-seekable / locally
+ * reachable for a renderer in a no-egress-to-R2 sandbox or any harness
+ * that streams from URLs. Remotion's OffthreadVideo range-reads, so a deep seek
+ * into a large remote source walks keyframes per frame and times out; and a
+ * historical Daytona free-tier sandbox could not reach R2 at all (that lane is
+ * gone; Modal keeps this for the faststart/206 guarantees). This stages EVERY external
+ * ref the RenderInput carries (enumerated once by renderInputAssets) onto a
+ * local loopback server, then asserts none stayed remote:
+ *
+ *   • source (clips[].src) — TRIM to the clip window with `ffmpeg -c copy`
+ *     (extractSegments) so the seek is shallow; the source is the multi-GB raw.
+ *   • matte / trajectory / audio / overlay assets — DOWNLOAD whole (small, and
+ *     the matte's frame-packed timeline must not be re-timed) and serve locally.
+ *
+ * It is a NO-OP when nothing is remote (a backend that pre-materialises to a
+ * Volume, or already-local desktop sources). The single enumeration +
+ * `assertNoRemoteRefs` guarantee a forgotten ref class becomes a loud failure,
+ * not a sandbox that silently hangs fetching something it can't reach.
+ */
+import type { RenderInput } from '../core/render/index.js';
+export interface MaterializeResult {
+    /** The same RenderInput, with remote URLs rewritten to the loopback server. */
+    renderInput: RenderInput;
+    /** Stop the media server + clean up extracted segments. Call after rendering. */
+    close: () => Promise<void>;
+}
+export declare function materializeSources(renderInput: RenderInput, workDir: string, log?: (m: string) => void): Promise<MaterializeResult>;
+//# sourceMappingURL=materializeSources.d.ts.map

package/dist/_members/render-harness/materializeSources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materializeSources.d.ts","sourceRoot":"","sources":["../src/materializeSources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAkBH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,WAAW,EAAE,WAAW,CAAC;IACzB,iFAAiF;IACjF,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAwCD,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAe,GAClC,OAAO,CAAC,iBAAiB,CAAC,CAuJ5B"}

package/dist/_members/render-harness/mediaServer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Local HTTP server with range request support.
+ * Serves files from a directory — Remotion needs HTTP URLs with range
+ * support for OffthreadVideo frame seeking.
+ *
+ * Private cloud render-harness module (no desktop/OSS consumers).
+ */
+export interface MediaServer {
+    /** Base URL, e.g., http://localhost:PORT */
+    baseUrl: string;
+    /** Stop the server and free the port */
+    close: () => void;
+}
+/**
+ * Start a local HTTP server serving files from a directory.
+ * Supports range requests (required for Remotion OffthreadVideo).
+ *
+ * @param directory - directory to serve files from
+ * @returns server with baseUrl and close function
+ */
+export declare function startMediaServer(directory: string): MediaServer;
+//# sourceMappingURL=mediaServer.d.ts.map

package/dist/_members/render-harness/mediaServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaServer.d.ts","sourceRoot":"","sources":["../src/mediaServer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,WAAW,WAAW;IAC1B,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAsBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAuD/D"}

package/dist/_members/render-harness/renderInputAssets.d.ts

@@ -0,0 +1,63 @@
+/**
+ * renderInputAssets — the single reader over a RenderInput's EXTERNAL asset
+ * references. This is the one place that knows "what files does a render
+ * environment depend on," so the resolve side (director, presign/mirror) and
+ * the localize side (sandbox `materializeSources`) can't drift apart — the bug
+ * that let the eval capture silently render without co-view mattes / crop
+ * trajectories.
+ *
+ * The RenderInput IS the manifest: every external dependency already lives on
+ * it as a URL field. This module just enumerates those fields by role, so a new
+ * ref class is added in exactly ONE place (the slot walker below) and every
+ * consumer — staging + the no-remote-ref invariant — picks it up automatically.
+ *
+ * Roles (every remote URL a RenderInput can carry):
+ *   source       clips[].src               scene + b-roll video/audio/image
+ *   matte        clips[].packedUrl         frame-packed co-view (captions-behind-speaker)
+ *   trajectory   clips[].cropTrajectoryUrl per-frame crop JSON
+ *   audio        audioTracks[].src         music / ambient beds
+ *   overlayAsset overlays[].params.src     image / gif / lottie overlay media
+ *
+ * OSS + RenderInput-side on purpose: `materializeSources` (which runs INSIDE the
+ * render sandbox with no creds) imports this. The director-side resolver that
+ * needs R2/S3 creds lives privately (lib/render-env) and never imports back.
+ */
+import type { RenderInput } from '../core/render/index.js';
+export type AssetRole = 'source' | 'matte' | 'trajectory' | 'audio' | 'overlayAsset' | 'font' | 'brandMedia';
+export interface AssetRef {
+    role: AssetRole;
+    /** The (remote) URL the RenderInput currently points at. */
+    url: string;
+    /** Deterministic, collision-free local filename to stage this ref under. */
+    filename: string;
+}
+/** A remote URL is http(s) and not already the local loopback media server. */
+export declare function isRemoteUrl(u: unknown): u is string;
+/** Identity of a URL ignoring the (volatile) query string — presign/mirror tokens. */
+export declare function assetUrlKey(url: string): string;
+/**
+ * A single mutable accessor onto one external-ref field of a RenderInput.
+ * The ONE definition of every external-ref location — read AND write — so
+ * enumeration, the invariant, and the rewrite all walk the identical set.
+ */
+export interface AssetSlot {
+    role: AssetRole;
+    get(): string | undefined;
+    set(url: string): void;
+}
+/** Yield a slot for every external-ref-bearing field on the RenderInput. */
+export declare function assetSlots(input: RenderInput): Generator<AssetSlot>;
+/**
+ * Every UNIQUE remote asset the RenderInput references, deduped by URL (the same
+ * source can back many clips). This is what a stager localizes — fetch each
+ * once, then rewrite all slots pointing at it (see `assetSlots`).
+ */
+export declare function renderInputAssets(input: RenderInput): AssetRef[];
+/**
+ * Post-staging guard: throw if ANY external ref still points at a remote URL.
+ * Makes a forgotten ref class a loud failure instead of a sandbox that silently
+ * hangs fetching something it can't reach (e.g. R2 from a free-tier
+ * sandbox). Call after a stager rewrites every ref to the local loopback.
+ */
+export declare function assertNoRemoteRefs(input: RenderInput): void;
+//# sourceMappingURL=renderInputAssets.d.ts.map

package/dist/_members/render-harness/renderInputAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderInputAssets.d.ts","sourceRoot":"","sources":["../src/renderInputAssets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,OAAO,GACP,YAAY,GACZ,OAAO,GACP,cAAc,GACd,MAAM,GACN,YAAY,CAAC;AAEjB,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,SAAS,CAAC;IAChB,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAMnD;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,IAAI,MAAM,GAAG,SAAS,CAAC;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,4EAA4E;AAC5E,wBAAiB,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,CAAC,SAAS,CAAC,CAgDpE;AAuBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,EAAE,CAYhE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAa3D"}

package/dist/_members/render-harness/resolveAssets.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Scan RenderInput for remote asset URLs, download them locally,
+ * and return a URL mapping table for replacement.
+ *
+ * Handles: overlay images, GIFs, Lottie JSON, audio tracks,
+ * brand kit assets (logos, fonts, intro/outro videos).
+ *
+ * Private cloud render-harness module — used only by materializeSources for the
+ * Modal render sandbox (no desktop/OSS consumers).
+ */
+import type { RenderInput } from '../core/render/index.js';
+export interface AssetMap {
+    /** Original URL → local HTTP URL */
+    urlMap: Record<string, string>;
+    /** Number of assets downloaded */
+    count: number;
+}
+type DownloadFn = (url: string, destPath: string) => Promise<void>;
+/**
+ * Scan a RenderInput for all remote asset URLs, download each to tempDir,
+ * and return a mapping from original URL → local media server URL.
+ *
+ * The caller should replace all URLs in the RenderInput using the map
+ * before passing to render.mjs.
+ *
+ * @param renderInput - the composition to scan
+ * @param tempDir - directory to download assets into
+ * @param mediaServerUrl - base URL of the local media server
+ * @param download - function to download a URL to a local path
+ */
+export declare function resolveAssets(renderInput: RenderInput, tempDir: string, mediaServerUrl: string, download: DownloadFn): Promise<AssetMap>;
+export {};
+//# sourceMappingURL=resolveAssets.d.ts.map

package/dist/_members/render-harness/resolveAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveAssets.d.ts","sourceRoot":"","sources":["../src/resolveAssets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,MAAM,WAAW,QAAQ;IACvB,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,UAAU,GACnB,OAAO,CAAC,QAAQ,CAAC,CAyDnB"}

package/dist/_members/render-harness/sandboxGlobalSpecs.d.ts

@@ -0,0 +1,23 @@
+/** Sentinel: the export lives in `sandbox-globals.ts` itself (the wrappers). */
+export declare const GLOBALS_MODULE = "@@sandbox-globals@@";
+/** One global endowment's resolution spec: which module + which export. */
+export interface SandboxGlobalSpec {
+    /** Module specifier to resolve the value from (or GLOBALS_MODULE sentinel). */
+    readonly module: string;
+    /** Export name to pull; `'default'` = the module's default export. */
+    readonly exportName: string;
+}
+/**
+ * name -> resolution spec for every Remotion sandbox global EXCEPT:
+ *   - `console` (desktop-sandbox-only; the box keeps real Node console), and
+ *   - the `@cueframe/animate` `sandboxScope` keys, which are DYNAMIC (a full set
+ *     on the desktop / pro build, empty on the OSS/box stub). Those are spread from
+ *     the resolved `@cueframe/animate` module at build time by each consumer, so
+ *     they can't be a static list here. `ANIMATE_MODULE` records the source.
+ */
+export declare const SANDBOX_GLOBAL_SPECS: Readonly<Record<string, SandboxGlobalSpec>>;
+/** Module the `@cueframe/animate` `sandboxScope` keys are spread from. */
+export declare const ANIMATE_MODULE = "@cueframe/animate";
+/** The static endowment names (everything except console + the animate spread). */
+export declare const SANDBOX_GLOBAL_NAMES: readonly string[];
+//# sourceMappingURL=sandboxGlobalSpecs.d.ts.map

package/dist/_members/render-harness/sandboxGlobalSpecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxGlobalSpecs.d.ts","sourceRoot":"","sources":["../src/sandboxGlobalSpecs.ts"],"names":[],"mappings":"AAuCA,gFAAgF;AAChF,eAAO,MAAM,cAAc,wBAAwB,CAAC;AAEpD,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAmE5E,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,cAAc,sBAAsB,CAAC;AAElD,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAsC,CAAC"}

package/dist/account-model/testing.d.ts

@@ -0,0 +1 @@
+export * from "../_members/account-model/testing/index.js";