@cueframe/kernel 0.2.41 → 0.2.42

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

@@ -659,6 +659,25 @@ export declare const ComponentBakeJobV2: z.ZodObject<{
     seed: z.ZodString;
 }, z.core.$strict>;
 export type ComponentBakeJobV2 = z.infer<typeof ComponentBakeJobV2>;
+/**
+ * The shape of the request FILE a host writes for the preview sidecar it spawns, as a number the
+ * two sides can compare before either of them reads the other's bytes.
+ *
+ * It is not the bake job's version. The job above is one field inside that file; version 1 was the
+ * job alone at the top level, and version 2 is `{ job, sceneHost }` — the scene-preparation host
+ * block that arrived with sealed scene shots. The file itself carries no discriminator, and the
+ * sidecar accepts either shape by sniffing for `job`, so a host and a sidecar that disagree do not
+ * fail at the seam: the sidecar hands the whole file to `ComponentBakeJobV2.parse` and the host
+ * reads back a raw Zod issue array naming `version`, `source`, `params` and `assets` — an error
+ * about the outer envelope wearing the vocabulary of the inner job.
+ *
+ * That is exactly the failure a desktop build hits when its staged `resources/component-runtime`
+ * predates the app running against it, and nothing in either artifact's own manifest can see it:
+ * a stale staged tree is internally self-consistent, digest included. So the number is published
+ * here and the staging step records it in `runtime-manifest.json`, which lets the host refuse a
+ * sidecar that does not read what it writes — with the re-stage command — before it spawns one.
+ */
+export declare const COMPONENT_PREVIEW_REQUEST_VERSION: 2;
 export declare const ComponentGraphicsActualV2: z.ZodObject<{
     api: z.ZodEnum<{
         canvas2d: "canvas2d";

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

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

package/dist/_members/composition/floors/clips.d.ts

@@ -0,0 +1,18 @@
+/** Shared timeline readers for the floors. Pure; no I/O. */
+import type { Composition, TimelineClip } from "../validators/composition.js";
+export interface VisualClip {
+    clip: TimelineClip;
+    trackKind: string;
+}
+/** Every enabled non-audio track's source-bearing clips, with their track kind. */
+export declare function visualClips(composition: Composition): VisualClip[];
+/** Every enabled audio track's source-bearing clips. */
+export declare function audioClips(composition: Composition): TimelineClip[];
+/** A clip is "video" if its own declared family or its track says so. */
+export declare function isVideoClip(clip: TimelineClip, trackKind: string): boolean;
+/**
+ * The clip covers (approximately) the whole output frame: no region, or a region
+ * that spans the frame within a small margin. Full-frame graphics are the ones
+ * that read as a "room" rather than an inset element.
+ */
+export declare function isFullFrame(clip: TimelineClip): boolean;

package/dist/_members/composition/floors/cohesionFloors.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Cohesion floors — the two slop mechanisms that separate a slideshow from a
+ * film a scene detector reads as one continuous shot.
+ *
+ *   1. STATIC HOLD — a single visual state parked on screen long enough to read
+ *      as a slide. What counts as "parked" is decided by `analyzeHold`, which
+ *      credits a card for the motion vars it reads and an overlay for the
+ *      animation length its primitive was designed around; see that module for
+ *      why "has no keyframes" is the wrong test in this repo.
+ *
+ *   2. A VOICE WITHOUT ITS SPINE — a narration (vo-role clip) with no word-timed
+ *      caption layer. The persistent word-synced line is what lets the visuals
+ *      change every beat while the film still coheres; a VO whose words appear
+ *      nowhere on screen wastes the strongest cohesion device available, and
+ *      `setCaptions` makes authoring it a one-op fix.
+ *
+ * Composition-level, render-free, criterion `editorial`. Advisories, never gates.
+ */
+import type { Composition } from "../validators/composition.js";
+import type { FloorAdvisory } from "./types.js";
+/**
+ * A visual state parked past this reads as a slide. A well-cut reference rarely
+ * holds one past ~3s; 4s leaves editorial room.
+ */
+export declare const STATIC_HOLD_MAX_SEC = 4;
+/** Anything held past the slide line, measured as time with nothing moving. */
+export declare function detectStaticHolds(composition: Composition): FloorAdvisory[];
+/** A narration (vo-role audio) with no word-timed caption layer. */
+export declare function detectSilentNarration(composition: Composition): FloorAdvisory[];
+/** All cohesion floors, in stable order. */
+export declare function detectCohesionAdvisories(composition: Composition): FloorAdvisory[];

package/dist/_members/composition/floors/craftFloors.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Craft floors — deterministic checks over the composition's clips ALONE (no
+ * pixels, no model), each making one founder critique measurable:
+ *
+ *   1. SFX SAME-SOUND REUSE — the mix leans on a tiny palette of transients. The
+ *      same "tick" over and over reads as canned. Measured as distinct sfx
+ *      mediaIds ÷ total sfx hits.
+ *
+ *   2. DEAD HOLD — the HARD ceiling above static-hold's "reads as a slide" line.
+ *      No single beat should park a visual state past DEAD_HOLD_MAX_SEC no matter
+ *      how it is dressed. A 30s card fires this AND static-hold: they are
+ *      different critiques (one says "add motion", this one says "no beat holds
+ *      this long"). Same hold analysis as static-hold, so a card reading the
+ *      motion vars and an overlay inside its designed length are exempt here too.
+ *
+ *   3. ROOM CHANGES — a graphics-led film (NO video footage) that cuts between
+ *      too many sequential full-frame "rooms" reads as a deck of slides rather
+ *      than one continuous space. A ROOM is a backdrop: a full-frame clip that
+ *      PAINTS the frame (proven for a card, declared for a component, catalogued
+ *      for an overlay) with nothing painted beneath it — never a beat card
+ *      composited over a persistent world, which is the shape the Director is
+ *      told to author. This is the WEAKEST proxy of the four — true
+ *      scene-discontinuity detection needs the rendered pixels — so it reports
+ *      only what the timeline honestly shows.
+ *
+ *   4. MONTAGE PACING — a run of video cuts churning too fast to read, or a
+ *      single subliminal clip the eye never registers.
+ *
+ * All land on `editorial`. Advisories, never gates.
+ */
+import type { Composition } from "../validators/composition.js";
+import type { FloorAdvisory } from "./types.js";
+/**
+ * A mix with this many SFX hits is dense enough that palette variety matters —
+ * below it, reuse is unremarkable (a 3-hit film reusing one tick is fine).
+ */
+export declare const SFX_VARIETY_MIN_HITS = 6;
+/**
+ * distinct sounds ÷ hits below this reads as "the same sound over and over".
+ * 15 hits from 3 sounds = 0.20 fires; 9 hits from 5 sounds = 0.56 is clean.
+ */
+export declare const SFX_VARIETY_MIN_RATIO = 0.4;
+/**
+ * The absolute ceiling for one parked visual state, above static-hold's "reads
+ * as a slide" line. Past this a beat is a parked slide however it is dressed.
+ */
+export declare const DEAD_HOLD_MAX_SEC = 8;
+/**
+ * More than this many sequential full-frame "rooms" in a graphics-led film reads
+ * as a slide deck. Two backdrops (a before / after) is a legitimate contrast.
+ */
+export declare const ROOM_CHANGE_MAX = 2;
+/** A clip shorter than this is a churn cut; MONTAGE_MIN_RUN in a row strobe. */
+export declare const MONTAGE_FAST_CLIP_SEC = 1.2;
+/** A single clip shorter than this is subliminal — the eye cannot register it. */
+export declare const MONTAGE_HARD_MIN_SEC = 0.4;
+/** How many adjacent video clips make a "montage" run worth grading for rhythm. */
+export declare const MONTAGE_MIN_RUN = 3;
+/**
+ * Floor 1 — SFX same-sound reuse. Among sfx-role audio clips, distinct mediaIds
+ * ÷ total hits. Fires only once the mix is dense enough for variety to matter.
+ * Composition-scoped (not one clip's fault) → no clipId.
+ */
+export declare function detectSfxSameSoundReuse(composition: Composition): FloorAdvisory[];
+/**
+ * Floor 2 — dead hold. Any judgeable medium parking one visual state past the
+ * HARD ceiling. Components stay exempt: nothing on the wire says how long their
+ * own choreography runs.
+ */
+export declare function detectDeadHolds(composition: Composition): FloorAdvisory[];
+/**
+ * Floor 3 — room changes (graphics-led only). Gated on NO video footage. Counts
+ * full-frame backdrop graphics with nothing painted beneath them that tile time
+ * without overlapping (a sequence of rooms). WEAKEST proxy — see the file
+ * header. Composition-scoped.
+ */
+export declare function detectRoomChanges(composition: Composition): FloorAdvisory[];
+/**
+ * Floor 4 — montage pacing. Over the video clips: any subliminal clip, and a
+ * MONTAGE_MIN_RUN-in-a-row churn of sub-MONTAGE_FAST_CLIP_SEC cuts. Both are
+ * findings about what the eye can resolve; see MONTAGE_MIN_RUN for why the
+ * too-slow half of this floor no longer exists.
+ */
+export declare function detectMontagePacing(composition: Composition): FloorAdvisory[];
+/** All craft floors, in stable order. Composition-level, render-free. */
+export declare function detectCraftAdvisories(composition: Composition): FloorAdvisory[];

package/dist/_members/composition/floors/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * CRAFT FLOORS — deterministic, render-free advisories over an authored
+ * composition. Pure functions: no I/O, no network, no model. They never refuse a
+ * composition; they tell its author which beat reads as a slide, which mix reads
+ * as canned, and which run of cuts reads as strobe.
+ */
+export type { FloorAdvisory, FloorCriterion, FloorRule } from "./types.js";
+export { floorAdvisoryLine } from "./types.js";
+export { STATIC_HOLD_MAX_SEC, detectStaticHolds, detectSilentNarration, detectCohesionAdvisories, } from "./cohesionFloors.js";
+export { DEAD_HOLD_MAX_SEC, ROOM_CHANGE_MAX, SFX_VARIETY_MIN_HITS, SFX_VARIETY_MIN_RATIO, MONTAGE_FAST_CLIP_SEC, MONTAGE_HARD_MIN_SEC, MONTAGE_MIN_RUN, detectSfxSameSoundReuse, detectDeadHolds, detectRoomChanges, detectMontagePacing, detectCraftAdvisories, } from "./craftFloors.js";
+export { OCCLUSION_MIN_COVERAGE, OCCLUSION_MIN_SEC, OCCLUSION_DECLARED_ALPHA_MIN_SEC, cardIsOpaque, declaredAlphaPolicy, layeredVisualClips, detectBackdropOcclusion, } from "./occlusionFloor.js";
+export type { DeclaredAlphaPolicy, LayeredClip, OcclusionEvidence } from "./occlusionFloor.js";
+export { CARD_EDGE_RAMP_FRAMES, analyzeHold, cardMotionSeconds, compositionFps, keyframeMotionSeconds, overlayDesignedSeconds, } from "./staticHold.js";
+export type { HoldAnalysis, StaticMedium } from "./staticHold.js";
+import type { Composition } from "../validators/composition.js";
+import { type FloorAdvisory } from "./types.js";
+/** Every floor, in stable order: cohesion first, then craft, then layering. */
+export declare function detectFloorAdvisories(composition: Composition): FloorAdvisory[];
+/**
+ * Every floor, rendered for a string `warnings[]` channel. The structured
+ * advisories are the source of truth; these lines are derived from them so the
+ * two can never drift.
+ */
+export declare function floorAdvisoryLines(composition: Composition): string[];

package/dist/_members/composition/floors/occlusionFloor.d.ts

@@ -0,0 +1,160 @@
+/**
+ * BACKDROP OCCLUSION — the film that hides itself.
+ *
+ * CueFrame's track order is INVERTED from the NLE convention every author
+ * arrives with: track index 0 is the TOP layer, and the LAST track is the
+ * backdrop. A Director that reaches for "track 0 = the bottom = the world"
+ * authors a persistent full-frame card there and buries every beat under it.
+ * That is not hypothetical — a real desktop run shipped a 30s launch video
+ * whose four beat cards were never once on screen, and nothing in the loop
+ * said so.
+ *
+ * This floor is the deterministic catch: an OPAQUE FULL-FRAME clip on a HIGHER
+ * layer that hides clips on LOWER layers for a SUBSTANTIAL span.
+ *
+ * ── The layer arithmetic ─────────────────────────────────────────────────────
+ * `layerIndex = trackCount - trackIndex`, over `composition.tracks` in wire
+ * order, with `trackCount = composition.tracks.length` — INCLUDING audio and
+ * disabled tracks, because the renderer counts them too. That is a re-derivation
+ * of `packages/execution/core/src/render/trackProjection.ts` (`visualIdentity`),
+ * fed to `zIndex` in `render-entry`'s `MainComposition`, not an import: this
+ * package is UPSTREAM of the execution packages (execution depends on
+ * composition, never the reverse), so importing the renderer's copy would invert
+ * the dependency graph. The two are pinned together instead by mirroring the
+ * renderer's own deliberate ordering fixture — the `top-overlay` (0→3) /
+ * `middle-video` (1→2) / `bottom-effect` (2→1) case in
+ * `core/src/render/__tests__/compositionRender.test.ts` — in this module's test,
+ * so a flip of the convention breaks both files at once. The `alphaPolicy`
+ * literals below are inlined for the same reason: they are
+ * `ComponentManifestV2.alphaPolicy` in
+ * `packages/execution/component-runtime/src/contracts.ts`, and importing that
+ * contract would invert the dependency graph.
+ *
+ * ── What counts as OPAQUE — two grades of evidence ───────────────────────────
+ * PROVEN (a CARD). A card's paint is literally on the wire (`html` + `tokens`),
+ * so we can READ whether it lays down an opaque plate.
+ *
+ * DECLARED (a component whose manifest travels on the clip). A component's
+ * pixels live in source we do not execute, but its author's alpha INTENT is on
+ * the wire: `source.params.componentManifest.alphaPolicy` (local desktop
+ * components ride as `overlay` + `primitiveId: 'custom'`, and the manifest is
+ * set beside `jsxSource`; `source.props` is read too, for the kinds that name
+ * their bag `props`). `requires-transparency` is strong evidence the clip is NOT
+ * an occluder and never fires. `allows-opaque` is PERMISSION to be opaque, not
+ * proof of it — so it is held to a much longer buried span (see
+ * `OCCLUSION_DECLARED_ALPHA_MIN_SEC`) and the advisory says the manifest ALLOWS
+ * opacity rather than asserting the pixels are.
+ *
+ * Nothing else is judged: a catalog overlay's alpha is not on the clip, and a
+ * media clip's coverage depends on intrinsic aspect and `fit`. A false positive
+ * here is worse than a miss — it would tell an author to move a clip that is
+ * fine — so every medium we cannot read stays see-through and never fires, and a
+ * clip with no readable manifest is simply unjudged.
+ *
+ * Composition-level, render-free, criterion `editorial`. Advisory, never a gate.
+ */
+import type { Composition, TimelineClip } from "../validators/composition.js";
+import type { FloorAdvisory } from "./types.js";
+/**
+ * A lower clip hidden for at least this FRACTION of its own life is effectively
+ * never seen. Below it the clip still reads before or after the takeover, which
+ * is ordinary layering — a title card punched over a beat, a transition plate.
+ * 0.9 leaves room for a takeover that lands a frame early or runs a beat long
+ * without indicting a clip the viewer does actually see.
+ */
+export declare const OCCLUSION_MIN_COVERAGE = 0.9;
+/**
+ * THE TRIGGER: at least ONE buried clip must be hidden for this many seconds
+ * before the floor speaks. A deliberate full-frame takeover for a beat is
+ * legitimate craft, and a short stinger can legitimately swallow a short clip
+ * whole. Past 3s of a lower clip buried, the takeover is not a beat any more —
+ * it is a layer in the wrong place. (Once it does speak it names every buried
+ * clip, short ones included; this floor gates the FINDING, not the evidence.)
+ */
+export declare const OCCLUSION_MIN_SEC = 3;
+/**
+ * THE TRIGGER for a clip whose opacity is only DECLARED, never proven — a
+ * component whose manifest says `allows-opaque`. That policy is PERMISSION to
+ * paint opaque pixels, not a statement that it does: a component free to be
+ * opaque may still render a transparent lower-third. So the declared grade does
+ * not get the card's 3s trigger. At this many seconds of a lower clip buried,
+ * no reading of the timeline leaves the takeover a beat — either the component
+ * is opaque and the film is hiding itself, or it is transparent and the author
+ * dismisses one advisory. Below it, the cost of being wrong outweighs the catch.
+ */
+export declare const OCCLUSION_DECLARED_ALPHA_MIN_SEC = 10;
+/**
+ * `ComponentManifestV2.alphaPolicy` values, INLINED rather than imported from
+ * `packages/execution/component-runtime/src/contracts.ts` — see the dependency
+ * note in the module header. If the contract ever grows a third value, this
+ * module treats it as unreadable and stays silent, which is the safe direction.
+ */
+declare const ALPHA_POLICY_ALLOWS_OPAQUE = "allows-opaque";
+declare const ALPHA_POLICY_REQUIRES_TRANSPARENCY = "requires-transparency";
+/**
+ * The alpha policy DECLARED on this clip, or `null` when the clip carries no
+ * readable manifest — which is most clips, and which leaves them unjudged.
+ *
+ * The manifest rides in the clip's own param bag: `params` for an `overlay`
+ * (how a local desktop component travels — `primitiveId: 'custom'`, manifest
+ * beside `jsxSource`), `props` for the kinds that name their bag that way.
+ * Read structurally and defensively: this bag is `Record<string, unknown>` on
+ * the wire, so anything that is not literally one of the two contract strings
+ * reads as "not declared".
+ */
+export type DeclaredAlphaPolicy = typeof ALPHA_POLICY_ALLOWS_OPAQUE | typeof ALPHA_POLICY_REQUIRES_TRANSPARENCY;
+export declare function declaredAlphaPolicy(source: TimelineClip["source"]): DeclaredAlphaPolicy | null;
+/** A visual clip with the layer the renderer will actually give it. */
+export interface LayeredClip {
+    clip: TimelineClip;
+    layerIndex: number;
+}
+/**
+ * Every enabled non-audio clip, carrying `layerIndex = trackCount - trackIndex`.
+ * Deliberately NOT built on `visualClips()`: that reader drops the track index,
+ * and the index is this floor's entire subject.
+ */
+export declare function layeredVisualClips(composition: Composition): LayeredClip[];
+/**
+ * Does this card lay down an opaque full-bleed plate?
+ *
+ * We judge the FIRST `background` declaration in document order, because HTML is
+ * written outside-in: the first background an author writes is the outermost
+ * element's, which is the one that fills the frame. Judging *any* background
+ * would fire on a transparent card carrying one opaque inner chip — precisely
+ * the false positive that would make this floor untrustworthy. The same block's
+ * sizing is then checked, so a card whose ROOT is itself a small opaque chip is
+ * ruled out too.
+ *
+ * Two bounds keep that premise honest, and both were false positives before
+ * they were written: the scan reads INLINE styles only (`maskStyleElements` —
+ * document order says nothing about which element a `<style>` rule hits), and a
+ * background found below the root counts only if that element `claimsWholeFrame`
+ * (an opaque `<span>` chip inside a transparent card is not a backdrop).
+ */
+export declare function cardIsOpaque(source: {
+    html: string;
+    tokens?: Record<string, string>;
+}): boolean;
+/**
+ * Does the clip's own geometry still cover the frame? `isFullFrame` reads
+ * `region`; these read the transforms that can pull an otherwise full-frame clip
+ * off or away from the frame. Any transform we cannot reason about → not an
+ * occluder. Exported because the room-changes floor asks the same geometric
+ * question of a candidate world and must not answer it differently.
+ */
+export declare function coversFrame(clip: TimelineClip): boolean;
+/**
+ * How strong our evidence is that this clip paints over everything beneath it.
+ * `proven` — a card whose own wire paint is an opaque full-bleed plate.
+ * `declared` — a component whose manifest ALLOWS opacity; permission, not fact.
+ */
+export type OcclusionEvidence = "proven" | "declared";
+/** Effects are applied to lanes, not painted as one — they are never "hidden". */
+export declare function isPaintedLane(clip: TimelineClip): boolean;
+/**
+ * The floor. One advisory per occluding clip — that is the ONE clip to edit —
+ * naming every clip it buries and the numbers that prove it.
+ */
+export declare function detectBackdropOcclusion(composition: Composition): FloorAdvisory[];
+export {};

package/dist/_members/composition/floors/staticHold.d.ts

@@ -0,0 +1,103 @@
+/**
+ * HOW LONG DOES THIS CLIP PARK A SINGLE VISUAL STATE?
+ *
+ * Both hold floors (`static-hold`, `dead-hold`) ask exactly this question and
+ * differ only in where they draw the line, so they share one answer.
+ *
+ * The naive test — "a card or an un-Ken-Burnsed still is static, full stop" —
+ * is wrong here, in both directions:
+ *
+ *   • A CARD IS NOT NECESSARILY STATIC. The card motion runtime drives a set of
+ *     CSS custom properties per frame (`--cf-progress`, `--cf-ease`, `--cf-frame`,
+ *     `--cf-t`, plus the edge ramps `--cf-enter` / `--cf-exit`). A card whose html
+ *     reads a CONTINUOUS one of those moves for its whole life and is not a slide.
+ *     A card that reads only the EDGE ramps animates in and out and is parked in
+ *     between — which is the honest number to judge.
+ *
+ *   • AN OVERLAY IS NOT STATIC JUST BECAUSE IT HAS NO KEYFRAMES. Catalog
+ *     primitives animate internally; treating "no `animate` channels" as "no
+ *     motion" would fire on every well-authored overlay in the catalog. What is
+ *     actually knowable is each primitive's DESIGNED animation length
+ *     (`durationInFrames` / `fps` in the catalog meta). Held within it, the
+ *     overlay is moving. Held past it, the surplus is the parked tail — the eye
+ *     sees a finished animation holding its last frame, which is exactly the
+ *     slide texture these floors exist to catch.
+ *
+ * Clip-level `animate` keyframes are motion on any medium and are subtracted the
+ * same way. CSS `@keyframes` in card html are NOT counted: they run on wall
+ * clock, and a frame-seeking renderer does not advance them, so they are not
+ * motion anyone will see in the output.
+ *
+ * Components stay EXEMPT. A component carries its own choreography and nothing
+ * on the wire says how long it runs, so the composition cannot honestly judge it.
+ */
+import type { Composition, TimelineClip } from "../validators/composition.js";
+import type { CardMotionVarName } from "../projection/cardTokens.js";
+/**
+ * Card motion vars that change on EVERY frame of the clip: a card reading one of
+ * these is in motion for its whole duration.
+ */
+declare const CONTINUOUS_CARD_MOTION_VARS: readonly ["--cf-frame", "--cf-t", "--cf-progress", "--cf-ease"];
+/**
+ * Card motion vars that ramp only at the edges: `--cf-enter` rises over the first
+ * frames, `--cf-exit` falls over the last. A card reading only these is parked
+ * for everything in between. (`--cf-fps` and `--cf-duration` are constants and
+ * are motion for nobody.)
+ */
+declare const EDGE_CARD_MOTION_VARS: readonly ["--cf-enter", "--cf-exit"];
+/**
+ * Frames each edge ramp spans in the card motion runtime. Duplicated here rather
+ * than imported because the runtime lives downstream of this package (it depends
+ * on the composition types, not the other way round); the test below pins the
+ * number so a drift is visible.
+ */
+export declare const CARD_EDGE_RAMP_FRAMES = 18;
+/**
+ * Compile-time proof that the two lists above plus the two constants partition
+ * `CARD_MOTION_VAR_NAMES`. Add a var to the runtime without classifying it here
+ * and this line stops type-checking, rather than the floor quietly mis-reading a
+ * moving card as a parked one.
+ */
+type AssertNever<T extends never> = T;
+type UnclassifiedCardMotionVar = Exclude<CardMotionVarName, (typeof CONTINUOUS_CARD_MOTION_VARS)[number] | (typeof EDGE_CARD_MOTION_VARS)[number] | "--cf-fps" | "--cf-duration">;
+export type CardMotionVarsArePartitioned = AssertNever<UnclassifiedCardMotionVar>;
+export type StaticMedium = "card" | "still image" | "overlay";
+export interface HoldAnalysis {
+    /** Seconds this clip parks one unchanging visual state. */
+    staticSeconds: number;
+    /** Which medium, for prose the author can act on. */
+    medium: StaticMedium;
+    /** For overlays: the primitive's designed animation length, in seconds. */
+    designedSeconds?: number;
+    /** For overlays: the primitive the clip mounts. */
+    primitiveId?: string;
+}
+export declare function compositionFps(composition: Composition): number;
+/**
+ * The longest span any `animate` channel covers, in clip-relative seconds.
+ * Keyframe times are clip-relative (the renderer evaluates channels at
+ * `frame / fps` within the clip), so this is directly comparable to `duration`.
+ */
+export declare function keyframeMotionSeconds(clip: TimelineClip): number;
+/**
+ * Seconds of motion a card gets from the card motion runtime: its whole duration
+ * if it reads a continuous var, the two edge ramps if it reads only those, zero
+ * if it reads none.
+ */
+export declare function cardMotionSeconds(source: {
+    html: string;
+    tokens?: Record<string, string>;
+}, duration: number, fps: number): number;
+/**
+ * A catalog primitive's designed animation length in seconds, or `null` when the
+ * catalog does not know the primitive (an org component id, or a build this
+ * catalog predates) — in which case the clip is not judged at all.
+ */
+export declare function overlayDesignedSeconds(primitiveId: string, fallbackFps: number): number | null;
+/**
+ * How long this clip holds one unchanging frame, or `null` when the medium is
+ * not judgeable (video, component, effect, nested composition, an animated
+ * still, an overlay the catalog does not know).
+ */
+export declare function analyzeHold(clip: TimelineClip, fps: number, trackKind?: string): HoldAnalysis | null;
+export {};

package/dist/_members/composition/floors/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * A FLOOR ADVISORY — a deterministic finding about the authored timeline,
+ * addressed to the clip its author can edit.
+ *
+ * Floors are ADVISORIES, never gates. They are computed from the composition
+ * alone: no pixels, no network, no model. Their job is to be FIXED, so every
+ * one of them carries the numbers that prove it (`detail`) and the edit that
+ * resolves it (`fix`) — never a vibe, and never a lone score.
+ *
+ * The shape is the public API's `advisories[]` item
+ * (`{ rule, criterion, clipId?, detail, fix }`), narrowed here to the rules and
+ * the single criterion these floors can emit. It is structurally assignable to
+ * that wire type; nothing new is invented.
+ */
+/** Stable machine names. An author reads `fix`; a human reads `rule` in a trace. */
+export type FloorRule = "static-hold" | "caption-spine" | "sfx-same-sound-reuse" | "dead-hold" | "room-changes" | "montage-pacing" | "backdrop-occlusion";
+/**
+ * Every floor lands on `editorial` — pacing and continuity territory. There is
+ * deliberately no new criterion: the criterion set is load-bearing across
+ * weights, prompts and score columns, and none of these findings is a new axis.
+ */
+export type FloorCriterion = "editorial";
+export interface FloorAdvisory {
+    /** Which criterion this advisory floors. Always `editorial`. */
+    criterion: FloorCriterion;
+    /** The rule that fired. */
+    rule: FloorRule;
+    /**
+     * THE CLIP TO EDIT. The author already holds the composition, so a clip id
+     * turns "something is wrong" into a targeted amendment. Absent only where the
+     * finding genuinely is not one clip's fault (an SFX palette is the whole mix;
+     * a room count is the whole film) — saying so honestly beats naming a clip we
+     * cannot justify.
+     */
+    clipId?: string;
+    /** What is wrong, WITH THE NUMBERS that prove it. */
+    detail: string;
+    /** The edit that resolves it. Imperative, specific, actually available. */
+    fix: string;
+}
+/**
+ * The one-line rendering of an advisory, for the string `warnings[]` channels
+ * that predate the structured shape (the local apply verdict, the MCP warning
+ * banner). Kept here so prose and structure can never drift: one is derived
+ * from the other.
+ *
+ * `<rule> — <detail>. Fix: <fix>` matches the house style already used by the
+ * card-token advisories (`card_token_unresolved — …`): the machine name leads
+ * so the reader can grep or dedupe it, the evidence follows, and the imperative
+ * closes the line where an author's eye lands last.
+ */
+export declare function floorAdvisoryLine(advisory: FloorAdvisory): string;

package/dist/_members/composition/scene/introspection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Introspection and parsing over the `SceneShotSpecV2` contract.
+ *
+ * These helpers CONSUME the zod contract defined in `./schema` — they admit untrusted data
+ * through it and walk an already-parsed shot — rather than define it, so they live beside the
+ * contract instead of inside it. `./schema` re-exports them, so every import path is unchanged.
+ */
+import { SceneShotSpecV2 } from './schema.js';
+/** Parse untrusted authored data through the same public schema all consumers embed. */
+export declare function parseSceneShotSpecV2(value: unknown): SceneShotSpecV2;
+/** Distinct outer image asset slots in first-use order, recursively through groups. */
+export declare function sceneShotImageSlots(spec: Pick<SceneShotSpecV2, 'layers'>): string[];
+/** Distinct video media ids in first-use order, recursively through groups. */
+export declare function sceneShotVideoSlots(spec: Pick<SceneShotSpecV2, 'layers'>): string[];
+export declare function sceneShotSurfaceCount(spec: Pick<SceneShotSpecV2, 'layers'>): number;

package/dist/_members/composition/scene/schema.d.ts

@@ -340,13 +340,8 @@ export type SceneRefusalCode = 'scene_spec_version_unsupported' | 'scene_lightin
  * second stage parses/materializes the schema that is also published as JSON Schema.
  */
 export declare const SceneShotSpecV2: z.ZodType<SceneShotSpecV2>;
-/** Parse untrusted authored data through the same public schema all consumers embed. */
-export declare function parseSceneShotSpecV2(value: unknown): SceneShotSpecV2;
-/** Distinct outer image asset slots in first-use order, recursively through groups. */
-export declare function sceneShotImageSlots(spec: Pick<SceneShotSpecV2, 'layers'>): string[];
-/** Distinct video media ids in first-use order, recursively through groups. */
-export declare function sceneShotVideoSlots(spec: Pick<SceneShotSpecV2, 'layers'>): string[];
-export declare function sceneShotSurfaceCount(spec: Pick<SceneShotSpecV2, 'layers'>): number;
+/** Introspection and parsing over this contract; re-exported so `./schema` keeps its surface. */
+export * from './introspection.js';
 /**
  * What a scene shot IS, for a caller reading the published contract.
  *
@@ -425,4 +420,3 @@ export declare const sceneShotJsonSchema: {
     _prefault?: unknown;
 };
 export declare function sceneShotJsonSchemaText(): string;
-export {};

package/dist/_members/errors/registry.d.ts

@@ -1646,6 +1646,12 @@ export interface Envelope {
     message: string;
     fix?: Record<string, unknown>;
     locator?: Record<string, unknown>;
+    /**
+     * Contract version that produced this verdict. If it differs between two
+     * calls the rules changed underneath the caller, not the request (CUE-42).
+     * Not sensitive, so it survives the scrub for untrusted callers too.
+     */
+    contract?: string;
 }
 export declare class CueframeError extends Error {
     readonly code: ErrorCode;

package/dist/animate/preparation-facts.js

@@ -4,11 +4,11 @@ import {
   sceneGrainPreparationCpuAllocationV1,
   scenePresetBuilderDescriptorV1,
   sceneSlabPreparationFactsV1
-} from "../chunk-OBA6NW4S.js";
+} from "../chunk-XV2K3AQT.js";
 import {
   photographicStudioPreparationFactsV1,
   sceneFocusPreparationAllocationsV1
-} from "../chunk-XACXNDFL.js";
+} from "../chunk-CL5Y6V6K.js";
 import "../chunk-2L7PYYJK.js";
 import "../chunk-2ESYSVXG.js";
 export {

package/dist/animate.js

@@ -102,7 +102,7 @@ import {
   useStage,
   weightsAt,
   worldTransform
-} from "./chunk-JBWSK2YD.js";
+} from "./chunk-2PU2TSUG.js";
 import {
   DEFAULT_LIGHTING_PROFILE,
   DEVICE_GLASS_OPACITY_ENCODED,
@@ -161,7 +161,7 @@ import {
   studioShadowFrustum,
   verifyPhotographicStudioHdr,
   withNormalisedFaceUv
-} from "./chunk-OBA6NW4S.js";
+} from "./chunk-XV2K3AQT.js";
 import {
   ALLOWED_BAKE_SCALES,
   DEFAULT_BAKE_SCALE,
@@ -183,7 +183,7 @@ import {
   projectedSlotEdges,
   sceneFocusPreparationAllocationsV1,
   selectSceneBakeScale
-} from "./chunk-XACXNDFL.js";
+} from "./chunk-CL5Y6V6K.js";
 import "./chunk-2L7PYYJK.js";
 import "./chunk-AVTEPAWI.js";
 import "./chunk-2ESYSVXG.js";

package/dist/authoring/scene.js

@@ -13,7 +13,7 @@ import {
   sceneTrackIdFor,
   validateSceneAdd,
   validateSceneUpdate
-} from "../chunk-4MK6YGKV.js";
+} from "../chunk-N2OZDD44.js";
 import {
   SCENE_TRANSITION_KINDS,
   collectSceneClipIssues,
@@ -22,7 +22,7 @@ import {
   offFrameLattice,
   readSceneSourceRef,
   sceneClipShapeIssues
-} from "../chunk-XACXNDFL.js";
+} from "../chunk-CL5Y6V6K.js";
 import "../chunk-2L7PYYJK.js";
 import "../chunk-2ESYSVXG.js";
 export {