@jokerized/decksmith 0.9.3 → 0.9.4

package/dist/types/bespoke/inspect.d.ts

@@ -56,6 +56,13 @@ export declare function isWriting(t: ReadText): boolean;
  * language's pass). Prints one JSON line per file.
  */
 export declare const OCR_SWIFT = "import Foundation\nimport Vision\nimport ImageIO\nfunc run(_ img: CGImage, _ langs: [String]) -> [[String: Any]] {\n  let req = VNRecognizeTextRequest()\n  req.recognitionLevel = .accurate\n  req.usesLanguageCorrection = false\n  req.recognitionLanguages = langs\n  try? VNImageRequestHandler(cgImage: img, options: [:]).perform([req])\n  var out: [[String: Any]] = []\n  for o in req.results ?? [] {\n    guard let c = o.topCandidates(1).first else { continue }\n    let b = o.boundingBox\n    out.append([\"s\": c.string, \"c\": c.confidence, \"b\": [b.minX, 1 - b.maxY, b.width, b.height], \"l\": langs[0]])\n  }\n  return out\n}\nfor path in CommandLine.arguments.dropFirst() {\n  guard let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: path) as CFURL, nil),\n        let img = CGImageSourceCreateImageAtIndex(src, 0, nil) else {\n    print(\"{\\\"error\\\":\\\"unreadable\\\"}\"); continue\n  }\n  var out: [[String: Any]] = []\n  for langs in [[\"en-US\"], [\"ko-KR\"], [\"ja-JP\"], [\"zh-Hans\"]] { out += run(img, langs) }\n  let data = try! JSONSerialization.data(withJSONObject: [\"texts\": out])\n  print(String(data: data, encoding: .utf8)!)\n}\n";
+export declare function exec(bin: string, args: string[], timeoutMs: number): Promise<string>;
+/**
+ * A compiled Swift helper, `<dir>/<name>-<hash of its source>`, compiled on
+ * first use (MEASURED ~25s once; then ~0.5s a picture). Rejects with the
+ * reason when this machine cannot build it — no macOS, no Swift toolchain.
+ */
+export declare function swiftBinary(name: string, source: string, dir: string): Promise<string>;
 /** The writing in a picture; rejects (with why) when nothing here can read it. */
 export declare function readText(png: string, toolDir: string): Promise<ReadText[]>;
 /** Everything the inspection says about one picture. */
@@ -65,5 +72,37 @@ export interface Inspection {
     /** Writing found, or null when no reader was available (`unread` says why). */
     text: string[] | null;
     unread?: string;
+    /** The picture has a transparent ground (a subjects layer for a backdrop). */
+    cutout?: boolean;
+    /** The flattened copy the reader read, when the picture is a cutout. */
+    flatFile?: string;
 }
