@cueframe/kernel 0.2.2 → 0.2.4

package/dist/_members/animate/three/toneMapping.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Tone mapping that belongs to the material instead of to the bound framebuffer.
+ *
+ * ## Why this exists
+ *
+ * Three applies `renderer.toneMapping` to a lit material only when the frame is going straight to
+ * the canvas. `WebGLPrograms.js` (165-176) and `WebGLRenderer.js` (2284-2292) both compute the
+ * program's tone mapping the same way:
+ *
+ * ```js
+ * let toneMapping = NoToneMapping;
+ * if ( material.toneMapped ) {
+ *   if ( currentRenderTarget === null || currentRenderTarget.isXRRenderTarget === true ) {
+ *     toneMapping = renderer.toneMapping;
+ *   }
+ * }
+ * ```
+ *
+ * and `WebGLProgram.js` (767-769) turns a `NoToneMapping` decision into *nothing at all*: no
+ * `#define TONE_MAPPING`, no `tonemapping_pars_fragment`, no `toneMapping()` function. The
+ * `#include <tonemapping_fragment>` that every lit ShaderLib entry carries then expands to a
+ * `#if defined( TONE_MAPPING )` with nothing inside it, and the material writes scene-referred
+ * radiance to the target unchanged.
+ *
+ * That is the right default for an *intermediate* target — an environment map or a G-buffer must
+ * stay scene-referred — but a scene shot's world target is not an intermediate. It stands in for
+ * the canvas: the whole frame is rasterized into it, blurred in it and encoded out of it once. So
+ * the shot lost the ACES roll-off the moment every shot began drawing through the focus pass, and
+ * a lit body that used to roll off into white clipped there instead.
+ *
+ * The fix is to move the decision from the framebuffer to the material. A material that carries
+ * these props tone-maps in its own fragment shader, at exactly the place three would have done it
+ * (the `<tonemapping_fragment>` site, after `<opaque_fragment>` and before `<colorspace_fragment>`),
+ * with three's own chunk and three's own function — and it does so whatever target is bound, so a
+ * device body looks the same drawn to the canvas by `device-showcase` and drawn into the focus
+ * pass's half-float target by a scene shot.
+ *
+ * `isXRRenderTarget` is deliberately NOT set on the pass's target. It is the flag that tells the
+ * renderer a target holds a *display* surface, and it changes the output colour space of the whole
+ * draw as well as the tone mapping (`WebGLRenderer.js:2275`). Borrowing it to mean "tone-map this"
+ * would be a lie about what the target is, and it would take the encoding with it.
+ *
+ * ## Why `toneMapped: false` is part of the same statement
+ *
+ * With the injection in place, `toneMapped: true` would make the canvas case apply the curve
+ * twice — three's prefix would declare `toneMappingExposure`, `ACESFilmicToneMapping` and
+ * `toneMapping()` a second time, which does not even compile. Setting `toneMapped: false` is what
+ * takes three's own gate out of the picture: the renderer's answer is `NoToneMapping` for every
+ * target, including none, and this module's injection is the single application. It is not a
+ * claim that the material is unlit — the unlit materials in this renderer (screenshots, world
+ * text, the black screen stand-in) carry `toneMapped: false` *and no injection*, which is what
+ * keeps them exact.
+ *
+ * ## Exposure, and where the curve comes from
+ *
+ * Neither is restated here. The function is chosen from `renderer.toneMapping`, which three hands
+ * to `onBeforeCompile` as its second argument — react-three-fiber sets it to `ACESFilmicToneMapping`
+ * when `flat` is false, which is the default and what every canvas in this package uses, so the
+ * ACES filmic path is what gets defined without this module naming it as a default anywhere. And
+ * `toneMappingExposure` is declared by three's own pars chunk, which means the renderer's
+ * `p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure )`
+ * (`WebGLRenderer.js:2617`) finds it and uploads the renderer's own exposure — a uniform three
+ * sets on every material refresh, and a no-op on a program that has no such uniform.
+ */
+/** The renderer surface the injection reads. Three passes the whole renderer; this is the slice. */
+export interface ToneMappingRenderer {
+    toneMapping: number;
+}
+/** The shader object three passes to `onBeforeCompile`; only the fragment source is rewritten. */
+export interface ToneMappingShader {
+    fragmentShader: string;
+}
+/**
+ * The GLSL a self-tone-mapping material prepends to its fragment shader for `toneMapping`: the
+ * define, three's own pars chunk, and the one-line `toneMapping()` three's prefix would have
+ * written. Empty when the renderer tone-maps with nothing, which is then an exact identity.
+ *
+ * It goes before the shader body rather than at the `<tonemapping_fragment>` site because the
+ * chunk declares a uniform and a handful of functions, and that site is inside `main()`. This is
+ * where three puts it too (its prefix precedes the body), and `<common>` guards its own
+ * `saturate` against the one this chunk defines.
+ */
+export declare function toneMappingPreamble(toneMapping: number): string;
+/**
+ * The `onBeforeCompile` a lit material carries. Three calls it once per program, with the renderer
+ * as the second argument, which is the only reason this needs no configuration of its own.
+ */
+export declare function toneMapInTheMaterial(shader: ToneMappingShader, renderer: ToneMappingRenderer): void;
+/**
+ * Spread into every lit material this package draws. The pair is one statement and neither half
+ * is meaningful alone: the injection applies the curve, and `toneMapped: false` stops three
+ * applying it a second time when the frame happens to be going to the canvas.
+ */
+export declare const SELF_TONE_MAPPED: {
+    readonly toneMapped: false;
+    readonly onBeforeCompile: typeof toneMapInTheMaterial;
+};
+/**
+ * Spread into every unlit, colour-managed material this package draws: a screenshot on a device's
+ * screen, a page, a rasterized world-text run.
+ *
+ * It is `SELF_TONE_MAPPED` minus the injection, and that is the whole difference between them —
+ * both switch three's own gate off, and only one puts a curve back. The contract calls these
+ * surfaces exact: what the author supplied is what the frame shows, whatever the renderer's tone
+ * mapping is set to and whatever target is bound. Every unlit material in this package spreads
+ * this constant and none of them spells `toneMapped` by hand — `DeviceMesh`'s two screen
+ * materials, `scene/UnlitPlane.tsx` and `media/MediaTileScene.tsx` — and the tone-mapping test
+ * walks the package's sources to enforce exactly that, so the rule cannot drift back into a
+ * per-file literal.
+ */
+export declare const UNLIT_COLOUR_MANAGED: {
+    readonly toneMapped: false;
+};