-export declare function inspectPicture(bytes: Buffer, file: string, toolDir: string): Promise<Inspection>;
+/**
+ * Inspect a drawn picture. A subjects layer drawn on a transparent ground
+ * (round 5) is inspected as it will be seen against the pack's ground: laid
+ * on `ground` first, and the text reader reads that flattened copy, written
+ * beside `file` as `<file>.flat.png` (Vision reads a transparent pixel as
+ * black, which would hide dark writing).
+ */
+export declare function inspectPicture(bytes: Buffer, file: string, toolDir: string, ground?: readonly [number, number, number]): Promise<Inspection>;
+/** "#rrggbb" (or "#rgb") as RGB; mid grey for anything else. */
+export declare function hexRgb(hex: string): [number, number, number];
+/** Share of an RGBA picture's pixels that are (nearly) transparent, sampled. */
+export declare function transparentShare(f: Frame): number;
+/** An RGBA picture laid over a flat ground, as RGB. */
+export declare function flattenOn(f: Frame, ground: readonly number[]): Frame;
+/** A minimal PNG encoder (8-bit RGB or RGBA, filter 0): the repository decodes PNGs, and the text reader needs one written. */
+export declare function encodePng(f: Frame): Buffer;
+/**
+ * The Swift helper for REPETITION across a deck's pictures: Vision's image
+ * feature print (`VNGenerateImageFeaturePrintRequest`), a learned embedding of
+ * what a picture shows, local and free. Prints one JSON line per file with the
+ * print as a float array. Two pictures of the same friendly robot sit close
+ * whatever their colours; two different scenes sit far apart (calibration in
+ * `SIMILAR_MAX`).
+ */
+export declare const PRINT_SWIFT = "import Foundation\nimport Vision\nimport ImageIO\nfor path in CommandLine.arguments.dropFirst() {\n  guard let src = CGImageSourceCreateWithURL(URL(fileURLWithPath: path) as CFURL, nil),\n        let img = CGImageSourceCreateImageAtIndex(src, 0, nil) else {\n    print(\"{\\\"error\\\":\\\"unreadable\\\"}\"); continue\n  }\n  let req = VNGenerateImageFeaturePrintRequest()\n  try? VNImageRequestHandler(cgImage: img, options: [:]).perform([req])\n  guard let o = req.results?.first as? VNFeaturePrintObservation else {\n    print(\"{\\\"error\\\":\\\"no print\\\"}\"); continue\n  }\n  var v = [Float](repeating: 0, count: o.elementCount)\n  o.data.withUnsafeBytes { raw in\n    let p = raw.bindMemory(to: Float.self)\n    for i in 0..<min(o.elementCount, p.count) { v[i] = p[i] }\n  }\n  let data = try! JSONSerialization.data(withJSONObject: [\"v\": v.map { Double($0) }])\n  print(String(data: data, encoding: .utf8)!)\n}\n";
+/** Each picture's feature print; rejects when this machine has no Vision. */
+export declare function featurePrints(pngs: readonly string[], toolDir: string): Promise<number[][]>;
+/** Vision's distance between two prints (Euclidean, as `computeDistance`). */
+export declare function printDistance(a: readonly number[], b: readonly number[]): number;

package/dist/types/bespoke/pipeline.d.ts

@@ -1,17 +1,20 @@
 import { type DeckNarration } from "../emit/composition.js";
-import { type Runner } from "../plan/codex.js";
+import { type Runner, type RunnerArgs } from "../plan/codex.js";
 import type { Prefs } from "../prefs.js";
 import type { Beat, Format, Source, Storyboard } from "../types.js";
 import { type Layout } from "../verify/scenes.js";
-import { type ArtCheck, type ArtCopies } from "./art.js";
-import { type Label } from "./callouts.js";
+import { type ArtCheck, type ArtCopies, type ArtRef, type DepthCopies } from "./art.js";
+import { type DataBuild } from "./databuild.js";
+import { type CutInput, type DepthInfo } from "./depth.js";
+import { type Grammar, type Role } from "./grammar.js";
 import { type Inspection } from "./inspect.js";
-import { type Measured } from "./prompt.js";
+import { type DeviceBeat, type Measured } from "./prompt.js";
 import { type RepairNote } from "./repair.js";
 import { type BespokeMap } from "./scene.js";
 import { type Skip } from "./select.js";
 import { type Shot } from "./shots.js";
 export type BespokePrefs = NonNullable<Prefs["bespoke"]>;