package/dist/_members/animate/three/useImageTexture.d.ts

@@ -0,0 +1,17 @@
+import { Texture } from 'three';
+/**
+ * Loads an image as a Three texture under `delayRender` so the frame waits for it.
+ *
+ * `src` may change between renders: each `src` gets its own `delayRender` handle, and a handle
+ * is always cleared before the next one is taken, so no handle outlives the load it belongs to.
+ * Passing `null` loads nothing and clears any handle still outstanding.
+ *
+ * A texture the hook has returned is disposed only by the commit that stops returning it — the
+ * layout effect after `src` changes or the source goes away — never when its replacement finishes
+ * loading, since the material keeps drawing the old one until React commits the new one. Unmount
+ * disposes whatever was last returned. The policy is `textureLifecycle.ts`, tested on its own.
+ *
+ * State here is load state, not animation state — every frame after the load is identical, so
+ * the hook stays a pure function of `src` from the renderer's point of view.
+ */
+export declare function useImageTexture(src: string | null): Texture | null;

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

@@ -23,3 +23,5 @@ export { type PlanStep, formatPlanSteps, buildExecutionTask, buildPlannerUserMes
 export { PipelineTrace as RequestTrace } from './pipelineTrace.js';
 export { generateMotionShell, MOTION_PRESETS, resolveMotionPresetCard, MotionPresetError, materializeMotionPresetOpsCore, isMotionPresetOp, hasMotionPresetOp } from './motion/index.js';
 export type { MotionPresetName, MotionShellOptions, MotionPresetErrorCode, ApplyMotionPresetOp, MaterializedMotionShell, MaterializeMotionPresetDeps } from './motion/index.js';
+export { SceneAuthoringError, collectSceneClipIssues, hasSceneOp, isSceneOp, isSceneShotClip, generateSceneShotWrapper, materializeSceneOpsCore, } from './scene/index.js';
+export type { SceneAddOp, SceneUpdateOp, SceneAuthoringContext, SceneClipIssue, SceneSourceDeclaration, SceneSourceResolver, SceneShotWrapperManifest, MaterializeSceneOpsDeps, RegisteredSceneSource, SceneSourceRegistration, } from './scene/index.js';

package/dist/_members/authoring/scene/index.d.ts

@@ -0,0 +1,6 @@
+export { SceneAuthoringError, SCENE_TRANSITION_KINDS, collectSceneClipIssues, hasSceneOp, isSceneOp, isSceneShotClip, isSceneShotSource, offFrameLattice, readSceneSourceRef, sceneClipShapeIssues, sceneTrackIdFor, validateSceneAdd, validateSceneUpdate, } from './validate.js';
+export type { SceneAddOp, SceneAuthoringContext, SceneAuthoringErrorCode, SceneClipIssue, SceneOp, SceneShotClip, SceneSourceDeclaration, SceneSourceResolver, SceneUpdateOp, ValidatedSceneAdd, ValidatedSceneUpdate, } from './validate.js';
+export { SCENE_IMAGE_MIME_TYPES, SCENE_SHOT_WRAPPER_SOURCE, SCENE_SHOT_WRAPPER_VERSION, generateSceneShotWrapper, sceneShotAlphaPolicy, sceneShotManifest, } from './wrapper.js';
+export type { SceneShotWrapper, SceneShotWrapperManifest } from './wrapper.js';
+export { SCENE_TRACK_NAME, materializeSceneOpsCore } from './materialize.js';
+export type { MaterializeSceneOpsDeps, RegisteredSceneSource, SceneSourceRegistration } from './materialize.js';

package/dist/_members/authoring/scene/materialize.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Turns `scene.add` / `scene.update` requests into ordinary clip operations, mirroring
+ * `materializeMotionPresetOpsCore`: the host supplies a source-registration sink over its
+ * component store, ops fold in order so an update may target a scene added earlier in the
+ * same batch, and the emitted ops carry `props.componentRef`, `props.scene` and the slot
+ * bindings on the clip.
+ *
+ * Staging versus publishing is the host's: the sink stages an immutable source and returns
+ * its identity; the host commits staged sources only after the whole batch validates and
+ * the composition compare-and-swap succeeds, and leaves failed staged records unreferenced.
+ */
+import type { Composition } from '../../composition/validators/index.js';
+import type { SceneShotSpecV2 } from '../../composition/scene/index.js';
+import { type SceneAuthoringContext } from './validate.js';
+import { type SceneShotWrapperManifest } from './wrapper.js';
+export interface SceneSourceRegistration {
+    /** Index of the request op in the batch. */
+    opIndex: number;
+    clipId: string;
+    /** Present on an update: the component the clip already pins; register the new version under it. */
+    componentId?: string;
+    tsxSource: string;
+    manifest: SceneShotWrapperManifest;
+    scene: SceneShotSpecV2;
+    assets: Record<string, string>;
+    /** Frame rate of the composition at this op; `durationInFrames` was quantized with it. */
+    fps: number;
+    durationInFrames: number;
+}
+export interface RegisteredSceneSource {
+    componentId: string;
+    sourceVersionId: string;
+}
+export interface MaterializeSceneOpsDeps extends Omit<SceneAuthoringContext, 'fps'> {
+    /**
+     * Composition frame rate, or a reader over the folded composition so a `setFormat` earlier
+     * in the batch is honoured by the ops after it.
+     */
+    fps: number | ((composition: Composition) => number);
+    /** Stage an immutable wrapper source and return its pinned identity. */
+    sink: (registration: SceneSourceRegistration) => Promise<RegisteredSceneSource> | RegisteredSceneSource;
+    /** Fold one already-materialized op into an in-memory composition (batch-order semantics). */
+    apply: (composition: Composition, op: unknown) => Composition;
+}
+/** Name given to a minted dedicated track. */
+export declare const SCENE_TRACK_NAME = "Scene shots";
+export declare function materializeSceneOpsCore(composition: Composition, ops: readonly unknown[], deps: MaterializeSceneOpsDeps): Promise<unknown[]>;

package/dist/_members/authoring/scene/validate.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Scene-shot authoring validation for the `scene.add` / `scene.update` requests (spec
+ * §"Authoring, persistence, and discovery", §"Timeline and transitions"). No host imports: the
+ * caller supplies the frame rate, a source resolver over its component store, and optionally the
+ * media kinds it knows.
+ *
+ * The clip-shape rules themselves live in `@cueframe/composition/scene` (`clipRules.ts`), because
+ * they are properties of the persisted contract and the render path enforces the very same rules
+ * before it seals a render input. They are re-exported here unchanged, so this module's public
+ * surface is what it always was; this file adds only the request shapes on top of them.
+ */
+import { type SceneClipIssueCode, type SceneClipRuleContext, type SceneShotClip, type SceneShotSpecV2, type SceneSourceDeclaration } from '../../composition/scene/index.js';
+import type { Composition, Transition } from '../../composition/validators/index.js';
+export { SCENE_TRANSITION_KINDS, collectSceneClipIssues, isSceneShotClip, isSceneShotSource, offFrameLattice, readSceneSourceRef, sceneClipShapeIssues, } from '../../composition/scene/index.js';
+export type { SceneClipIssue, SceneShotClip, SceneSourceDeclaration, SceneSourceResolver, } from '../../composition/scene/index.js';
+/** The authoring context is the clip rules' context; nothing extra is needed to validate a request. */
+export type SceneAuthoringContext = SceneClipRuleContext;
+export type SceneAuthoringErrorCode = SceneClipIssueCode;
+/** One rejection: a path into the request (or clip) and an actionable message. */
+export declare class SceneAuthoringError extends Error {
+    readonly code: SceneAuthoringErrorCode;
+    readonly path: string;
+    readonly clipId: string | undefined;
+    opIndex: number | undefined;
+    constructor(code: SceneAuthoringErrorCode, path: string, detail: string, options?: {
+        clipId?: string;
+        opIndex?: number;
+        op?: string;
+    });
+}
+export interface SceneAddOp {
+    type: 'scene.add';
+    clipId: string;
+    trackId?: string;
+    newTrack?: boolean;
+    newTrackId?: string;
+    startTime: number;
+    duration: number;
+    transitionIn?: Transition;
+    scene: SceneShotSpecV2;
+    assets: Record<string, string>;
+}
+export interface SceneUpdateOp {
+    type: 'scene.update';
+    clipId: string;
+    startTime?: number;
+    duration?: number;
+    transitionIn?: Transition;
+    scene?: SceneShotSpecV2;
+    assets?: Record<string, string>;
+}
+export type SceneOp = SceneAddOp | SceneUpdateOp;
+export declare const isSceneOp: (op: unknown) => op is SceneOp;
+export declare const hasSceneOp: (ops: readonly unknown[]) => boolean;
+export interface ValidatedSceneAdd {
+    spec: SceneShotSpecV2;
+    slots: string[];
+    track: {
+        id: string;
+        create: boolean;
+    };
+    /** The clip as it will be persisted, minus the source pin the host supplies. */
+    clip: SceneShotClip;
+}
+/** The minted id for a requested dedicated track. */
+export declare function sceneTrackIdFor(clipId: string): string;
+export declare function validateSceneAdd(op: SceneAddOp, composition: Composition, ctx: SceneAuthoringContext): ValidatedSceneAdd;
+export interface ValidatedSceneUpdate {
+    spec: SceneShotSpecV2;
+    slots: string[];
+    trackId: string;
+    componentId: string;
+    currentSourceVersionId: string;
+    currentDeclaration: SceneSourceDeclaration;
+    /** The merged clip as it will be persisted, still pinned to the current source. */
+    clip: SceneShotClip;
+    /** Which ordinary timing fields the request touched. */
+    timing: Pick<SceneUpdateOp, 'startTime' | 'duration' | 'transitionIn'>;
+}
+export declare function validateSceneUpdate(op: SceneUpdateOp, composition: Composition, ctx: SceneAuthoringContext): ValidatedSceneUpdate;

package/dist/_members/authoring/scene/wrapper.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The immutable scene-shot wrapper: one small TSX module plus a manifest generated from the
+ * referenced image slots (spec §"Assets and production admission").
+ *
+ * The module text is constant. The scene stays in `props.scene`, so changing scene values
+ * never changes the source identity; only a change to the referenced slot set (or the alpha
+ * policy the backdrop implies) regenerates the manifest, and with it the source identity,
+ * atomically. Hosts register `{ tsxSource, manifest }` through their existing component store.
+ */
+import { type SceneShotSpecV2 } from '../../composition/scene/index.js';
+export declare const SCENE_SHOT_WRAPPER_VERSION: 2;
+/** Scene image slots admit exactly these formats (verified MIME and decoded dimensions). */
+export declare const SCENE_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
+export declare const SCENE_VIDEO_MIME_TYPES: readonly ["video/mp4", "video/webm"];
+/** Structurally a `ComponentManifestV2`; the host parses it with that contract before registering. */
+export interface SceneShotWrapperManifest {
+    version: 2;
+    assets: Record<string, {
+        kind: 'image' | 'video';
+        required: true;
+        mimeTypes: string[];
+    }>;
+    graphics: {
+        api: 'webgl';
+        required: true;
+        accelerationPreference: 'hardware-preferred';
+    };
+    alphaPolicy: 'requires-transparency' | 'allows-opaque';
+    sceneShot: {
+        version: typeof SCENE_SHOT_WRAPPER_VERSION;
+    };
+}
+export interface SceneShotWrapper {
+    tsxSource: string;
+    manifest: SceneShotWrapperManifest;
+}
+export declare const SCENE_SHOT_WRAPPER_SOURCE: string;
+export declare function sceneShotAlphaPolicy(spec: Pick<SceneShotSpecV2, 'backdrop'>): SceneShotWrapperManifest['alphaPolicy'];
+/** The manifest for a slot set: one required image declaration per slot, ordered by name. */
+export declare function sceneShotManifest(slots: readonly string[], alphaPolicy: SceneShotWrapperManifest['alphaPolicy'], videoSlots?: readonly string[]): SceneShotWrapperManifest;
+export declare function generateSceneShotWrapper(spec: Pick<SceneShotSpecV2, 'layers' | 'backdrop'>): SceneShotWrapper;

package/dist/_members/component-runtime/allowedImports.d.ts

@@ -0,0 +1,3 @@
+/** Public component imports shared by admission and desktop dependency staging. */
+export declare const COMPONENT_IMPORT_ALLOWLIST: readonly ["react", "react/jsx-runtime", "remotion", "@remotion/media", "@remotion/layout-utils", "@remotion/transitions", "@remotion/motion-blur", "@remotion/noise", "@remotion/paths", "@remotion/shapes", "@remotion/three", "three", "three/webgpu", "three/tsl", "@react-three/fiber", "@cueframe/animate", "gsap"];
+//# sourceMappingURL=allowedImports.d.ts.map

package/dist/_members/component-runtime/allowedImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowedImports.d.ts","sourceRoot":"","sources":["../src/allowedImports.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,eAAO,MAAM,0BAA0B,0TAkB5B,CAAC"}

package/dist/_members/component-runtime/bake.d.ts

@@ -1,4 +1,5 @@
 import { type ComponentBakeRequestV2 as BakeRequest, type ComponentBakeJobV2 as BakeJob, type ComponentRenderReceiptV2 as RenderReceipt } from './contracts.js';
+import { type ComponentRenderTiming } from './render.js';
 export declare function assertAssetBindingsMatch(request: Pick<BakeRequest, 'source' | 'assets'>): void;
 export declare function bakeComponentAlphaV2(options: {
     job: BakeJob;
@@ -7,6 +8,13 @@ export declare function bakeComponentAlphaV2(options: {
     renderEntryRoot?: string;
     ffprobeExecutable?: string;
     ffmpegExecutable?: string;
+    concurrency?: number;
+    onProgress?: (progress: {
+        renderedFrames: number;
+        encodedFrames: number;
+        totalFrames: number;
+    }) => void;
+    onTiming?: (timing: ComponentRenderTiming) => void;
 }): Promise<RenderReceipt>;
 export declare function sourceIdentityForBake(request: BakeRequest): string;
 //# sourceMappingURL=bake.d.ts.map

package/dist/_members/component-runtime/bake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bake.d.ts","sourceRoot":"","sources":["../src/bake.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,sBAAsB,IAAI,WAAW,EAC1C,KAAK,kBAAkB,IAAI,OAAO,EAClC,KAAK,wBAAwB,IAAI,aAAa,EAC/C,MAAM,gBAAgB,CAAC;AAaxB,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAC9C,IAAI,CAkCN;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,GAAG,EAAE,OAAO,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,OAAO,CAAC,aAAa,CAAC,CAiFzB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAElE"}
+{"version":3,"file":"bake.d.ts","sourceRoot":"","sources":["../src/bake.ts"],"names":[],"mappings":"AAEA,OAAO,EAQL,KAAK,sBAAsB,IAAI,WAAW,EAC1C,KAAK,kBAAkB,IAAI,OAAO,EAClC,KAAK,wBAAwB,IAAI,aAAa,EAC/C,MAAM,gBAAgB,CAAC;AAUxB,OAAO,EAAwB,KAAK,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAK/E,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAC9C,IAAI,CAkCN;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,GAAG,EAAE,OAAO,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACxG,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACpD,GAAG,OAAO,CAAC,aAAa,CAAC,CAoGzB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAElE"}

package/dist/_members/component-runtime/browserFirewall.d.ts

@@ -14,8 +14,14 @@ type FirewallBrowser = {
         silent: boolean;
     }): Promise<void>;
 };
-export declare function installComponentRequestFirewall(browser: FirewallBrowser, allowedAssetOrigins: ReadonlySet<string>): Promise<{
+export declare function installComponentRequestFirewall(browser: FirewallBrowser, allowedAssetOrigins: ReadonlySet<string>, onDiagnostic?: (entry: {
+    type: 'request-failed' | 'page-error';
+    url?: string;
+    message: string;
+}) => void): Promise<{
     deniedRequests(): readonly string[];
+    fatalError(): unknown | null;
+    close(): Promise<void>;
 }>;
 export {};
 //# sourceMappingURL=browserFirewall.d.ts.map

package/dist/_members/component-runtime/browserFirewall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browserFirewall.d.ts","sourceRoot":"","sources":["../src/browserFirewall.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAMD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GAAG,IAAI,EAC7B,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,GACvC,yBAAyB,CAoB3B;AAcD,eAAO,MAAM,uBAAuB,iUAAgB,CAAC;AAErD,KAAK,eAAe,GAAG;IACrB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1D,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1D,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD,CAAC;AAEF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,eAAe,EACxB,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,GACvC,OAAO,CAAC;IAAE,cAAc,IAAI,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAwClD"}
+{"version":3,"file":"browserFirewall.d.ts","sourceRoot":"","sources":["../src/browserFirewall.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAMD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GAAG,IAAI,EAC7B,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,GACvC,yBAAyB,CAoB3B;AAcD,eAAO,MAAM,uBAAuB,iUAAgB,CAAC;AAErD,KAAK,eAAe,GAAG;IACrB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1D,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1D,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD,CAAC;AAEF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,eAAe,EACxB,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,EACxC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,GACvG,OAAO,CAAC;IACT,cAAc,IAAI,SAAS,MAAM,EAAE,CAAC;IACpC,UAAU,IAAI,OAAO,GAAG,IAAI,CAAC;IAC7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC,CA6DD"}

package/dist/_members/component-runtime/browserOptions.d.ts

@@ -2,7 +2,63 @@
  * Backend admission is performed separately and fails closed when a requested
  * API is unavailable; this option is never interpreted as a fallback signal.
  */
-export declare const COMPONENT_CHROMIUM_OPTIONS: Readonly<{
-    gl: "swangle";
-}>;
+import { ComponentHostAttestationV2, type ComponentGraphicsRequirementV2, type ComponentRendererConfigV2, type SceneShotCapabilityV2 } from './contracts.js';
+import { type CdpBrowserConnection } from './webglProbe.js';
+/**
+ * The browser BINARY this lane opens, plus the backend policy for it.
+ *
+ * `browserExecutable` is REQUIRED, and is always `verifyStagedBrowser`'s verified path
+ * (`prepareLocalBundle` in ./render.ts). It used to be optional, and an absent one was handed to
+ * Remotion as `undefined` — which Remotion documents as "download a browser automatically". A
+ * preview drawn by a browser nobody staged and nobody verified is a preview of nothing the export
+ * lane will reproduce, so the optional arm is gone and the type says so.
+ *
+ * Callers that want only the backend — the identity in `resolvedComponentRenderer`, and the tests
+ * that pin the per-platform policy — ask `componentBrowserBackend` instead of passing a fake path.
+ */
+export declare function componentBrowserOptions(graphics: ComponentGraphicsRequirementV2, browserExecutable: string, chromeMode: 'headless-shell' | 'chrome-for-testing'): {
+    chromiumOptions: {
+        gl: "angle" | "angle-egl" | "swangle" | "vulkan";
+        headless?: false;
+        enableMultiProcessOnLinux?: boolean;
+    };
+    browserExecutable: string;
+    chromeMode: "headless-shell" | "chrome-for-testing";
+};
+/** The chromeMode and GL backend a requirement resolves to on this host. No binary involved. */
+export declare function componentBrowserBackend(graphics: ComponentGraphicsRequirementV2): {
+    chromiumOptions: {
+        gl: 'angle' | 'angle-egl' | 'swangle' | 'vulkan';
+        headless?: false;
+        enableMultiProcessOnLinux?: boolean;
+    };
+};
+export declare function webglBackend(platform: NodeJS.Platform, hardware: boolean): 'angle' | 'angle-egl' | 'swangle';
+/**
+ * The renderer configuration a requirement resolves to on this host. Sealed into
+ * the render identity and receipt (contracts.ts ComponentRendererConfigV2).
+ */
+export declare function resolvedComponentRenderer(graphics: ComponentGraphicsRequirementV2, sceneShot?: SceneShotCapabilityV2 | null): ComponentRendererConfigV2;
+/** Validate the browser's selected renderer, not merely the presence of a GPU
+ * in the container. A hardware worker must never silently use SwiftShader, and
+ * a webgl (scene-shot) requirement must find WebGL available — and a host
+ * `MAX_TEXTURE_SIZE` that fits the shadow map the scene renderer may allocate —
+ * before any frame is captured: a missing renderer or an undersized host fails
+ * here with a typed refusal naming both numbers, never as a black frame, a
+ * substituted api or a quietly halved shadow map. The WebGL decision itself
+ * lives in webglProbe.ts so the composition lane, which reaches it through the
+ * tracked scene-shot bundle, applies the identical policy.
+ *
+ * Returns the admitted host for the receipt to record
+ * (`ComponentRenderReceiptV2.host`, outside the identity), or null when this
+ * render never probed one.
+ *
+ * Only the WebGL path measures `MAX_TEXTURE_SIZE`, and so only it opens a page.
+ * The hardware-compositor check reads Chrome's attestation over CDP and nothing
+ * else — a canvas2d component under `CUEFRAME_RENDER_ACCELERATION=hardware` has
+ * no shadow map to fit, and paying a page for a number it cannot use would be a
+ * round trip per render for nothing. That also means the two paths cannot
+ * disagree about what a null limit means: only the lane that asked for the
+ * measurement ever holds one. */
+export declare function assertComponentBrowserHardware(browser: CdpBrowserConnection, graphics?: ComponentGraphicsRequirementV2): Promise<ComponentHostAttestationV2 | null>;
 //# sourceMappingURL=browserOptions.d.ts.map

package/dist/_members/component-runtime/browserOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browserOptions.d.ts","sourceRoot":"","sources":["../src/browserOptions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;EAA4C,CAAC"}
+{"version":3,"file":"browserOptions.d.ts","sourceRoot":"","sources":["../src/browserOptions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,0BAA0B,EAE1B,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAKL,KAAK,oBAAoB,EAC1B,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,8BAA8B,EACxC,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,gBAAgB,GAAG,oBAAoB;qBAgBlC;QACf,EAAE,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;QACjD,QAAQ,CAAC,EAAE,KAAK,CAAC;QACjB,yBAAyB,CAAC,EAAE,OAAO,CAAC;KACrC;;;EAVF;AAED,gGAAgG;AAChG,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,8BAA8B,GACvC;IACD,eAAe,EAAE;QACf,EAAE,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;QACjD,QAAQ,CAAC,EAAE,KAAK,CAAC;QACjB,yBAAyB,CAAC,EAAE,OAAO,CAAC;KACrC,CAAC;CACH,CAqCA;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,CAG5G;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,8BAA8B,EACxC,SAAS,CAAC,EAAE,qBAAqB,GAAG,IAAI,GACvC,yBAAyB,CAM3B;AAED;;;;;;;;;;;;;;;;;;;;iCAoBiC;AACjC,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,CAAC,EAAE,8BAA8B,GACxC,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CA0B5C"}

package/dist/_members/component-runtime/canonicalIdentity.d.ts

@@ -7,6 +7,20 @@ export declare function componentBundleIdentity(input: {
     dependencyLockDigest: string;
 }): string;
 export declare function componentRenderIdentity(request: ComponentRenderRequestV2): string;
+/**
+ * The artifact key.
+ *
+ * `receipt.host` is dropped here, structurally, rather than left out of the object a caller
+ * happens to build: it is an attestation about the machine, not about the picture. Admission
+ * refuses every host below `STUDIO_SHADOW_MAP_BUDGET` and every host above it draws the identical
+ * frame, so hashing the reported limit or the renderer string would give two byte-identical
+ * artifacts two identities and evict correct ones across a mixed fleet. Everything that does
+ * change the picture — the backend, the colour pipeline, the scene capability, the runtime digest
+ * — is elsewhere on the receipt and is hashed.
+ *
+ * Dropping it also leaves every receipt written before `host` existed hashing to the same value it
+ * did then, because the remaining fields are unchanged.
+ */
 export declare function componentArtifactIdentity(input: {
     outputSha256: string;
     receipt: Omit<ComponentRenderReceiptV2, 'artifactId'>;

package/dist/_members/component-runtime/canonicalIdentity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalIdentity.d.ts","sourceRoot":"","sources":["../src/canonicalIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AAqCxB,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEvE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,GAAG,MAAM,CAET;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,MAAM,CAEjF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,YAAY,CAAC,CAAC;CACvD,GAAG,MAAM,CAET"}
+{"version":3,"file":"canonicalIdentity.d.ts","sourceRoot":"","sources":["../src/canonicalIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AAqCxB,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEvE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,GAAG,MAAM,CAET;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,MAAM,CAEjF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,YAAY,CAAC,CAAC;CACvD,GAAG,MAAM,CAOT"}