+export type { DeviceBeat };
 /** What a gate round says about one beat's candidate scene. */
 export interface GateResult {
     /** One line per finding, fed verbatim to the critique round. */
@@ -31,7 +34,7 @@ export interface GateResult {
     sid?: string;
 }
 /** Which probe: the drafts, the final candidates, or a repair round's. */
-export type GateRound = "draft" | "final" | "repair";
+export type GateRound = "draft" | "final" | "repair" | "second";
 /** Builds a deck with these candidates, gates each, and says what it found — keyed by beat id. */
 export type GateFn = (candidates: BespokeMap, round: GateRound) => Promise<Map<string, GateResult>>;
 export interface BespokeInput {
@@ -54,12 +57,20 @@ export interface BespokeInput {
     /** Where the image tool saves pictures. Default `$CODEX_HOME` or `~/.codex` (tests point it elsewhere). */
     codexHome?: string;
     /** Inspects a drawn picture (src/bespoke/inspect.ts); swappable so tests need no Swift or Vision. */
-    inspect?: (bytes: Buffer, file: string) => Promise<Inspection>;
+    inspect?: (bytes: Buffer, file: string, ground?: [number, number, number]) => Promise<Inspection>;
     /** Draws the deck's WebP and the boxed copy (src/bespoke/sheet.ts); swappable so tests need no Chrome. */
     copies?: (png: Buffer, boxes: Inspection["subjects"], box: {
         width: number;
         height: number;
+    }, opts: {
+        plate?: Buffer;
+        ground?: string;
+        cutout?: boolean;
     }) => Promise<ArtCopies>;
+    /** Vision feature prints of pictures (src/bespoke/inspect.ts); swappable so tests need no Swift. */
+    prints?: (pngs: readonly string[]) => Promise<number[][]>;
+    /** Cuts a picture into depth planes (src/bespoke/depth.ts); swappable so tests need no Chrome or Core ML. */
+    cut?: (i: CutInput) => Promise<DepthCopies>;
 }
 export interface SceneReport {
     beat: string;
@@ -87,9 +98,35 @@ export interface SceneReport {
         depicts: string;
         subjects?: number;
         check?: ArtCheck;
+        /** Drawn with a backdrop (two layers), and the setting it shows. */
+        plate?: boolean;
+        setting?: string;
+        motifs?: string[];
+        /** Round 6: its depth planes' distances (far to near), the subjects', and how they were made. */
+        depth?: {
+            planes: number[];
+            subjects: number[];
+            scale: number;
+            info: DepthInfo;
+        };
     };
+    /** Given a picture by the device pass's floor, not by the model's choice (`pictureFloor`). */
+    pictureForced?: boolean;
+    /** The camera grammar the scene was staged in (src/bespoke/grammar.ts), and its rhetorical role. */
+    grammar?: string;
+    role?: string;
+    /** What the camera did, one word per move (`shotSummary`). */
+    shots?: string;
+    /** Picture pixels per output pixel at the scene's closest shot (`effectiveAt`; gate `EFF_MIN`). */
+    effective?: number;
+    /** A data scene's build (src/bespoke/databuild.ts). */
+    build?: string;
     /** A data beat: drawn as a chart, never on a picture. */
     data?: boolean;
+    /** The scene's visual device (`assignDevices`). */
+    device?: string;
+    /** A second critique call was made for it (round 4: its first critique's scene failed). */
+    second?: boolean;
     /** Why there is none, when one was wanted. */
     artNote?: string;
     /** What the deterministic repair did to the kept scene (src/bespoke/repair.ts). */
@@ -131,9 +168,28 @@ export interface BespokeReport {
         rejectedText: number;
         rejectedStyle: number;
         rejectedSubjects: number;
+        /** Pictures refused for repeating another picture of the deck (a motif, a stock subject, or a near-identical print). */
+        rejectedRepeat: number;
+        /** Pictures drawn with a backdrop (two layers). */
+        plates: number;
+    };
+    /**
+     * How much the deck's pictures repeat each other: the closest pair's
+     * Vision feature-print distance (`SIMILAR_MAX` is the gate) and the mean,
+     * and every subject noun two pictures share.
+     */
+    repetition?: {
+        minPrint?: number;
+        meanPrint?: number;
+        shared: string[];
     };
     /** Wall seconds of the pass's stages, for profiling (`build` adds its own). */
     stages?: Record<string, number>;
+    /** The deck-order device pass: where its names came from, and why any were replaced. */
+    devices?: {
+        from: DeviceAssignment["from"];
+        note?: string;
+    };
     scenes: SceneReport[];
     skipped: Skip[];
 }
@@ -141,12 +197,21 @@ export interface BespokeResult {
     map: BespokeMap;
     report: BespokeReport;
 }
+/**
+ * What a cached verdict was reached under: the browser's gates and the static
+ * `card_row`. A rejection stamped otherwise is asked about again.
+ */
+export declare const GATE_STAMP = "gates-7+cards-2:0.08/0.6/0.8/0.2/0.12";
+/** A second critique starts only with this much of the wall-time cap left, seconds. */
+export declare const SECOND_SECONDS = 420;
 /** Repair rounds after the final gates, each one probe build of the repaired scenes only. */
 export declare const REPAIR_ROUNDS = 2;
 export declare class Budget {
     readonly cap: number;
     readonly deadline: number;
     readonly now: () => number;
+    /** The per-call ceiling, seconds: the per-scene timeout. */
+    readonly callSeconds: number;
     calls: number;
     /** Illustration calls, capped apart from `calls` (`prefs.art`). */
     art: number;
@@ -155,21 +220,45 @@ export declare class Budget {
     rejectedText: number;
     rejectedStyle: number;
     rejectedSubjects: number;
+    rejectedRepeat: number;
+    /** Device-pass calls (one a deck at most). */
+    devices: number;
     tokens: number;
     quota: boolean;
-    constructor(cap: number, deadline: number, now: () => number);
+    constructor(cap: number, deadline: number, now: () => number, 
+    /** The per-call ceiling, seconds: the per-scene timeout. */
+    callSeconds?: number);
     /** Undefined if a call may go ahead (and is counted), else why not. */
     take(): string | undefined;
     /** As `take`, for an illustration call against its own cap. */
     takeArt(cap: number): string | undefined;
+    /** The deck's one device call: apart from the scene cap, but not past the quota or the clock. */
+    takeDevice(): string | undefined;
     /** One redraw of a rejected picture: not against the art cap, but against the clock and the quota. */
     takeRedraw(): string | undefined;
     seconds(): number;
 }
+/**
+ * `run`, with at most `n` calls in flight across every kind — pictures, the
+ * device call and scenes alike. The lanes of `pool` bound the scene calls only;
+ * every beat's picture starts at once, and with every beat of a deck now drawn
+ * that would put a dozen Codex processes on the machine together.
+ *
+ * `admit` is asked once a lane is free, just before the call starts: a call
+ * can wait minutes for one (drafts queue behind 240s pictures), so a budget or
+ * timeout decided when it was queued is stale by then. It returns the args to
+ * run with, or throws to refuse.
+ */
+export declare function lanes(run: Runner, n: number, admit?: (args: RunnerArgs) => RunnerArgs): Runner;
+/**
+ * The wall-time cap, applied when a call actually starts (`lanes`' admit): a
+ * call that waited past the deadline is refused, and none may run past it.
+ */
+export declare function deadlineAdmit(deadline: number, now: () => number): (args: RunnerArgs) => RunnerArgs;
+/** Grammars that need two subjects or more: a one-subject picture is staged as a zoom-out instead. */
+export declare const ONE_SUBJECT_UNSTAGEABLE: readonly string[];
 /** Below this share of the frame, a cue "barely moves" by the rubric's measure (static_hold's floor is 0.015%). */
 export declare const RUBRIC_CUE_CHANGE = 0.005;
-/** The focal size the prompt asks for; the gate's floor is `KEY_TYPE_PX`. */
-export declare const RUBRIC_FOCAL_PX = 88;
 /**
  * The share of its box a settled drawing should paint. MEASURED 2026-10-08:
  * round 1's sixteen scenes painted 3.9-15.6% (median ~9%) — thin outlines and
@@ -198,10 +287,105 @@ export declare function rubricProbe(m: Measured | undefined, warnings?: readonly
  */
 export declare const DATA_ARCHETYPES: readonly string[];
 export declare function isDataBeat(beat: Pick<Beat, "archetype">): boolean;
-/** A reply's labels, kept only where they are the shape the schema promised. */
-export declare function readLabels(raw: unknown): Label[];
 /** A reply's shot list, kept only where it is the shape the schema promised. */
 export declare function readShots(raw: unknown): Shot[];
 /** The paper the prompt may quote for this beat: its cited sections, equations and figure captions. */
 export declare function contextFor(beat: Beat, source: Source): string;
+/** One beat's device, as the deck-order pass decided it. */
+export interface BeatDevice {
+    beatId: string;
+    /** Kebab-case name of the scene's main visual device. Unique in the deck. */
+    device: string;
+    /** Whether the beat gets an illustration; otherwise its scene is pure motion graphics. */
+    illustrate: boolean;
+    /** What the scene shows, how it is composed and how it moves, when the model gave it. */
+    idea?: string;
+    /** An illustrated beat's planned setting and subjects (round 5): the deck's pictures planned together. */
+    setting?: string;
+    subjects?: string[];
+    /** Where the name came from: the model, or the rule catalogue (no call, a bad or repeated name). */
+    from: "codex" | "rule";
+    /** Illustrated only because of the picture floor (`pictureFloor`), not by the model's choice. */
+    forced?: true;
+    /** What the beat's narration does (src/bespoke/grammar.ts `roleOf`). */
+    role: Role;
+    /** An illustrated beat's camera grammar (`chooseGrammar`), never the previous illustrated beat's. */
+    grammar?: Grammar;
+    /** A data beat's build (src/bespoke/databuild.ts `chooseBuild`), never one an earlier data beat used. */
+    build?: DataBuild;
+}
+/** What `assignDevices` returns: one entry per beat, in deck order. */
+export interface DeviceAssignment {
+    beats: BeatDevice[];
+    /** `cache`: read back from a previous run, no call. */
+    from: "codex" | "cache" | "rule";
+    /** Why the model's answer was not used, or was used only in part. */
+    note?: string;
+}
+export interface DeviceOptions {
+    /** The model runner. Absent: the rule catalogue only, no call. */
+    run?: Runner;
+    /** Asked before the call: undefined lets it go ahead (src/bespoke/pipeline.ts `Budget`). */
+    take?: () => string | undefined;
+    /** Illustrations the deck may draw. */
+    artCap: number;
+    model?: string;
+    bin?: string;
+    config?: readonly string[];
+    /** Scratch for the prompt, schema and reply. */
+    work: string;
+    timeoutMs: number;
+    /** Where a decided assignment is kept, so a rerun asks nothing. */
+    cacheDir?: string;
+    onUsage?: (tokens: number) => void;
+}
+/** Bump with any change to the device prompt or the rules applied to its answer. */
+export declare const DEVICE_VERSION = "devices-2";
+/** Whether a device name is type or a UI element rather than a picture (`UI_DEVICE`). */
+export declare function isUiDevice(name: string): boolean;
+/**
+ * The fewest pictures a deck's device pass leaves it (round 6): every eligible
+ * beat, at most the art cap — the motion is the picture's own.
+ */
+export declare function pictureFloor(eligible: number, artCap: number): number;
+/** A model's name made a kebab-case device name, or "" when nothing is left of it. */
+export declare function deviceName(raw: unknown): string;
+/**
+ * THE DECK-ORDER DEVICE PASS. Runs once, before any picture or scene is asked
+ * for — scenes generate two at a time, so their devices cannot come from
+ * finished scenes — and gives every bespoke beat one visual device, no two
+ * alike, with one line on how its scene is composed. One Codex call names them
+ * from the beats' content; whatever it does not name well (or at all, or
+ * twice), and every beat when there is no call, takes the next unused name from
+ * the rule catalogue. Illustration is decided here too: every beat with two
+ * cues, data beats included (round 6), at most `artCap`.
+ *
+ * STICKY PER BEAT. A decided device is also cached under its beat's own content,
+ * and a later run whose deck changed (one beat edited, a different call cap)
+ * keeps every unchanged beat's device and idea — the call is told they are
+ * decided — so the scenes cached under them still hit; only the changed beats
+ * are named anew. Every beat decided already: no call at all.
+ *
+ * Round 5 adds a camera grammar and a data build to this same pass, in deck
+ * order: keep it one function, one typed result. It never throws: no answer, a
+ * broken cache file or a cache it cannot write all end in names.
+ */
+export declare function assignDevices(beats: readonly DeviceBeat[], opts: DeviceOptions): Promise<DeviceAssignment>;
+/**
+ * Two pictures of a deck closer than this by Vision's feature print are the
+ * same picture drawn twice. CALIBRATED 2026-10-10 on round 4's 38 pictures:
+ * pairs within a deck — all of them friendly robots, in other poses — sat at
+ * 0.49-0.89 (cross-deck 0.53-0.90), so a print alone does not see a repeated
+ * MOTIF; that is `sharedMotifs`' job. This bar catches the near-duplicate.
+ */
+export declare const SIMILAR_MAX = 0.45;
+/** The subject nouns `motifs` shares with any of `others`. */
+export declare function sharedMotifs(motifs: readonly string[], others: ReadonlyArray<readonly string[]>): string[];
+/** The stock subjects (`STOCK_MOTIFS`) a picture draws that its beat does not name. */
+export declare function stockDrawn(drawn: {
+    motifs: readonly string[];
+    depicts: string;
+}, allowed: readonly string[]): string[];
+/** How much a deck's kept pictures repeat each other (`BespokeReport.repetition`). */
+export declare function repetitionOf(arts: readonly ArtRef[]): BespokeReport["repetition"];
 export declare function bespokePass(input: BespokeInput): Promise<BespokeResult>;

package/dist/types/bespoke/probe.d.ts

@@ -27,8 +27,8 @@ export declare function attribute(f: Finding, windows: readonly SceneWindow[]):
 export declare function pinPageErrors(findings: Finding[], candidates: BespokeMap, sidOf: ReadonlyMap<string, string>): Finding[];
 /**
  * What an illustrated scene's frames say about its staging: the distinct
- * push-ins held at cue ends, whether it opens wide, and how many subjects are
- * named by a label within reach at the end. Empty for a scene with no subjects.
+ * push-ins held at cue ends and whether it opens wide. Empty for a scene with
+ * no subjects.
  */
 export declare function stagingMeasures(rows: readonly Layout[], cams: readonly CamSample[], open?: number): Partial<Measured>;
 export declare function browserGate(deck: ProbeDeck): GateFn;

package/dist/types/bespoke/prompt.d.ts

@@ -28,12 +28,14 @@
  * The placement grid is Code2Video's visual anchor prompt (arXiv 2510.01174).
  */
 import type { Theme } from "../emit/kit.js";
+import { type DataBuild } from "./databuild.js";
+import { type Grammar } from "./grammar.js";
 import { type Box, CAMERA_MAX_SCALE } from "./shots.js";
 export { CAMERA_MAX_SCALE };
 /** Bump with any change to either prompt or to a reference: it is part of every cache key. */
-export declare const PROMPT_VERSION = "bespoke-5";
+export declare const PROMPT_VERSION = "bespoke-13";
 /** Bump with any change to what `checkFragment` accepts. Also part of every key. */
-export declare const CONTRACT_VERSION = "contract-4";
+export declare const CONTRACT_VERSION = "contract-5";
 /** What the model is told about one beat. */
 export interface Brief {
     lang: string;
@@ -65,30 +67,114 @@ export interface Brief {
     /**
      * The beat's illustration, attached to the call as an image (src/bespoke/art.ts),
      * and its subjects in body-box px, left to right (src/bespoke/inspect.ts):
-     * what the labels are anchored to and the shots frame.
+     * what the shots frame.
      */
     art?: {
         depicts: string;
         width: number;
         height: number;
+        /** The picture has a backdrop layer the shell draws behind the box (round 5). */
+        plate?: boolean;
+        setting?: string;
         subjects?: Box[];
-        /** Where the shell draws each subject's label (src/bespoke/callouts.ts), and its longest fit. */
-        zones?: Array<Box & {
-            subject: number;
-            chars: number;
-        }>;
+        /**
+         * Round 6: the picture is a full-frame depth shot (src/bespoke/depth.ts) and
+         * the headline reaches this far down it, px; the scene's own layer is fixed.
+         */
+        band?: number;
     };
-    /** A data beat (a chart or a table): built as a chart, never on a picture. */
+    /** A data beat (a chart or a table). Round 6 pictures it too; without a picture it builds its chart. */
     data?: boolean;
+    /**
+     * The scene's main visual device, a short kebab-case name ('spike-train',
+     * 'fog-lift', 'edge-sweep'), given by the deck-order pass `assignDevices`
+     * (src/bespoke/pipeline.ts) before any scene is generated. Unique in a deck.
+     */
+    device: string;
+    /**
+     * The device pass's one line on what this scene shows, how it is composed and
+     * how it moves. The pass sees the whole deck, so this line — not a list of
+     * the other scenes' names — is what keeps neighbouring scenes from being
+     * composed alike; and it is the beat's own, so editing one beat does not
+     * re-key every scene after it.
+     */
+    idea?: string;
+    /** An illustrated scene's camera grammar (src/bespoke/grammar.ts), from the same pass. */
+    grammar?: Grammar;
+    /** A data scene's build (src/bespoke/databuild.ts), from the same pass. */
+    build?: DataBuild;
 }
+/** One beat as the deck-order device pass sees it. */
+export interface DeviceBeat {
+    id: string;
+    archetype: string;
+    headline: string;
+    intent: string;
+    claim?: string;
+    narration?: string;
+    /** Narration cues the scene will be keyed to. Fewer than two: no picture (the shots need two). */
+    cues: number;
+    /** A chart or table beat: never illustrated. */
+    data: boolean;
+}
+/** The device pass's structured reply. */
+export declare const DEVICE_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["beats"];
+    readonly properties: {
+        readonly beats: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "device", "illustrate", "idea", "setting", "subjects"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly device: {
+                        readonly type: "string";
+                    };
+                    readonly illustrate: {
+                        readonly type: "boolean";
+                    };
+                    readonly idea: {
+                        readonly type: "string";
+                    };
+                    readonly setting: {
+                        readonly type: "string";
+                    };
+                    readonly subjects: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+/**
+ * The deck-order device pass: one call that names, for every beat at once, the
+ * visual device its scene is built on — so no two beats of a deck look alike,
+ * which per-beat calls running two at a time cannot arrange among themselves.
+ */
+export declare function devicePrompt(beats: readonly DeviceBeat[], artCap: number, decided?: ReadonlyMap<string, {
+    device: string;
+    idea?: string;
+}>): string;
 /** What the probe measured about a candidate, quoted to the critique round. */
 export interface Measured {
     /** Bounding box of the drawing over the body box, settled frame. */
     fill?: number;
     /** Share of a 6x4 grid over the box something is drawn in. */
     cells?: number;
-    /** Largest label at the settled frame, px. */
+    /** Largest label at the settled frame, px (as rendered). */
     maxType?: number;
+    /** Largest font-size a label declares at the settled frame (KaTeX excluded), px. */
+    maxDeclared?: number;
     /** Share of the box the settled drawing paints (filled shapes count, hairlines barely). */
     mass?: number;
     /** Share of the drawn parts left dimmed (under 0.6 opacity) at the end. */
@@ -101,18 +187,18 @@ export interface Measured {
     subjects?: number;
     /** Distinct push-ins the held frames show (illustrated scenes, `shotsOf`). */
     shots?: number;
-    /** Whether the first cue opens on the whole picture. */
+    /** Whether the first cue opens as its grammar says (the whole picture; close, for a zoom-out). */
     establishing?: boolean;
-    /** Subjects named by a label within reach of them, at the end. */
-    anchored?: number;
-    /** The farthest a subject's label sits from it, box px, at the end. */
-    anchorMax?: number;
+    /** The camera grammar the scene was staged in. */
+    grammar?: string;
+    /** Round 6: the scene's own tweens that animate UI into place (`ui_motion`). */
+    uiMotion?: readonly string[];
 }
 /** The structured reply. `--output-schema` holds the model to it. */
 export declare const REPLY_SCHEMA: {
     readonly type: "object";
     readonly additionalProperties: false;
-    readonly required: readonly ["review", "plan", "markup", "css", "script", "shots", "labels"];
+    readonly required: readonly ["review", "plan", "markup", "css", "script", "shots"];
     readonly properties: {
         readonly review: {
             readonly type: "string";
@@ -129,22 +215,6 @@ export declare const REPLY_SCHEMA: {
         readonly script: {
             readonly type: "string";
         };
-        readonly labels: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["subject", "text"];
-                readonly properties: {
-                    readonly subject: {
-                        readonly type: "integer";
-                    };
-                    readonly text: {
-                        readonly type: "string";
-                    };
-                };
-            };
-        };
         readonly shots: {
             readonly type: "array";
             readonly items: {
@@ -168,15 +238,21 @@ export declare const REPLY_SCHEMA: {
 };
 /** The subjects as the prompt lists them: box px, left to right. */
 export declare function subjectLines(subjects: readonly Box[]): string;
+/**
+ * The beat's visual device, from the deck-order pass (`assignDevices`), and the
+ * devices the deck has already spent. Round 4's scenes kept arriving at the same
+ * labelled cards whatever the beat said; naming the device, and the ones not to
+ * reuse, is what makes neighbouring scenes differ.
+ */
+export declare function deviceSection(b: Pick<Brief, "device" | "idea" | "grammar" | "build">): string;
 /** The first call: draw this beat. */
 export declare function generatePrompt(b: Brief): string;
 /** The rubric the critique round scores, and the probe reads off the measures. */
-export declare const RUBRIC: readonly ["FILLS THE STAGE: the drawing uses the whole box (>= 80% of its area, no empty third or band) with visual mass — filled shapes, not hairlines", "ONE FOCUS PER CUE: in every cue one element is clearly what to look at; the rest is dimmed", "MOTION EXPLAINS: the moves are the idea (flow, transform, morph, camera, counter), at least three kinds, nothing decorative, nothing still while the voice speaks; the camera goes where the voice is", "LEGIBLE HIERARCHY: focal label/number 88px+, labels 52px+, nothing under 44px, high contrast, no collisions or clipping", "CONSISTENT WITH THE PACK: only the pack's colours, big flat shapes, strokes 5-8px, the deck's font", "IN SYNC: each cue's change starts within 0.5s of its words and nothing appears before the cue that names it"];
+export declare const RUBRIC: readonly ["FILLS THE STAGE: the drawing uses the whole box (>= 80% of its area, no empty third or band) with visual mass — filled shapes, not hairlines", "ONE FOCUS PER CUE: in every cue one element is clearly what to look at; the rest is dimmed", "MOTION EXPLAINS: the moves are the idea (flow, transform, morph, camera, counter), nothing decorative, nothing still while the voice speaks; the camera goes where the voice is; NO UI MOTION — no label, plate, chip, card or bar popped, slid or grown into place", "QUIET TYPE: few words, 40-44px, one key number or word up to 56px, nothing bigger, high contrast, no collisions or clipping — the subtitles carry the words", "CONSISTENT WITH THE PACK: only the pack's colours, big flat shapes, strokes 5-8px, the deck's font", "IN SYNC: each cue's change starts within 0.5s of its words and nothing appears before the cue that names it"];
 /** The second call: score the frames against the rubric, then fix what is wrong. */
 export declare function critiquePrompt(b: Brief, current: {
     markup: string;
     css: string;
     script: string;
     shots?: readonly unknown[];
-    labels?: readonly unknown[];
 }, findings: readonly string[], legend: string | undefined, measured?: Measured): string;

package/dist/types/bespoke/references.d.ts

@@ -13,8 +13,14 @@
  * motion-design habits round 1 lacked:
  *
  *  - THE STAGE IS FILLED: every reference spans >= 85% of its box at the end.
- *  - HIERARCHY: one 88-120px focal element per cue; labels 48-60px; nothing
- *    under 44px.
+ *  - CUE 1 STANDS FROM THE FIRST FRAME (round 6): the seam cuts to it, so the
+ *    stage is never empty between scenes (`seam_blank`).
+ *  - EVERY TWEEN IS A fromTo (AGENTS.md invariant 2), its start written out; a
+ *    later one on the same property has immediateRender:false.
+ *  - QUIET TYPE (the v2 scale, `TYPE_SCALE`, since 2026-10-10): one focal
+ *    label or number per cue at 56px at most; labels 40-44px; nothing under
+ *    40px. They were 88-120px focal and 48-60px labels, and the founder's
+ *    verdict on that was "the fonts are too large".
  *  - ONE FOCUS PER CUE: what the voice is naming is lit (accent, full opacity);
  *    what it is not is dimmed to ~0.3 — never removed, so the viewer keeps place.
  *  - IDENTITY IS KEPT: a thing that changes state moves or morphs into the new
@@ -45,13 +51,6 @@ export interface Reference {
     }>;
     duration: number;
     fragment: Fragment;
-    /** An illustrated reference's subjects, box px: what the prompt would list for its picture. */
-    subjects?: ReadonlyArray<{
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    }>;
 }
 /** The box every reference is drawn for. */
 export declare const REFERENCE_BOX: {
@@ -59,15 +58,15 @@ export declare const REFERENCE_BOX: {
     readonly height: 732;
 };
 export declare const REFERENCES: readonly Reference[];
-/** Whether a reference places the beat's illustration (and so needs a beat that has one). */
-export declare function placesArt(r: Reference): boolean;
 /** A reference with its `{{token}}` colours filled from `theme`. */
 export declare function paint(f: Fragment, theme: Theme): Fragment;
 /**
  * The two references a beat is shown: the best fit for its archetype first,
  * then the best fit that teaches a DIFFERENT motion, so every prompt carries
- * at least two verbs beyond fade-and-draw. An illustrated beat leads with the
- * staged reference and is never shown a scene that moves its own camera (the
- * shell's shots do that); a data beat leads with the chart that builds.
+ * at least two verbs beyond fade-and-draw. A beat with a picture is never shown
+ * a scene that moves its own camera (the shell's shots do that); a data beat
+ * leads with the chart that builds. (Round 6: a scene on a depth picture is
+ * shown no reference at all — src/bespoke/prompt.ts — and round 4's
+ * "illustrated" reference, labels and spotlight over the picture, is gone.)
  */
 export declare function pickReferences(archetype: string, n?: number, art?: boolean, data?: boolean): Reference[];