@plaintake/scenario 1.23.0 → 1.30.0

package/dist/index.js

@@ -1,3 +1,62 @@
+// ../schema/src/baseline.ts
+import { z } from "zod";
+var Sha256 = z.string().regex(/^[0-9a-f]{64}$/);
+var DiffCategorySchema = z.enum([
+  "step",
+  "assertion",
+  "target-name",
+  "target-role",
+  "target-bounds",
+  "timing",
+  "caption",
+  "actor"
+]);
+var SeveritySchema = z.enum(["fail", "report"]);
+var DifferenceSchema = z.object({
+  category: DiffCategorySchema,
+  severity: SeveritySchema,
+  detail: z.string()
+});
+var RectSchema = z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() });
+var SnapshotTargetSchema = z.object({
+  role: z.string().nullable(),
+  accessibleName: z.string().nullable(),
+  rect: RectSchema.nullable()
+});
+var SnapshotStepSchema = z.object({
+  stableId: z.string().min(1),
+  target: SnapshotTargetSchema.nullable(),
+  /** `null` for a step that started and never finished. */
+  durationMs: z.number().nullable()
+});
+var SemanticSnapshotSchema = z.object({
+  /** sha256 of the bundle's `scenario/scenario.ts`; `null` when the bundle has none. */
+  scenarioSha256: Sha256.nullable(),
+  steps: z.array(SnapshotStepSchema),
+  assertions: z.array(z.object({ stableId: z.string().min(1), status: z.enum(["passed", "failed"]) })),
+  /** Absent when the bundle carries no render plan — a `check` bundle. */
+  captions: z.array(z.object({ id: z.string(), lines: z.array(z.string()) })).optional(),
+  actors: z.object({
+    ids: z.array(z.string()),
+    turnOrder: z.array(z.string()),
+    /** Absent without a render plan, or for a single-actor plan. */
+    labels: z.array(z.object({ id: z.string(), label: z.string() })).optional()
+  })
+});
+var BASELINE_SCHEMA = "plaintake.baseline/v1";
+var BaselineFileSchema = z.object({
+  schema: z.literal(BASELINE_SCHEMA),
+  /** Informational only: which PlainTake wrote the file. */
+  plaintakeVersion: z.string().min(1),
+  snapshot: SemanticSnapshotSchema.extend({ scenarioSha256: Sha256 })
+});
+var BaselineStatusSchema = z.enum(["match", "drift", "scenario-changed", "absent", "skipped", "updated"]);
+var BaselineReportSchema = z.object({
+  path: z.string().min(1),
+  status: BaselineStatusSchema,
+  differences: z.array(DifferenceSchema)
+});
+
 // ../schema/src/errors.ts
 var EXIT_CODES = {
   ok: 0,
@@ -6,7 +65,8 @@ var EXIT_CODES = {
   toolchain: 3,
   capture: 4,
   render: 5,
-  verification: 6
+  verification: 6,
+  drift: 7
 };
 var DemoError = class extends Error {
   kind;
@@ -22,9 +82,9 @@ var DemoError = class extends Error {
 };
 
 // ../schema/src/event.ts
-import { z } from "zod";
-var NanosString = z.string().regex(/^\d+$/, "must be a digit-only nanosecond string");
-var DemoEventTypeSchema = z.enum([
+import { z as z2 } from "zod";
+var NanosString = z2.string().regex(/^\d+$/, "must be a digit-only nanosecond string");
+var DemoEventTypeSchema = z2.enum([
   "session.start",
   "session.finish",
   "chapter",
@@ -54,7 +114,7 @@ var DemoEventTypeSchema = z.enum([
   "turn",
   /*
    * A full-frame motion-graphics cut-away: `demo.explain(...)` stops the screencast, splices
-   * in a PlainMotion-rendered scene at this point on the timeline, and resumes the recording
+   * in a rendered motion-graphics scene at this point on the timeline, and resumes the recording
    * on the same page, same actor. A member of its own for the same reason `turn` is one: a
    * cut-away is not a step — no target, no verb, no hold — and its `payload` carries the
    * whole authored request (id, narration, scene props, cues) because the scene is compiled
@@ -64,23 +124,23 @@ var DemoEventTypeSchema = z.enum([
    */
   "explain"
 ]);
-var TargetSchema = z.object({
-  role: z.string().optional(),
-  accessibleName: z.string().optional(),
-  selector: z.string().optional(),
-  rect: z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() }).optional()
+var TargetSchema = z2.object({
+  role: z2.string().optional(),
+  accessibleName: z2.string().optional(),
+  selector: z2.string().optional(),
+  rect: z2.object({ x: z2.number(), y: z2.number(), width: z2.number(), height: z2.number() }).optional()
 });
-var DemoEventSchema = z.object({
-  schema: z.literal("agent-demo.event/v1"),
-  seq: z.number().int().nonnegative(),
+var DemoEventSchema = z2.object({
+  schema: z2.literal("agent-demo.event/v1"),
+  seq: z2.number().int().nonnegative(),
   tStartNs: NanosString,
   tEndNs: NanosString.optional(),
   type: DemoEventTypeSchema,
-  stableId: z.string().min(1).optional(),
-  title: z.string().optional(),
-  subtitle: z.string().optional(),
+  stableId: z2.string().min(1).optional(),
+  title: z2.string().optional(),
+  subtitle: z2.string().optional(),
   target: TargetSchema.optional(),
-  payload: z.record(z.string(), z.unknown()).optional(),
+  payload: z2.record(z2.string(), z2.unknown()).optional(),
   /**
    * Which actor performed this event, for a `turn` hand-off or a verb step taken during one.
    * Absent means the scenario's default actor — a single-actor event log never sets this, so
@@ -88,27 +148,34 @@ var DemoEventSchema = z.object({
    * here: the default actor's id is an application-layer notion the recorder resolves, not a
    * value this schema should invent and materialise on parse.
    */
-  actor: z.string().min(1).optional()
+  actor: z2.string().min(1).optional()
 });
 
 // ../schema/src/json-schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../schema/src/scenario.ts
-import { z as z2 } from "zod";
-var ScenarioIntroSchema = z2.object({
-  lines: z2.array(z2.string().min(1)).min(1).max(2, "intro.lines takes at most two lines \u2014 a third would have to shrink the type to fit"),
-  narration: z2.string().min(1).optional(),
-  durationMs: z2.number().int().positive().max(15e3, "intro.durationMs must be at most 15000ms").optional()
+import { z as z3 } from "zod";
+var ScenarioIntroSchema = z3.object({
+  lines: z3.array(z3.string().min(1)).min(1).max(2, "intro.lines takes at most two lines \u2014 a third would have to shrink the type to fit"),
+  narration: z3.string().min(1).optional(),
+  durationMs: z3.number().int().positive().max(15e3, "intro.durationMs must be at most 15000ms").optional()
 });
-var ScenarioCameraSchema = z2.object({
-  maxZoom: z2.number().min(1, "camera.maxZoom must be at least 1 (no zoom)").max(1.6, "camera.maxZoom must be at most 1.6 \u2014 beyond that the upscaled capture turns UI text to mush").optional(),
-  margin: z2.number().min(0, "camera.margin must be at least 0").max(2, "camera.margin must be at most 2 (as a fraction of the target, per side)").optional(),
-  easeMs: z2.number().int().min(133, "camera.easeMs must be at least 133ms").max(2e3, "camera.easeMs must be at most 2000ms").optional(),
-  minDwellMs: z2.number().int().min(0, "camera.minDwellMs must be at least 0").max(5e3, "camera.minDwellMs must be at most 5000ms").optional()
+var ScenarioHookSchema = z3.union([
+  z3.string().min(1),
+  z3.object({
+    text: z3.string().min(1),
+    durationMs: z3.number().int().min(1e3, "hook.durationMs must be at least 1000ms").max(1e4, "hook.durationMs must be at most 10000ms \u2014 past that it is a title, not a hook").optional()
+  })
+]);
+var ScenarioCameraSchema = z3.object({
+  maxZoom: z3.number().min(1, "camera.maxZoom must be at least 1 (no zoom)").max(1.6, "camera.maxZoom must be at most 1.6 \u2014 beyond that the upscaled capture turns UI text to mush").optional(),
+  margin: z3.number().min(0, "camera.margin must be at least 0").max(2, "camera.margin must be at most 2 (as a fraction of the target, per side)").optional(),
+  easeMs: z3.number().int().min(133, "camera.easeMs must be at least 133ms").max(2e3, "camera.easeMs must be at most 2000ms").optional(),
+  minDwellMs: z3.number().int().min(0, "camera.minDwellMs must be at least 0").max(5e3, "camera.minDwellMs must be at most 5000ms").optional()
 });
-var ScenarioSpeechSchema = z2.object({
-  speed: z2.number().min(0.5, "speech.speed must be at least 0.5 (half speed)").max(2, "speech.speed must be at most 2.0 (double speed) \u2014 an unmeasured, conservative ceiling").optional(),
+var ScenarioSpeechSchema = z3.object({
+  speed: z3.number().min(0.5, "speech.speed must be at least 0.5 (half speed)").max(2, "speech.speed must be at most 2.0 (double speed) \u2014 an unmeasured, conservative ceiling").optional(),
   /*
    * The voices this scenario may switch to mid-run, beyond the run-wide default `--voice`
    * picks. A step names one with `demo.step({ voice })` or an actor with `demo.actor(id,
@@ -135,24 +202,63 @@ var ScenarioSpeechSchema = z2.object({
    * A mix is refused at record time with both sides named — the run's pronunciation
    * dictionary is configured once, for the one language it speaks.
    */
-  voices: z2.array(z2.string().min(1, "speech.voices entries must be non-empty voice names")).min(1, "speech.voices must name at least one voice \u2014 an empty list declares nothing, so omit it").optional()
+  voices: z3.array(z3.string().min(1, "speech.voices entries must be non-empty voice names")).min(1, "speech.voices must name at least one voice \u2014 an empty list declares nothing, so omit it").optional()
 });
-var ScenarioMetaSchema = z2.object({
-  schema: z2.literal("agent-demo.scenario/v1"),
-  id: z2.string().regex(/^[a-z0-9][a-z0-9-]*$/, "must be a lowercase kebab-case id"),
-  title: z2.string().min(1),
-  language: z2.string().min(2).default("en"),
-  viewport: z2.object({
-    width: z2.literal(1920),
-    height: z2.literal(1080),
-    deviceScaleFactor: z2.literal(1)
+var EnvName = z3.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var TerminalMetaSchema = z3.object({
+  shell: z3.enum(["bash", "zsh", "sh"]).default("bash"),
+  command: z3.array(z3.string().min(1)).min(1).optional(),
+  cols: z3.number().int().min(40).max(200).default(120),
+  rows: z3.number().int().min(12).max(60).default(34),
+  cwd: z3.string().min(1).optional(),
+  env: z3.array(EnvName).default([]),
+  secrets: z3.array(EnvName).default([]),
+  browser: z3.boolean().optional(),
+  label: z3.string().trim().min(1).optional(),
+  transition: z3.enum(["cut", "card"]).optional()
+}).superRefine((t, ctx) => {
+  for (const field of ["label", "transition"]) {
+    if (t[field] !== void 0 && t.browser !== true) {
+      ctx.addIssue({ code: "custom", path: [field], message: `terminal.${field} needs terminal.browser: true` });
+    }
+  }
+  for (const name of t.secrets) {
+    if (!t.env.includes(name)) {
+      ctx.addIssue({ code: "custom", path: ["secrets"], message: `secret ${name} must also be listed in terminal.env` });
+    }
+  }
+});
+var ScenarioMetaSchema = z3.object({
+  schema: z3.literal("agent-demo.scenario/v1"),
+  id: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/, "must be a lowercase kebab-case id"),
+  title: z3.string().min(1),
+  language: z3.string().min(2).default("en"),
+  viewport: z3.object({
+    width: z3.literal(1920),
+    height: z3.literal(1080),
+    deviceScaleFactor: z3.literal(1)
   }),
-  locale: z2.literal("en-US"),
-  timezoneId: z2.literal("UTC"),
-  colorScheme: z2.literal("light"),
-  reducedMotion: z2.literal("reduce"),
+  /*
+   * How large the page is drawn inside the fixed 1920x1080 capture. At `s`, the page lays out
+   * at a 1920/s x 1080/s CSS viewport with deviceScaleFactor `s`, so Chromium paints every
+   * CSS pixel as s x s device pixels: the frame is still 1920x1080, the UI in it is s times
+   * larger and sharp, and the app's own responsive layout sees the narrower viewport. It is
+   * what a person gets from browser zoom, and what a vertical (`--aspect 9:16`) cut needs to
+   * stay legible once the whole frame is letterboxed to 1080 wide.
+   *
+   * `viewport` above still describes the capture, not the layout, which is why it stays a
+   * literal. Only 1.5 and 2 are offered besides 1: both divide 1920x1080 into whole CSS
+   * pixels, and both were measured (`ui-scale-dpr-spike.spec.ts`) to capture device-pixel
+   * frames headless and headed. Optional and inert when absent: every scenario written
+   * before this records exactly as it always did.
+   */
+  uiScale: z3.union([z3.literal(1), z3.literal(1.5), z3.literal(2)]).optional(),
+  locale: z3.literal("en-US"),
+  timezoneId: z3.literal("UTC"),
+  colorScheme: z3.literal("light"),
+  reducedMotion: z3.literal("reduce"),
   /** Exact console error strings the scenario tolerates. Anything else fails the run. */
-  allowedConsoleErrors: z2.array(z2.string()).default([]),
+  allowedConsoleErrors: z3.array(z3.string()).default([]),
   /*
    * Whether this scenario hands the real browser window to a person, and in which phase.
    *
@@ -170,7 +276,7 @@ var ScenarioMetaSchema = z2.object({
    * The same precedent as everywhere else here: a `.default()`, so every scenario written
    * before this parses unchanged.
    */
-  handoff: z2.enum(["none", "preflight", "session"]).default("none"),
+  handoff: z3.enum(["none", "preflight", "session"]).default("none"),
   /*
    * How long a handoff waits for the person before giving up. Not a patience limit —
    * past a few minutes, a block is indistinguishable from a hang, and the person is better
@@ -179,7 +285,7 @@ var ScenarioMetaSchema = z2.object({
    * In the schema rather than only in the runtime so `validate` catches an out-of-range
    * value with no browser and no waiting.
    */
-  handoffTimeoutMs: z2.number().int().min(5e3, "handoffTimeoutMs must be at least 5000ms").max(
+  handoffTimeoutMs: z3.number().int().min(5e3, "handoffTimeoutMs must be at least 5000ms").max(
     3e5,
     "handoffTimeoutMs must be at most 300000ms (5 minutes) \u2014 past that a wait is indistinguishable from a hang"
   ).default(12e4),
@@ -193,6 +299,12 @@ var ScenarioMetaSchema = z2.object({
    * discarded in silence rather than refused.
    */
   intro: ScenarioIntroSchema.optional(),
+  /*
+   * The hook, drawn over the top band of a portrait render. Optional on the same precedent as
+   * `intro`; a scenario without one renders exactly what it always did, and a 16:9 render of one
+   * that has it carries it undrawn.
+   */
+  hook: ScenarioHookSchema.optional(),
   /*
    * Framing overrides for this scenario's pages. Optional like everything above it, and
    * inert when absent: the defaults are the constants the camera has always used.
@@ -208,6 +320,8 @@ var ScenarioMetaSchema = z2.object({
    * comment for the field's shape and the reasoning behind `speed`'s bounds.
    */
   speech: ScenarioSpeechSchema.optional(),
+  /* A live terminal as the recorded source instead of a web page; see `TerminalMetaSchema`. */
+  terminal: TerminalMetaSchema.optional(),
   /*
    * A text-substitution dictionary applied to narration immediately before synthesis — not the
    * vendored en-us phoneme dictionary `install-voice` fetches (a different thing entirely: that
@@ -227,120 +341,167 @@ var ScenarioMetaSchema = z2.object({
    *
    * Optional and inert when absent, the same precedent as everything else on this schema.
    */
-  pronunciations: z2.record(z2.string().min(1, "pronunciation keys must not be empty"), z2.string()).optional()
+  pronunciations: z3.record(z3.string().min(1, "pronunciation keys must not be empty"), z3.string()).optional()
 });
 
 // ../schema/src/manifest.ts
-import { z as z4 } from "zod";
-var Sha256 = z4.string().regex(/^[0-9a-f]{64}$/);
-var BundleManifestSchema = z4.object({
-  schema: z4.literal("agent-demo.bundle/v1"),
-  status: z4.enum(["passed", "failed"]),
-  scenario: z4.object({ id: z4.string().min(1), sourceSha256: Sha256 }),
-  toolchain: z4.object({
-    node: z4.string(),
-    playwright: z4.string(),
-    chromiumRevision: z4.string(),
-    ffmpeg: z4.string(),
+import { z as z5 } from "zod";
+var Sha2562 = z5.string().regex(/^[0-9a-f]{64}$/);
+var BundleManifestSchema = z5.object({
+  schema: z5.literal("agent-demo.bundle/v1"),
+  status: z5.enum(["passed", "failed"]),
+  scenario: z5.object({ id: z5.string().min(1), sourceSha256: Sha2562 }),
+  toolchain: z5.object({
+    node: z5.string(),
+    playwright: z5.string(),
+    chromiumRevision: z5.string(),
+    ffmpeg: z5.string(),
     /** May be the literal "unknown" — never a fabricated version. */
-    libass: z4.string(),
-    fontSha256: Sha256,
-    containerImage: z4.string().optional(),
+    libass: z5.string(),
+    fontSha256: Sha2562,
+    containerImage: z5.string().optional(),
     /**
-     * The plainmotion CLI's own `--version` string, present exactly when a scenario called
-     * `demo.explain()` at least once — a run that never cut away never spawned it, and
-     * `containerImage`'s own optionality is the precedent for saying so with an absent field
-     * rather than a fabricated one.
+     * The plainmotion CLI's own `--version` string, present on bundles recorded by 1.28.0 or earlier
+     * whose scenario called `demo.explain()` — explain scenes were then rendered by that
+     * external CLI. Read-only now: explain scenes render in process, so nothing writes it, and
+     * it stays optional so those bundles keep verifying.
      */
-    plainmotion: z4.string().optional()
+    plainmotion: z5.string().optional()
   }),
-  environment: z4.object({
-    os: z4.string(),
+  environment: z5.object({
+    os: z5.string(),
     /** Part of the reproducibility claim: byte-identity holds per architecture. */
-    architecture: z4.string(),
-    locale: z4.literal("en-US"),
-    timezone: z4.literal("UTC"),
-    viewport: z4.tuple([z4.literal(1920), z4.literal(1080)]),
-    deviceScaleFactor: z4.literal(1)
+    architecture: z5.string(),
+    locale: z5.literal("en-US"),
+    timezone: z5.literal("UTC"),
+    /*
+     * The captured frame: 1920x1080 pixels at one pixel per video pixel, always. `uiScale`
+     * below says how the page was laid out into that frame; it never changes these two.
+     */
+    viewport: z5.tuple([z5.literal(1920), z5.literal(1080)]),
+    deviceScaleFactor: z5.literal(1),
+    /*
+     * The scenario's `uiScale`, written only when it is not 1 — so every manifest recorded
+     * before the option existed, and every one recorded without it, stays byte-identical.
+     * Recorded because it changes what every target rect in the bundle was measured against
+     * (CSS pixels times this), which a diff between two bundles must not mistake for drift.
+     */
+    uiScale: z5.union([z5.literal(1.5), z5.literal(2)]).optional()
   }),
-  assertions: z4.array(z4.object({ id: z4.string().min(1), status: z4.enum(["passed", "failed"]) })),
-  artifacts: z4.array(
-    z4.object({
-      path: z4.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "must be a relative POSIX path"),
-      sha256: Sha256,
-      bytes: z4.number().int().nonnegative(),
-      role: z4.enum(["source", "derived"])
+  assertions: z5.array(z5.object({ id: z5.string().min(1), status: z5.enum(["passed", "failed"]) })),
+  artifacts: z5.array(
+    z5.object({
+      path: z5.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "must be a relative POSIX path"),
+      sha256: Sha2562,
+      bytes: z5.number().int().nonnegative(),
+      role: z5.enum(["source", "derived"])
     })
   )
 });
 
 // ../schema/src/narration-index.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var NARRATION_INDEX_SCHEMA = "agent-demo.narration-index/v1";
-var NarrationIndexClipSchema = z5.object({
+var NarrationIndexClipSchema = z6.object({
   /** The step id, which is also the clip id and the cache filename stem. */
-  id: z5.string().min(1),
+  id: z6.string().min(1),
   /**
    * The marker-free, normalised line — `clipFor`'s `text`. Never empty: the runtime does not call
    * the narrator for a step that normalises to nothing, so an empty line here is a corrupt index.
    */
-  text: z5.string().min(1),
+  text: z6.string().min(1),
   /**
    * The author's `[pause]` segments, present only when a marker actually split the line — which is
    * two or more pieces, never one. When present it is what the cache key is built from (the pieces
    * join by NUL), so it must round-trip exactly or a warmed marked line lands under a different key
    * from the one the recording will look for.
    */
-  breaks: z5.array(z5.string().min(1)).min(2).optional(),
+  breaks: z6.array(z6.string().min(1)).min(2).optional(),
   /**
    * The resolved voice, present only when it was not the run's default (`speech.voice` below).
    * Absent means "spoken by the default", exactly as it does on the frozen plan's per-clip voice.
    */
-  voice: z5.string().min(1).optional()
+  voice: z6.string().min(1).optional()
 });
-var NarrationIndexSchema = z5.object({
-  schema: z5.literal(NARRATION_INDEX_SCHEMA),
-  speech: z5.object({
-    voice: z5.string().min(1),
-    voices: z5.array(z5.string().min(1)).optional(),
-    speed: z5.number().positive(),
-    dtype: z5.string().min(1),
-    pronunciations: z5.record(z5.string().min(1), z5.string()).optional()
+var NarrationIndexSchema = z6.object({
+  schema: z6.literal(NARRATION_INDEX_SCHEMA),
+  speech: z6.object({
+    voice: z6.string().min(1),
+    voices: z6.array(z6.string().min(1)).optional(),
+    speed: z6.number().positive(),
+    dtype: z6.string().min(1),
+    pronunciations: z6.record(z6.string().min(1), z6.string()).optional()
   }),
-  clips: z5.array(NarrationIndexClipSchema).min(1)
+  clips: z6.array(NarrationIndexClipSchema).min(1)
 });
 
 // ../schema/src/render-plan.ts
-import { z as z6 } from "zod";
-var CueSchema = z6.object({
-  id: z6.string().min(1),
-  startMs: z6.number().int().nonnegative(),
-  endMs: z6.number().int().positive(),
-  lines: z6.array(z6.string()).min(1).max(2)
-});
-var HEX_COLOUR = z6.string().regex(/^#[0-9A-Fa-f]{6}$/, "must be a #RRGGBB colour");
-var OutroSchema = z6.object({
-  durationMs: z6.number().int().positive().max(15e3),
-  lines: z6.array(z6.string().min(1)).min(1).max(2),
+import { z as z7 } from "zod";
+var CueSchema = z7.object({
+  id: z7.string().min(1),
+  startMs: z7.number().int().nonnegative(),
+  endMs: z7.number().int().positive(),
+  lines: z7.array(z7.string()).min(1).max(2),
+  /**
+   * When each word of `lines` is spoken, in video milliseconds — one entry per space-separated
+   * word of the lines joined, in order. Frozen only by a narrated recording under the social
+   * layout, whose captions light each word as the voice reaches it (`toAss`); absent everywhere
+   * else, so every other plan's cues serialise exactly as they did.
+   *
+   * Times, never invented: they are the synthesiser's own word timestamps, mapped back through
+   * the pronunciation dictionary onto the caption's words. A cue whose words those timestamps
+   * do not describe gets no `words` at all and is drawn whole, which is what a silent recording
+   * gets too.
+   */
+  words: z7.array(z7.number().int().nonnegative()).min(1).optional()
+}).refine(
+  ({ words, lines, startMs, endMs }) => words === void 0 || words.length === lines.join(" ").split(" ").filter((word) => word !== "").length && words.every((at, index) => at >= startMs && at < endMs && (index === 0 || at >= words[index - 1])),
+  {
+    message: "words must time every word of the cue, in order, inside the cue",
+    path: ["words"]
+  }
+);
+var HEX_COLOUR = z7.string().regex(/^#[0-9A-Fa-f]{6}$/, "must be a #RRGGBB colour");
+var OutroSchema = z7.object({
+  durationMs: z7.number().int().positive().max(15e3),
+  lines: z7.array(z7.string().min(1)).min(1).max(2),
   backgroundColor: HEX_COLOUR,
   textColor: HEX_COLOUR,
-  assPath: z6.literal("captions/outro.ass")
+  assPath: z7.literal("captions/outro.ass")
 });
-var IntroSchema = z6.object({
-  durationMs: z6.number().int().positive().max(15e3),
-  lines: z6.array(z6.string().min(1)).min(1).max(2),
+var IntroSchema = z7.object({
+  durationMs: z7.number().int().positive().max(15e3),
+  lines: z7.array(z7.string().min(1)).min(1).max(2),
   backgroundColor: HEX_COLOUR,
   textColor: HEX_COLOUR,
-  assPath: z6.literal("captions/intro.ass")
+  assPath: z7.literal("captions/intro.ass")
+});
+var HookSchema = z7.object({
+  lines: z7.array(z7.string().min(1)).min(1).max(2),
+  durationMs: z7.number().int().min(1e3).max(1e4),
+  assPath: z7.literal("captions/hook.ass"),
+  /**
+   * The hook drawn as a picture rather than as ASS: a transparent PNG the width of the output
+   * and as tall as the bottom of its band, rasterised in Chromium when the hook was set (at
+   * record time, or by a `render --hook`/`--aspect` re-cut) so its emoji are drawn in colour by
+   * the system's emoji face — libass can only draw them as outlines. Frozen as a source file:
+   * a plain re-render overlays it and never opens a browser. Absent, the hook is drawn from
+   * `assPath` exactly as it was before 1.30, so older bundles re-render byte-identically.
+   */
+  imagePath: z7.literal("captions/hook.png").optional()
+});
+var FrameSchema = z7.object({
+  radius: z7.number().int().positive().max(96),
+  assPath: z7.literal("captions/frame.ass")
 });
-var ChapterMarkSchema = z6.object({
-  startMs: z6.number().int().nonnegative(),
-  endMs: z6.number().int().positive(),
-  title: z6.string().min(1)
+var ChapterMarkSchema = z7.object({
+  startMs: z7.number().int().nonnegative(),
+  endMs: z7.number().int().positive(),
+  title: z7.string().min(1)
 });
-var ChaptersSchema = z6.object({
-  metadataPath: z6.literal("render/chapters.ffmetadata"),
-  marks: z6.array(ChapterMarkSchema).min(1)
+var ChaptersSchema = z7.object({
+  metadataPath: z7.literal("render/chapters.ffmetadata"),
+  marks: z7.array(ChapterMarkSchema).min(1)
 }).refine(
   ({ marks }) => marks[0]?.startMs === 0 && marks.every(
     (mark, index) => mark.endMs > mark.startMs && (index === 0 || marks[index - 1]?.endMs === mark.startMs)
@@ -353,14 +514,14 @@ var ChaptersSchema = z6.object({
     path: ["marks"]
   }
 );
-var CursorPointSchema = z6.object({
-  id: z6.string().min(1),
-  x: z6.number().int().min(0).max(1920),
-  y: z6.number().int().min(0).max(1080),
-  arriveMs: z6.number().int().nonnegative(),
-  departMs: z6.number().int().nonnegative(),
-  action: z6.enum(["click", "type", "point"]),
-  rippleMs: z6.number().int().nonnegative().optional(),
+var CursorPointSchema = z7.object({
+  id: z7.string().min(1),
+  x: z7.number().int().min(0).max(1920),
+  y: z7.number().int().min(0).max(1080),
+  arriveMs: z7.number().int().nonnegative(),
+  departMs: z7.number().int().nonnegative(),
+  action: z7.enum(["click", "type", "point"]),
+  rippleMs: z7.number().int().nonnegative().optional(),
   /**
    * Size-correction percent, applied by the emitter with `\fscx`/`\fscy`, so the arrow
    * stays one size on screen whatever the frame does to it between the cursor filter and
@@ -391,11 +552,21 @@ var CursorPointSchema = z6.object({
    * always did — so a cursor bundle from before the camera, or from before the letterbox,
    * still parses and regenerates byte-for-byte.
    */
-  scale: z6.number().int().min(1).max(400).optional()
+  scale: z7.number().int().min(1).max(400).optional(),
+  /**
+   * Present only on the first point after a hard cut (`TransitionCutSchema`): the output
+   * instant the picture changes to the next actor's segment. The pointer then does not glide
+   * from the previous point — it parks there until `cutMs` and is parked on this point from
+   * `cutMs` on, so it never slides from a terminal row into a web page over live frames, nor
+   * moves over a frozen picture. Bounded by the previous point's `departMs` and this point's
+   * `arriveMs` (`CursorSchema`'s refine). Absent everywhere else, so a cut-free plan's points
+   * are byte-identical.
+   */
+  cutMs: z7.number().int().nonnegative().optional()
 });
-var CursorSchema = z6.object({
-  assPath: z6.literal("captions/cursor.ass"),
-  points: z6.array(CursorPointSchema).min(1)
+var CursorSchema = z7.object({
+  assPath: z7.literal("captions/cursor.ass"),
+  points: z7.array(CursorPointSchema).min(1)
 }).refine(
   ({ points }) => points.every(
     (point, index) => point.arriveMs <= point.departMs && (point.rippleMs === void 0 || point.rippleMs >= point.arriveMs) && (index === 0 || points[index - 1].departMs <= point.arriveMs && points[index - 1].arriveMs < point.arriveMs)
@@ -407,19 +578,29 @@ var CursorSchema = z6.object({
     message: "points must be ordered, arrive before departing, and not overlap",
     path: ["points"]
   }
+).refine(
+  ({ points }) => points.every(
+    (point, index) => point.cutMs === void 0 || index > 0 && points[index - 1].departMs <= point.cutMs && point.cutMs <= point.arriveMs
+  ),
+  {
+    // A jump needs somewhere to jump from, and it must happen between leaving the previous
+    // point and reaching this one — anything else would show two arrows or none.
+    message: "cutMs must fall within [previous point departMs, arriveMs], never on the first point",
+    path: ["points"]
+  }
 );
-var CameraShotSchema = z6.object({
-  id: z6.string().min(1),
-  enterMs: z6.number().int().nonnegative(),
-  holdFromMs: z6.number().int().nonnegative(),
-  x: z6.number().int().min(0),
-  y: z6.number().int().min(0),
-  w: z6.number().int().positive(),
-  h: z6.number().int().positive()
+var CameraShotSchema = z7.object({
+  id: z7.string().min(1),
+  enterMs: z7.number().int().nonnegative(),
+  holdFromMs: z7.number().int().nonnegative(),
+  x: z7.number().int().min(0),
+  y: z7.number().int().min(0),
+  w: z7.number().int().positive(),
+  h: z7.number().int().positive()
 });
-var CameraSchema = z6.object({
-  commandPath: z6.literal("render/camera.cmd"),
-  shots: z6.array(CameraShotSchema).min(1)
+var CameraSchema = z7.object({
+  commandPath: z7.literal("render/camera.cmd"),
+  shots: z7.array(CameraShotSchema).min(1)
 }).refine(
   ({ shots }) => shots.every(
     (shot) => shot.x % 2 === 0 && shot.y % 2 === 0 && // Implied by the %32 and 9w/16 rules below; kept so a future relaxation of
@@ -447,39 +628,87 @@ var CameraSchema = z6.object({
     path: ["shots"]
   }
 );
-var ActorSchema = z6.object({
-  id: z6.string().min(1),
-  label: z6.string().min(1)
+var ActorSchema = z7.object({
+  id: z7.string().min(1),
+  label: z7.string().min(1)
 });
-var SegmentSchema = z6.object({
-  id: z6.string().min(1),
-  actorId: z6.string().min(1),
-  startMs: z6.number().int().nonnegative(),
-  endMs: z6.number().int().positive()
+var SegmentSchema = z7.object({
+  id: z7.string().min(1),
+  actorId: z7.string().min(1),
+  startMs: z7.number().int().nonnegative(),
+  endMs: z7.number().int().positive(),
+  /**
+   * Where this segment's frames actually sit inside the concatenated `raw/session.webm`,
+   * measured from the segment files themselves (`probeSegmentSpanMs`, last packet's pts plus
+   * its duration — the offset the concat demuxer gives the next file). Present only on plans
+   * with a hard cut or a `terminal.browser` scenario, and then on every segment (`RenderPlanSchema`'s refine): the splice trims
+   * `[sourceStartMs, sourceEndMs)` instead of the capture-derived `[startMs, endMs)`, because
+   * Chromium's WebM writer can end a segment file short of its capture window, or round a
+   * sub-second capture up to a 1 s file, and a cut's freeze would otherwise clone a frame of
+   * the wrong actor. `sourceEndMs` is the usable end — the file's span capped at `captureMs` for
+   * every segment but the last (which reads past its file's end into the head tail-pad clone, as
+   * the capture-based trim always has) — so it may stop short of the next `sourceStartMs`.
+   * `startMs`/`endMs` keep their capture-derived values regardless.
+   */
+  sourceStartMs: z7.number().int().nonnegative().optional(),
+  sourceEndMs: z7.number().int().positive().optional()
 });
-var TransitionCardSchema = z6.object({
-  fromActorId: z6.string().min(1),
-  toActorId: z6.string().min(1),
-  durationMs: z6.number().int().positive().max(15e3),
-  lines: z6.array(z6.string().min(1)).min(1).max(2),
+var TransitionCardSchema = z7.object({
+  fromActorId: z7.string().min(1),
+  toActorId: z7.string().min(1),
+  durationMs: z7.number().int().positive().max(15e3),
+  lines: z7.array(z7.string().min(1)).min(1).max(2),
   backgroundColor: HEX_COLOUR,
   textColor: HEX_COLOUR,
-  assPath: z6.string().regex(/^captions\/turn-[0-9]+\.ass$/)
+  assPath: z7.string().regex(/^captions\/turn-[0-9]+\.ass$/),
+  /**
+   * The outgoing segment's last-frame hold before this card, exactly as on a cut
+   * (`TransitionCutSchema.freezeMs`): `contentMs − trimmedSpanMs(source window)`. Only plans
+   * with measured source bounds (every plan with a cut, and every `terminal.browser` plan) carry it; a card in any other plan
+   * never does, so it parses and serialises as it always has.
+   */
+  freezeMs: z7.number().int().positive().optional()
 });
-var ExplainSegmentPlanSchema = z6.object({
-  id: z6.string().min(1),
-  segmentPath: z6.string().regex(/^explain\/[a-z0-9][a-z0-9-]*\/segment\.mp4$/),
-  durationMs: z6.number().int().positive()
+var TransitionCutSchema = z7.object({
+  kind: z7.literal("cut"),
+  fromActorId: z7.string().min(1),
+  toActorId: z7.string().min(1),
+  /**
+   * How long the outgoing segment's last frame is held before the cut (`tpad=stop_mode=clone`),
+   * so the video reaches the joint the derivation placed at the segment's content length:
+   * `contentMs − trimmedSpanMs(source window)`, present only when that is at least one frame —
+   * usually a trailing cue's overrun, but possibly a single frame (33ms) with no overrun at
+   * all, when the trim keeps one frame fewer than the content slot reserves. The joint itself
+   * still claims 0 (`transitionGapMs`). Cards and explain scenes in a source-bound plan (a cut, or `terminal.browser`) carry the
+   * same optional `freezeMs`; in a plan without source bounds nothing carries one.
+   */
+  freezeMs: z7.number().int().positive().optional()
+}).refine((cut) => cut.fromActorId !== cut.toActorId, {
+  // The same reason `runtime.ts` refuses a turn to the actor already holding the browser:
+  // a joint where nobody changes is an explain scene's, never a hand-off's.
+  message: "a cut must hand off between two different actors (fromActorId !== toActorId)",
+  path: ["toActorId"]
 });
-var HighlightRectSchema = z6.object({
-  id: z6.string().min(1),
-  x: z6.number().int().min(0),
-  y: z6.number().int().min(0),
-  width: z6.number().int().positive(),
-  height: z6.number().int().positive(),
-  startMs: z6.number().int().nonnegative(),
-  endMs: z6.number().int().positive(),
-  label: z6.string().min(1).optional(),
+var TransitionSchema = z7.union([TransitionCardSchema, TransitionCutSchema]);
+var ExplainSegmentPlanSchema = z7.object({
+  id: z7.string().min(1),
+  segmentPath: z7.string().regex(/^explain\/[a-z0-9][a-z0-9-]*\/segment\.mp4$/),
+  durationMs: z7.number().int().positive(),
+  /**
+   * The hold on the capture segment *before* this scene, as on a cut or card joint
+   * (`TransitionCutSchema.freezeMs`). Only in plans with measured source bounds.
+   */
+  freezeMs: z7.number().int().positive().optional()
+});
+var HighlightRectSchema = z7.object({
+  id: z7.string().min(1),
+  x: z7.number().int().min(0),
+  y: z7.number().int().min(0),
+  width: z7.number().int().positive(),
+  height: z7.number().int().positive(),
+  startMs: z7.number().int().nonnegative(),
+  endMs: z7.number().int().positive(),
+  label: z7.string().min(1).optional(),
   /**
    * The rect the spotlight glides *from*, when this window's cutout should animate rather
    * than cut straight to the held `x`/`y`/`width`/`height` — the pre-reveal position a
@@ -491,11 +720,11 @@ var HighlightRectSchema = z6.object({
    * whole span — so every plan frozen before this field existed, and every window a future
    * derivation decides not to glide, is unaffected by construction.
    */
-  from: z6.object({
-    x: z6.number().int().min(0),
-    y: z6.number().int().min(0),
-    width: z6.number().int().positive(),
-    height: z6.number().int().positive()
+  from: z7.object({
+    x: z7.number().int().min(0),
+    y: z7.number().int().min(0),
+    width: z7.number().int().positive(),
+    height: z7.number().int().positive()
   }).optional(),
   /**
    * The absolute video-ms at which the glide from `from` completes and the spotlight
@@ -504,7 +733,7 @@ var HighlightRectSchema = z6.object({
    * has to be real time left to glide across) and no later than `endMs` (the window
    * cannot settle after it has already closed).
    */
-  settleMs: z6.number().int().positive().optional()
+  settleMs: z7.number().int().positive().optional()
 }).refine(({ x, y, width, height }) => x + width <= 1920 && y + height <= 1080, {
   // Unlike CameraShotSchema's crop window, a highlight rect is drawn by libass, not fed to
   // `crop` — there is no yuv420p even-pixel rule to enforce — but it still has to fit the
@@ -534,9 +763,9 @@ var HighlightRectSchema = z6.object({
   message: "settleMs must be strictly after startMs and no later than endMs",
   path: ["settleMs"]
 });
-var HighlightSchema = z6.object({
-  assPath: z6.literal("captions/highlight.ass"),
-  rects: z6.array(HighlightRectSchema).min(1)
+var HighlightSchema = z7.object({
+  assPath: z7.literal("captions/highlight.ass"),
+  rects: z7.array(HighlightRectSchema).min(1)
 }).refine(
   ({ rects }) => rects.every(
     (rect, index) => rect.endMs > rect.startMs && (index === 0 || rects[index - 1].endMs <= rect.startMs)
@@ -546,8 +775,8 @@ var HighlightSchema = z6.object({
     path: ["rects"]
   }
 );
-var SpeechClipSchema = z6.object({
-  id: z6.string().min(1),
+var SpeechClipSchema = z7.object({
+  id: z7.string().min(1),
   /*
    * Bundle-relative and unescapable by construction: no slash, no leading dot, so `..` and
    * an absolute path are both unrepresentable. The renderer's `assertBundleRelative` says
@@ -561,10 +790,10 @@ var SpeechClipSchema = z6.object({
    * character the recorder could have replaced. `narration.test.ts` asserts the two agree on a
    * table of candidates, because a comment cannot.
    */
-  path: z6.string().regex(/^speech\/clips\/[A-Za-z0-9][A-Za-z0-9._-]*\.wav$/),
-  atMs: z6.number().int().nonnegative(),
-  durationMs: z6.number().int().positive(),
-  source: z6.enum(["synth", "file", "explain"]),
+  path: z7.string().regex(/^speech\/clips\/[A-Za-z0-9][A-Za-z0-9._-]*\.wav$/),
+  atMs: z7.number().int().nonnegative(),
+  durationMs: z7.number().int().positive(),
+  source: z7.enum(["synth", "file", "explain"]),
   /*
    * Which voice synthesised this clip, when it was not the plan-wide default that
    * `engine.voice` names. Absent on every clip of a one-voice recording and on every
@@ -580,16 +809,16 @@ var SpeechClipSchema = z6.object({
    * Optional and additive: every bundle frozen before per-step voices existed carries no
    * `voice` on any clip and must keep verifying, which is what `optional()` buys.
    */
-  voice: z6.string().min(1).optional()
+  voice: z7.string().min(1).optional()
 });
-var SpeechEngineSchema = z6.object({
-  name: z6.string().min(1),
-  version: z6.string().min(1),
-  modelSha256: z6.string().regex(/^[0-9a-f]{64}$/),
-  voice: z6.string().min(1)
+var SpeechEngineSchema = z7.object({
+  name: z7.string().min(1),
+  version: z7.string().min(1),
+  modelSha256: z7.string().regex(/^[0-9a-f]{64}$/),
+  voice: z7.string().min(1)
 });
-var SpeechSchema = z6.object({
-  trackPath: z6.literal("speech/narration.wav"),
+var SpeechSchema = z7.object({
+  trackPath: z7.literal("speech/narration.wav"),
   /*
    * 24 kHz mono, because that is what Kokoro emits and nothing on this path resamples.
    * Written as literals rather than imported from `@plaintake/audio`, which owns the
@@ -597,10 +826,26 @@ var SpeechSchema = z6.object({
    * be the cycle `no-circular` refuses. `packages/audio/src/wav.test.ts` asserts the two
    * agree, since a comment cannot.
    */
-  sampleRate: z6.literal(24e3),
-  channels: z6.literal(1),
-  clips: z6.array(SpeechClipSchema).min(1),
-  engine: SpeechEngineSchema.optional()
+  sampleRate: z7.literal(24e3),
+  channels: z7.literal(1),
+  clips: z7.array(SpeechClipSchema).min(1),
+  engine: SpeechEngineSchema.optional(),
+  /**
+   * Normalise the assembled track's integrated loudness (ITU-R BS.1770) to `targetLufs`, with
+   * a make-up gain and a lookahead limiter that holds every sample at or under `maxPeakDbfs`.
+   * The short-form platforms play every upload at about -14 LUFS and turn a quieter one down
+   * no further — they only ever turn a louder one *down* — so an unnormalised narration simply
+   * plays quieter than everything around it.
+   *
+   * A target, not a gain: the gain and the limiting are a pure function of the frozen clips
+   * (`normalizeLoudness`, `@plaintake/audio`) recomputed by every freeze in a fixed sequence of
+   * double-precision operations, so the same clips always produce the same track. Absent means the clips are laid out at the level they
+   * were synthesised at, which is every plan before this field.
+   */
+  loudness: z7.object({
+    targetLufs: z7.number().min(-30).max(-5),
+    maxPeakDbfs: z7.number().min(-12).max(0)
+  }).optional()
 }).refine(
   ({ clips }) => new Set(clips.map((clip) => clip.id)).size === clips.length && clips.every(
     (clip, index) => index === 0 || clips[index - 1].atMs + clips[index - 1].durationMs <= clip.atMs
@@ -620,19 +865,19 @@ var SpeechSchema = z6.object({
   // A synthesised clip with no record of what synthesised it is the one state this block
   // exists to prevent. The converse is fine: an engine recorded on an all-file track is
   // merely redundant, not misleading. An `explain` clip is exempt rather than overlooked:
-  // it was synthesised by plainmotion, whose identity the manifest's toolchain block
-  // carries — the `engine` here would name a synthesiser that never touched it.
+  // its scene's own frozen plan records what synthesised it — the `engine` here names the
+  // step narrator's identity, which an explain scene's voice need not share.
   message: "engine must be recorded whenever any clip was synthesised",
   path: ["engine"]
 });
-var ThemeSchema = z6.object({ accentColor: HEX_COLOUR });
+var ThemeSchema = z7.object({ accentColor: HEX_COLOUR });
 var RENDER_PLAN_SCHEMA = "agent-demo.render/v1";
-var RenderPlanSchema = z6.object({
-  schema: z6.literal(RENDER_PLAN_SCHEMA),
-  source: z6.object({
-    path: z6.literal("raw/session.webm"),
-    sha256: z6.string().regex(/^[0-9a-f]{64}$/),
-    durationMs: z6.number().int().nonnegative()
+var RenderPlanSchema = z7.object({
+  schema: z7.literal(RENDER_PLAN_SCHEMA),
+  source: z7.object({
+    path: z7.literal("raw/session.webm"),
+    sha256: z7.string().regex(/^[0-9a-f]{64}$/),
+    durationMs: z7.number().int().nonnegative()
   }),
   /**
    * The frame. **Three geometries live here and they are not the same thing**, which is the
@@ -694,23 +939,47 @@ var RenderPlanSchema = z6.object({
    * one would be backwards — a plan is frozen once and rendered later, so both belong at the
    * parse, not at the encode.
    */
-  video: z6.object({
-    width: z6.number().int().positive().multipleOf(2),
-    height: z6.number().int().positive().multipleOf(2),
-    fps: z6.literal(30),
-    pixelFormat: z6.literal("yuv420p"),
-    capture: z6.object({ width: z6.literal(1920), height: z6.literal(1080) }).default({ width: 1920, height: 1080 }),
-    letterbox: z6.object({
-      width: z6.number().int().positive().multipleOf(2),
-      height: z6.number().int().positive().multipleOf(2),
-      x: z6.number().int().nonnegative().multipleOf(2),
-      y: z6.number().int().nonnegative().multipleOf(2),
+  video: z7.object({
+    width: z7.number().int().positive().multipleOf(2),
+    height: z7.number().int().positive().multipleOf(2),
+    fps: z7.literal(30),
+    pixelFormat: z7.literal("yuv420p"),
+    capture: z7.object({ width: z7.literal(1920), height: z7.literal(1080) }).default({ width: 1920, height: 1080 }),
+    letterbox: z7.object({
+      width: z7.number().int().positive().multipleOf(2),
+      height: z7.number().int().positive().multipleOf(2),
+      x: z7.number().int().nonnegative().multipleOf(2),
+      y: z7.number().int().nonnegative().multipleOf(2),
       /**
        * The fill for everything the box does not cover. `#RRGGBB` for the reason
        * `OutroSchema`'s colours are: the value reaches an FFmpeg filtergraph, and that
        * grammar admits no metacharacter.
        */
-      padColor: HEX_COLOUR
+      padColor: HEX_COLOUR,
+      /**
+       * `follow` — the `--reframe follow` opt-in — fills the box with a 4:3 window of the
+       * capture that follows the camera shots (or a fixed centre window with no camera),
+       * instead of the whole 16:9 frame. The one place this plan crops the picture for its
+       * shape rather than for a zoom, and still a render-time decision: the window is a
+       * pure function of `camera.shots` and this box (`followWindow`, `renderer-ffmpeg`),
+       * so a bundle re-cuts into or out of it without re-recording. Absent means the whole
+       * frame is scaled in — every plan before this field, unchanged.
+       */
+      reframe: z7.literal("follow").optional(),
+      /**
+       * The two layouts that treat the picture as an object on a background rather than as
+       * the background itself — `--reframe social` and `--reframe inset`:
+       *
+       * - `social` (9:16, always `follow`): a 9:8 follow window in a box sized and placed for
+       *   short-form feeds — clear of the platforms' own top bar, bottom caption block and
+       *   right-hand action rail — with a band above it for the `hook`, bold captions below it,
+       *   and rounded corners on a branded pad;
+       * - `inset` (16:9, never `follow`): the whole frame scaled into a box inset from every
+       *   edge, with rounded corners on a branded pad.
+       *
+       * Absent means the plain letterbox or follow box — every plan before these, unchanged.
+       */
+      layout: z7.enum(["social", "inset"]).optional()
     }).optional(),
     /*
      * Everything before the closing card: the opening card, if there is one, plus the
@@ -727,8 +996,8 @@ var RenderPlanSchema = z6.object({
      * With no intro it is exactly what it always was, which is what keeps a plan without
      * one byte-identical to what earlier versions wrote.
      */
-    durationMs: z6.number().int().positive(),
-    tailPadMs: z6.number().int().nonnegative()
+    durationMs: z7.number().int().positive(),
+    tailPadMs: z7.number().int().nonnegative()
   }).refine(
     ({ width, height, letterbox }) => letterbox === void 0 || letterbox.x + letterbox.width <= width && letterbox.y + letterbox.height <= height,
     {
@@ -741,13 +1010,28 @@ var RenderPlanSchema = z6.object({
       message: "the letterbox box must fit inside the output frame",
       path: ["letterbox"]
     }
+  ).refine(
+    ({ letterbox }) => letterbox?.reframe === void 0 || (letterbox.layout === "social" ? letterbox.width * 8 === letterbox.height * 9 : letterbox.width * 3 === letterbox.height * 4),
+    {
+      // The follow window is cut to the box's own shape and scaled into it with no further
+      // correction, so a box of any other shape would freeze a stretched picture: 4:3 for the
+      // plain follow box, 9:8 for the social one.
+      message: "a follow letterbox must be exactly 4:3 (9:8 under the social layout)",
+      path: ["letterbox"]
+    }
+  ).refine(
+    ({ letterbox }) => letterbox?.layout === void 0 || (letterbox.layout === "social" ? letterbox.reframe === "follow" : letterbox.reframe === void 0),
+    {
+      message: "the social layout always follows the camera and the inset layout never does",
+      path: ["letterbox"]
+    }
   ),
-  captions: z6.object({
-    language: z6.string().min(2),
-    srtPath: z6.literal("captions/captions.srt"),
-    vttPath: z6.literal("captions/captions.vtt"),
-    assPath: z6.literal("captions/captions.ass"),
-    cues: z6.array(CueSchema)
+  captions: z7.object({
+    language: z7.string().min(2),
+    srtPath: z7.literal("captions/captions.srt"),
+    vttPath: z7.literal("captions/captions.vtt"),
+    assPath: z7.literal("captions/captions.ass"),
+    cues: z7.array(CueSchema)
   }),
   /**
    * How the burned-in captions were drawn. This is the **source** of
@@ -761,18 +1045,18 @@ var RenderPlanSchema = z6.object({
    * older reader ignoring fields it does not know still executes the same frozen arguments
    * over the same frozen ASS. That observation generalises to the schema as a whole.
    */
-  style: z6.object({
-    fontFile: z6.literal("assets/fonts/NotoSans-Regular.ttf"),
-    fontName: z6.literal("Noto Sans"),
-    fontSize: z6.number().int().positive(),
-    textColor: z6.string(),
-    outlineColor: z6.string(),
+  style: z7.object({
+    fontFile: z7.literal("assets/fonts/NotoSans-Regular.ttf"),
+    fontName: z7.literal("Noto Sans"),
+    fontSize: z7.number().int().positive(),
+    textColor: z7.string(),
+    outlineColor: z7.string(),
     /** ASS `Outline`: a stroke width under `BorderStyle 1`, box padding under `BorderStyle 4`. */
-    outlineWidth: z6.number().int().nonnegative(),
-    marginBottom: z6.number().int().nonnegative(),
-    marginSide: z6.number().int().nonnegative().default(80),
-    borderStyle: z6.union([z6.literal(1), z6.literal(4)]).default(1),
-    outlineOpacity: z6.number().min(0).max(1).default(1),
+    outlineWidth: z7.number().int().nonnegative(),
+    marginBottom: z7.number().int().nonnegative(),
+    marginSide: z7.number().int().nonnegative().default(80),
+    borderStyle: z7.union([z7.literal(1), z7.literal(4)]).default(1),
+    outlineOpacity: z7.number().min(0).max(1).default(1),
     boxColor: HEX_COLOUR.default("#000000"),
     /*
      * Opaque, which under the `BorderStyle 1` default draws nothing at all: `BackColour` is
@@ -780,7 +1064,7 @@ var RenderPlanSchema = z6.object({
      * and ASS's own default, so a plan frozen before this field existed regenerates its ASS
      * byte-for-byte rather than byte-for-byte-except-one-field-nobody-can-see.
      */
-    boxOpacity: z6.number().min(0).max(1).default(1),
+    boxOpacity: z7.number().min(0).max(1).default(1),
     /**
      * ASS `\an` alignment: which edge of the frame the caption block is anchored to, and
      * therefore which margin `marginBottom` is measured from.
@@ -799,15 +1083,25 @@ var RenderPlanSchema = z6.object({
      * remaining code, middle-centre (5), would put the words back over the picture — which
      * is the thing the letterbox exists to stop.
      */
-    alignment: z6.union([z6.literal(2), z6.literal(8)]).default(2)
+    alignment: z7.union([z7.literal(2), z7.literal(8)]).default(2),
+    /**
+     * The social layout's captions: bold, every character drawn by an explicitly chosen face
+     * (`faceRuns`, `@plaintake/subtitles`, so an emoji or an arrow never depends on the font
+     * provider's fallback), and — on a cue that carries `words` — each word lit in
+     * `highlightColor` as it is spoken, the short-form convention. Absent means the caption style
+     * every other plan has, so its ASS is byte-for-byte what it was.
+     */
+    social: z7.object({ highlightColor: HEX_COLOUR }).optional()
   }),
-  ffmpeg: z6.object({
-    base: z6.array(z6.string()),
-    soft: z6.array(z6.string()),
-    hard: z6.array(z6.string())
+  ffmpeg: z7.object({
+    base: z7.array(z7.string()),
+    soft: z7.array(z7.string()),
+    hard: z7.array(z7.string())
   }),
   intro: IntroSchema.optional(),
   outro: OutroSchema.optional(),
+  hook: HookSchema.optional(),
+  frame: FrameSchema.optional(),
   chapters: ChaptersSchema.optional(),
   cursor: CursorSchema.optional(),
   camera: CameraSchema.optional(),
@@ -862,15 +1156,15 @@ var RenderPlanSchema = z6.object({
    * argument arrays from the plan, and read this field (via `outputOf`) so a re-cut writes
    * the file the original recording wrote rather than the fallback name.
    */
-  outputPath: z6.string().regex(/^output\/[a-z0-9][a-z0-9-]*\.mp4$/, "must be output/<scenario-id>.mp4, a kebab-case id").optional(),
+  outputPath: z7.string().regex(/^output\/[a-z0-9][a-z0-9-]*\.mp4$/, "must be output/<scenario-id>.mp4, a kebab-case id").optional(),
   /**
    * The capture timeline cut into windows — of a genuine multi-actor cast, of an implicit
    * single actor pausing for explain cut-aways, or both at once. `segments` is the one
    * field of the five below that a segmented capture *always* carries; the other four are
    * two independent, narrower capabilities layered on top of it:
    *
-   * - `actors`/`transitionCards`/`badgesAssPath` — the multi-actor demo's cast, the cards
-   *   drawn at each hand-off, and the badge track naming the active actor throughout. Three
+   * - `actors`/`transitionCards`/`badgesAssPath` — the multi-actor demo's cast, the card
+   *   drawn (or the hard cut taken — `TransitionCutSchema`, zero screen time) at each hand-off, and the badge track naming the active actor throughout. Three
    *   fields that carry one capability and so, like every other optional block above, are
    *   present or absent together (the first refinement below) — and never without
    *   `segments`, which they reference by `actorId` (the second). Absent means no genuine
@@ -879,18 +1173,18 @@ var RenderPlanSchema = z6.object({
    *   whenever a scenario called `demo.explain()` at all, with or without a cast alongside
    *   it — never without `segments` either (the third refinement), for the same reason.
    *
-   * Every gap between adjacent `segments` is claimed by exactly one occupant, a card or an
-   * explain scene, never both and never neither (the fifth refinement) — which is also why
+   * Every gap between adjacent `segments` is claimed by exactly one occupant, a card, a cut or
+   * an explain scene — a cut claims its gap with zero screen time, but it still claims it — never both and never neither (the fifth refinement) — which is also why
    * `segments` can appear with `transitionCards` and `explainSegments` both absent only when
    * `segments.length === 1` never occurs (`SegmentSchema`'s own `.min(2)` on the array rules
    * it out): a lone, unsegmented capture has no gap to claim in the first place, and needs
    * none of these five fields at all.
    */
-  actors: z6.array(ActorSchema).min(2).optional(),
-  segments: z6.array(SegmentSchema).min(2).optional(),
-  transitionCards: z6.array(TransitionCardSchema).min(1).optional(),
-  badgesAssPath: z6.literal("captions/badges.ass").optional(),
-  explainSegments: z6.array(ExplainSegmentPlanSchema).min(1).optional()
+  actors: z7.array(ActorSchema).min(2).optional(),
+  segments: z7.array(SegmentSchema).min(2).optional(),
+  transitionCards: z7.array(TransitionSchema).min(1).optional(),
+  badgesAssPath: z7.literal("captions/badges.ass").optional(),
+  explainSegments: z7.array(ExplainSegmentPlanSchema).min(1).optional()
 }).refine(
   (plan) => {
     const castFields = [plan.actors, plan.transitionCards, plan.badgesAssPath];
@@ -903,7 +1197,12 @@ var RenderPlanSchema = z6.object({
     message: "actors, transitionCards and badgesAssPath must be present together or absent together",
     path: ["actors"]
   }
-).refine((plan) => plan.actors === void 0 || plan.segments !== void 0, {
+).refine((plan) => plan.frame === void 0 || plan.video.letterbox?.layout !== void 0, {
+  // Corners are drawn on the box a layout lays the picture in; a plan with no such box has no
+  // corner to round, and drawing one anyway would paint pad colour over the picture itself.
+  message: "frame needs a social or inset letterbox to round the corners of",
+  path: ["frame"]
+}).refine((plan) => plan.actors === void 0 || plan.segments !== void 0, {
   // A cast with nowhere to draw its own windows — `segment.actorId` is what a badge or a
   // transition card is drawn against — cannot render.
   message: "actors requires segments \u2014 a cast with no capture windows of its own cannot render",
@@ -928,6 +1227,24 @@ var RenderPlanSchema = z6.object({
     message: "segments must tile raw/session.webm contiguously from 0",
     path: ["segments"]
   }
+).refine(
+  (plan) => {
+    if (plan.segments === void 0) return true;
+    const { segments } = plan;
+    const sourced = segments.filter(
+      (segment) => segment.sourceStartMs !== void 0 || segment.sourceEndMs !== void 0
+    );
+    if (sourced.length === 0) return true;
+    return segments.every(
+      (segment, index) => segment.sourceStartMs !== void 0 && segment.sourceEndMs !== void 0 && segment.sourceEndMs > segment.sourceStartMs && (index === 0 || segment.sourceStartMs >= segments[index - 1].sourceEndMs)
+    );
+  },
+  {
+    // All or none: a splice that trimmed some segments by measured source position and the
+    // rest by capture position would mix two coordinate systems in one graph.
+    message: "sourceStartMs/sourceEndMs must be present on every segment or on none, each window non-empty and in order without overlap",
+    path: ["segments"]
+  }
 ).refine(
   (plan) => {
     if (plan.segments === void 0) return true;
@@ -961,95 +1278,108 @@ var RenderPlanSchema = z6.object({
 );
 
 // ../schema/src/results.ts
-import { z as z7 } from "zod";
-var RELATIVE_POSIX = z7.string().regex(/^[A-Za-z0-9.][A-Za-z0-9._/-]*$/, "must be a relative POSIX path").refine((value) => !value.split("/").includes(".."), "must not traverse upwards");
-var Sha2562 = z7.string().regex(/^[0-9a-f]{64}$/);
-var DISPLAY_PATH = z7.string().min(1);
+import { z as z8 } from "zod";
+var RELATIVE_POSIX = z8.string().regex(/^[A-Za-z0-9.][A-Za-z0-9._/-]*$/, "must be a relative POSIX path").refine((value) => !value.split("/").includes(".."), "must not traverse upwards");
+var Sha2563 = z8.string().regex(/^[0-9a-f]{64}$/);
+var DISPLAY_PATH = z8.string().min(1);
 var envelope = (kind) => ({
-  schema: z7.literal("agent-demo.result/v1"),
-  kind: z7.literal(kind),
-  ok: z7.boolean(),
+  schema: z8.literal("agent-demo.result/v1"),
+  kind: z8.literal(kind),
+  ok: z8.boolean(),
   /** Human-readable failures. Empty iff ok. */
-  problems: z7.array(z7.string())
+  problems: z8.array(z8.string())
 });
-var ArtifactRefSchema = z7.object({
+var ArtifactRefSchema = z8.object({
   path: RELATIVE_POSIX,
-  sha256: Sha2562,
-  bytes: z7.number().int().nonnegative()
+  sha256: Sha2563,
+  bytes: z8.number().int().nonnegative()
 });
-var StreamSummarySchema = z7.object({
-  container: z7.enum(["mp4", "webm", "other"]),
-  durationMs: z7.number().int().nonnegative(),
-  video: z7.object({
-    codec: z7.string(),
-    width: z7.number().int(),
-    height: z7.number().int(),
-    pixelFormat: z7.string(),
-    fps: z7.number().int(),
-    frames: z7.number().int(),
+var StreamSummarySchema = z8.object({
+  container: z8.enum(["mp4", "webm", "other"]),
+  durationMs: z8.number().int().nonnegative(),
+  video: z8.object({
+    codec: z8.string(),
+    width: z8.number().int(),
+    height: z8.number().int(),
+    pixelFormat: z8.string(),
+    fps: z8.number().int(),
+    frames: z8.number().int(),
     /**
      * The video stream's own duration, as distinct from the container's above. The
      * constant-rate check measures frames against this, because a padded narration track makes
      * the container's duration the audio's. Zero for a WebM, which carries no per-track
      * duration at all.
      */
-    durationMs: z7.number().int().nonnegative()
+    durationMs: z8.number().int().nonnegative()
   }),
-  subtitles: z7.array(z7.object({ codec: z7.string(), language: z7.string(), title: z7.string() })),
+  subtitles: z8.array(z8.object({ codec: z8.string(), language: z8.string(), title: z8.string() })),
   /** Properties, not a count — a narration track muxed in stereo or at the wrong rate
    * still counts as one stream. */
-  audio: z7.array(
-    z7.object({
-      codec: z7.string(),
-      sampleRate: z7.number().int().nonnegative(),
-      channels: z7.number().int().nonnegative()
+  audio: z8.array(
+    z8.object({
+      codec: z8.string(),
+      sampleRate: z8.number().int().nonnegative(),
+      channels: z8.number().int().nonnegative()
     })
   ),
   /** Titled chapters make FFmpeg's MP4 muxer add a `bin_data` track beside the `chpl` atom. */
-  dataStreams: z7.number().int().nonnegative(),
-  chapters: z7.array(
-    z7.object({
-      startMs: z7.number().int().nonnegative(),
-      endMs: z7.number().int().nonnegative(),
-      title: z7.string()
+  dataStreams: z8.number().int().nonnegative(),
+  chapters: z8.array(
+    z8.object({
+      startMs: z8.number().int().nonnegative(),
+      endMs: z8.number().int().nonnegative(),
+      title: z8.string()
     })
   )
 });
-var ToolchainSchema = z7.object({
-  node: z7.string(),
-  playwright: z7.string(),
-  chromiumRevision: z7.string(),
-  ffmpeg: z7.string(),
+var ToolchainSchema = z8.object({
+  node: z8.string(),
+  playwright: z8.string(),
+  chromiumRevision: z8.string(),
+  ffmpeg: z8.string(),
   /** May be the literal "unknown" — never fabricated. */
-  libass: z7.string(),
-  fontSha256: Sha2562
+  libass: z8.string(),
+  fontSha256: Sha2563
 });
-var AssertionSchema = z7.object({ id: z7.string().min(1), status: z7.enum(["passed", "failed"]) });
-var StatusSchema = z7.enum(["passed", "failed"]);
-var VariantsSchema = z7.enum(["soft", "hard"]);
-var ValidationResultSchema = z7.object({
+var AssertionSchema = z8.object({ id: z8.string().min(1), status: z8.enum(["passed", "failed"]) });
+var StatusSchema = z8.enum(["passed", "failed"]);
+var VariantsSchema = z8.enum(["soft", "hard"]);
+var ValidationResultSchema = z8.object({
   ...envelope("validate"),
   /** Absent when the scenario could not be loaded at all. */
-  scenario: z7.object({
-    id: z7.string(),
-    title: z7.string(),
-    language: z7.string(),
+  scenario: z8.object({
+    id: z8.string(),
+    title: z8.string(),
+    language: z8.string(),
     /**
      * Whether this scenario needs a person, and in which phase. Reported so an author
      * — or an agent reading `--json` — learns that a scenario cannot run unattended
      * without first trying to run it. Defaulted, so a result written before this parses.
      */
-    handoff: z7.enum(["none", "preflight", "session"]).default("none"),
-    sha256: Sha2562
+    handoff: z8.enum(["none", "preflight", "session"]).default("none"),
+    sha256: Sha2563,
+    /**
+     * The terminal the scenario records instead of a web page, with its defaults applied, or
+     * null for a browser scenario. Defaulted like `handoff`, so a result written before
+     * terminals existed parses.
+     */
+    terminal: z8.object({
+      cols: z8.number().int(),
+      rows: z8.number().int(),
+      shell: z8.string(),
+      command: z8.array(z8.string()).optional(),
+      /** Present (true) only when the scenario declares `terminal.browser`. */
+      browser: z8.literal(true).optional()
+    }).nullable().default(null)
   }).optional()
 });
-var RunCommandResultSchema = z7.object({
+var RunCommandResultSchema = z8.object({
   ...envelope("run"),
   bundleDir: DISPLAY_PATH,
   status: StatusSchema,
-  cueCount: z7.number().int().nonnegative(),
+  cueCount: z8.number().int().nonnegative(),
   /** Zero on the Free Tier, and zero for a scenario with no `chapter` calls. */
-  chapterCount: z7.number().int().nonnegative(),
+  chapterCount: z8.number().int().nonnegative(),
   /**
    * How many lines the video speaks. Zero for a silent run, which is the default.
    *
@@ -1058,119 +1388,130 @@ var RunCommandResultSchema = z7.object({
    * scenario whose steps carry no `subtitle`, which produces a perfectly valid silent video and
    * would look like the feature being broken rather than like nothing having been written to say.
    */
-  narratedCount: z7.number().int().nonnegative(),
-  diagnostics: z7.array(z7.object({ code: z7.string(), cueId: z7.string(), detail: z7.string() })),
-  assertions: z7.array(AssertionSchema),
-  outputs: z7.array(ArtifactRefSchema),
+  narratedCount: z8.number().int().nonnegative(),
+  diagnostics: z8.array(z8.object({ code: z8.string(), cueId: z8.string(), detail: z8.string() })),
+  assertions: z8.array(AssertionSchema),
+  outputs: z8.array(ArtifactRefSchema),
   /**
    * The previous bundle this run replaced, archived as a `.<timestamp>` sibling rather
    * than deleted. Absent when nothing occupied the output directory — the common first
    * run — or when `--no-archive` asked for the old replace semantics. Optional and
    * additive, so every result written before archives existed still parses.
    */
-  archivedPath: DISPLAY_PATH.optional()
+  archivedPath: DISPLAY_PATH.optional(),
+  /**
+   * The capture-drift verdict against `<name>.baseline.json` beside the scenario. Absent when
+   * the recording failed (a failed recording is not evidence of drift) and in every result
+   * written before baselines existed, so it is optional and additive.
+   */
+  baseline: BaselineReportSchema.optional()
 });
-var CheckAssertionSchema = AssertionSchema.extend({ message: z7.string().optional() });
-var CheckCommandResultSchema = z7.object({
+var CheckAssertionSchema = AssertionSchema.extend({ message: z8.string().optional() });
+var CheckCommandResultSchema = z8.object({
   ...envelope("check"),
   bundleDir: DISPLAY_PATH,
   status: StatusSchema,
-  assertions: z7.array(CheckAssertionSchema),
+  assertions: z8.array(CheckAssertionSchema),
   /**
    * Handoff notes, plus a `speech.close` note when closing the narrator failed after
    * capture. Cue, chapter, cursor and camera diagnostics are all derived from a render plan
    * that `check` never builds — fabricating them would report on capabilities this command
    * cannot see.
    */
-  diagnostics: z7.array(z7.object({ code: z7.string(), cueId: z7.string(), detail: z7.string() }))
+  diagnostics: z8.array(z8.object({ code: z8.string(), cueId: z8.string(), detail: z8.string() })),
+  /**
+   * The capture-drift verdict against `<name>.baseline.json` beside the scenario. Absent when
+   * the recording failed (a failed recording is not evidence of drift) and in every result
+   * written before baselines existed, so it is optional and additive.
+   */
+  baseline: BaselineReportSchema.optional()
 });
-var RenderCommandResultSchema = z7.object({
+var RenderCommandResultSchema = z8.object({
   ...envelope("render"),
   bundleDir: DISPLAY_PATH,
   variants: VariantsSchema,
-  streams: z7.object({
+  streams: z8.object({
     base: StreamSummarySchema.optional(),
     soft: StreamSummarySchema.optional(),
     hard: StreamSummarySchema.optional()
   }),
-  outputs: z7.array(ArtifactRefSchema)
+  outputs: z8.array(ArtifactRefSchema)
 });
-var VerificationReportSchema = z7.object({
+var VerificationReportSchema = z8.object({
   ...envelope("verify"),
   bundleDir: DISPLAY_PATH,
-  artifactCount: z7.number().int().nonnegative()
+  artifactCount: z8.number().int().nonnegative()
 });
-var WarmCommandResultSchema = z7.object({
+var WarmCommandResultSchema = z8.object({
   ...envelope("warm"),
   bundleDir: DISPLAY_PATH,
-  clipCount: z7.number().int().nonnegative(),
-  synthesizedCount: z7.number().int().nonnegative(),
-  cachedCount: z7.number().int().nonnegative()
+  clipCount: z8.number().int().nonnegative(),
+  synthesizedCount: z8.number().int().nonnegative(),
+  cachedCount: z8.number().int().nonnegative()
 });
-var DifferenceCategorySchema = z7.enum(["step", "assertion", "target", "timing", "caption", "actor"]);
-var DiffCommandResultSchema = z7.object({
+var DiffCommandResultSchema = z8.object({
   ...envelope("diff"),
   bundleA: DISPLAY_PATH,
   bundleB: DISPLAY_PATH,
-  identical: z7.boolean(),
-  differences: z7.array(z7.object({ category: DifferenceCategorySchema, detail: z7.string() }))
+  identical: z8.boolean(),
+  differences: z8.array(DifferenceSchema)
 });
-var CompareCommandResultSchema = z7.object({
+var CompareCommandResultSchema = z8.object({
   ...envelope("compare"),
   bundleA: DISPLAY_PATH,
   bundleB: DISPLAY_PATH,
-  checks: z7.array(z7.object({ name: z7.string(), ok: z7.boolean(), detail: z7.string() }))
+  checks: z8.array(z8.object({ name: z8.string(), ok: z8.boolean(), detail: z8.string() }))
 });
-var InitResultSchema = z7.object({
+var InitResultSchema = z8.object({
   ...envelope("init"),
-  files: z7.array(DISPLAY_PATH),
-  validates: z7.boolean()
+  files: z8.array(DISPLAY_PATH),
+  validates: z8.boolean()
 });
-var PruneCandidateSchema = z7.object({
+var PruneCandidateSchema = z8.object({
   path: DISPLAY_PATH,
-  bytes: z7.number().int().nonnegative(),
-  scenarioId: z7.string().optional()
+  bytes: z8.number().int().nonnegative(),
+  scenarioId: z8.string().optional()
 });
-var PruneCommandResultSchema = z7.object({
+var PruneCommandResultSchema = z8.object({
   ...envelope("prune"),
-  dryRun: z7.boolean(),
+  dryRun: z8.boolean(),
   /** What was removed (confirmed) or would be (dry run) — never includes a `failed` entry. */
-  candidates: z7.array(PruneCandidateSchema),
+  candidates: z8.array(PruneCandidateSchema),
   /** A discovered bundle that was never attempted, and why — never silently dropped. */
-  skipped: z7.array(z7.object({ path: DISPLAY_PATH, reason: z7.string() })),
+  skipped: z8.array(z8.object({ path: DISPLAY_PATH, reason: z8.string() })),
   /** A selected candidate `rm` was attempted on and could not remove, and why. Always empty
    * on a dry run, since nothing is attempted until `--yes`. */
-  failed: z7.array(z7.object({ path: DISPLAY_PATH, reason: z7.string() })),
+  failed: z8.array(z8.object({ path: DISPLAY_PATH, reason: z8.string() })),
   /** What `candidates` account for: bytes actually reclaimed if `dryRun` is false, or would
    * be reclaimed if every candidate succeeded. */
-  bytesReclaimed: z7.number().int().nonnegative()
+  bytesReclaimed: z8.number().int().nonnegative()
 });
-var ImportCommandResultSchema = z7.object({
+var ImportCommandResultSchema = z8.object({
   ...envelope("import"),
   tracePath: DISPLAY_PATH,
   outputPath: DISPLAY_PATH,
   /** How many `demo.step` calls the draft carries. Zero only on the failure path. */
-  stepCount: z7.number().int().nonnegative(),
+  stepCount: z8.number().int().nonnegative(),
   /** Whether the written draft already passes `plaintake validate`. Best-effort: a draft
    * that fails is still written, still a success, and its problems are warnings here. */
-  validates: z7.boolean(),
+  validates: z8.boolean(),
   /** Author-facing advice: multi-page traces, redactions, unimported trace calls, and the
    * standing review-for-secrets line. Never empty on success. */
-  warnings: z7.array(z7.string())
+  warnings: z8.array(z8.string())
 });
-var InspectResultSchema = z7.object({
+var InspectResultSchema = z8.object({
   ...envelope("inspect"),
   bundleDir: DISPLAY_PATH,
   status: StatusSchema,
-  scenario: z7.object({ id: z7.string(), sourceSha256: Sha2562 }),
+  scenario: z8.object({ id: z8.string(), sourceSha256: Sha2563 }),
   toolchain: ToolchainSchema,
-  video: z7.object({
+  video: z8.object({
     /** The whole output: the cards, if any, plus the content between them. */
-    durationMs: z7.number().int(),
-    frames: z7.number().int(),
-    width: z7.number().int(),
-    height: z7.number().int(),
-    fps: z7.number().int(),
+    durationMs: z8.number().int(),
+    frames: z8.number().int(),
+    width: z8.number().int(),
+    height: z8.number().int(),
+    fps: z8.number().int(),
     /**
      * Split out because `durationMs` alone is misleading once a card exists: 12,034ms of
      * output can be 9,034ms of recording. The parts are reported separately rather than
@@ -1185,20 +1526,20 @@ var InspectResultSchema = z7.object({
      * the word means, and is worth stating because the plan's own `video.durationMs` is a
      * different number that includes the opening card.
      */
-    contentDurationMs: z7.number().int().nonnegative(),
-    introDurationMs: z7.number().int().nonnegative().default(0),
-    outroDurationMs: z7.number().int().nonnegative()
+    contentDurationMs: z8.number().int().nonnegative(),
+    introDurationMs: z8.number().int().nonnegative().default(0),
+    outroDurationMs: z8.number().int().nonnegative()
   }),
-  captions: z7.object({
-    language: z7.string(),
-    cueCount: z7.number().int().nonnegative(),
-    characterCount: z7.number().int().nonnegative(),
-    medianCueMs: z7.number().int().nonnegative(),
-    shortestCueMs: z7.number().int().nonnegative(),
-    longestCueMs: z7.number().int().nonnegative()
+  captions: z8.object({
+    language: z8.string(),
+    cueCount: z8.number().int().nonnegative(),
+    characterCount: z8.number().int().nonnegative(),
+    medianCueMs: z8.number().int().nonnegative(),
+    shortestCueMs: z8.number().int().nonnegative(),
+    longestCueMs: z8.number().int().nonnegative()
   }),
   /** Measured from the rendered MP4 where possible, declared from the plan otherwise. */
-  chapters: z7.array(z7.object({ startMs: z7.number().int().nonnegative(), title: z7.string() })),
+  chapters: z8.array(z8.object({ startMs: z8.number().int().nonnegative(), title: z8.string() })),
   /**
    * The narration this bundle carries, or absent for a silent one.
    *
@@ -1209,13 +1550,13 @@ var InspectResultSchema = z7.object({
    * model behind it, and inventing a voice id for it would make the one field that answers "why
    * does this sound different" answer wrongly.
    */
-  narration: z7.object({
-    clipCount: z7.number().int().positive(),
+  narration: z8.object({
+    clipCount: z8.number().int().positive(),
     /** Total speech, excluding the silence between clips. Not the video's length. */
-    spokenMs: z7.number().int().nonnegative(),
+    spokenMs: z8.number().int().nonnegative(),
     /** How many clips the author supplied rather than the model producing. */
-    suppliedCount: z7.number().int().nonnegative(),
-    voice: z7.string().optional()
+    suppliedCount: z8.number().int().nonnegative(),
+    voice: z8.string().optional()
   }).optional(),
   /**
    * The multi-actor demo's cast, or absent for a single-actor bundle — every bundle
@@ -1232,19 +1573,19 @@ var InspectResultSchema = z7.object({
    * the field a reader of this JSON would already trust as the timeline, not from a second
    * field that only agrees with it by a schema-level invariant this result does not surface.
    */
-  actors: z7.object({
+  actors: z8.object({
     /** `plan.actors.length`. Reported alongside `labels` rather than left for a caller to
      * compute, matching `narration.clipCount` sitting beside `narration` above for the
      * same reason: the count is the fact most callers want first, before the list. */
-    count: z7.number().int().min(2),
+    count: z8.number().int().min(2),
     /** In `plan.actors` order — the cast list a badge or transition card would draw, not
      * deduplicated or sorted. */
-    labels: z7.array(z7.string().min(1)).min(2),
+    labels: z8.array(z8.string().min(1)).min(2),
     /** Hand-offs, not participants: one fewer than `plan.segments.length`, since a
      * segment is a window one actor already holds and a turn is the cut between two of
      * them — the same count `plan.transitionCards.length` carries, arrived at
      * independently from `segments` for the reason above. */
-    turnCount: z7.number().int().nonnegative()
+    turnCount: z8.number().int().nonnegative()
   }).refine((value) => value.count === value.labels.length, "actors.count must equal actors.labels.length").optional(),
   /**
    * The explain scenes this bundle cut away to, in composite order, or absent for a bundle
@@ -1256,20 +1597,20 @@ var InspectResultSchema = z7.object({
    * `actors` is sourced from the plan rather than re-read from `demo.explain()` calls: a
    * bundle whose scenario has since been edited or deleted still inspects correctly.
    */
-  explainScenes: z7.array(
-    z7.object({
-      id: z7.string().min(1),
-      durationMs: z7.number().int().positive()
+  explainScenes: z8.array(
+    z8.object({
+      id: z8.string().min(1),
+      durationMs: z8.number().int().positive()
     })
   ).min(1).optional(),
   /** The rendered MP4s, from the manifest, so hashes are not recomputed. */
-  outputs: z7.array(ArtifactRefSchema),
-  assertions: z7.array(AssertionSchema),
-  artifactCount: z7.number().int().nonnegative(),
+  outputs: z8.array(ArtifactRefSchema),
+  assertions: z8.array(AssertionSchema),
+  artifactCount: z8.number().int().nonnegative(),
   /** Everything the manifest accounts for. What "delete this bundle" would reclaim. */
-  bundleBytes: z7.number().int().nonnegative()
+  bundleBytes: z8.number().int().nonnegative()
 });
-var DoctorResultSchema = z7.object({
+var DoctorResultSchema = z8.object({
   ...envelope("doctor"),
   /**
    * The PlainTake build this is. Here rather than in `ToolchainSchema` on purpose:
@@ -1277,12 +1618,12 @@ var DoctorResultSchema = z7.object({
    * manifest on every release and break the byte-for-byte golden bundle. `doctor` is the
    * one command a bug report is asked for, which makes it the right place.
    */
-  version: z7.string(),
-  ffmpeg: z7.string(),
-  ffprobe: z7.string(),
-  libass: z7.string(),
-  hasLibass: z7.boolean(),
-  hasX264: z7.boolean(),
+  version: z8.string(),
+  ffmpeg: z8.string(),
+  ffprobe: z8.string(),
+  libass: z8.string(),
+  hasLibass: z8.boolean(),
+  hasX264: z8.boolean(),
   /**
    * Whether this FFmpeg can encode AAC, which is what a narrated bundle is muxed with.
    *
@@ -1292,8 +1633,8 @@ var DoctorResultSchema = z7.object({
    * that actually needs it, with a fix string. Failing `doctor` here would be telling someone
    * their installation is broken for a capability they may never turn on.
    */
-  hasAac: z7.boolean(),
-  filters: z7.array(z7.string()),
+  hasAac: z8.boolean(),
+  filters: z8.array(z8.string()),
   /**
    * Whether spoken narration could be produced right now, and what is missing if not.
    *
@@ -1302,32 +1643,27 @@ var DoctorResultSchema = z7.object({
    * `openNarrator` asks before a run, answered by the same function (`speechAssetProblems`), so
    * `doctor` cannot say speech is fine and then a run refuse it.
    */
-  speech: z7.object({
-    ready: z7.boolean(),
+  speech: z8.object({
+    ready: z8.boolean(),
     /** Installed voices, in catalogue order. Empty means the model cannot speak yet. */
-    voices: z7.array(z7.string()),
+    voices: z8.array(z8.string()),
     /** What is missing, in the same words a refused run would use. Empty when ready. */
-    notes: z7.array(z7.string())
+    notes: z8.array(z8.string())
   }),
   /**
-   * Whether the plainmotion CLI is on `PATH`, for a scenario that wants to call
-   * `demo.explain()`. The same stance `hasAac`/`speech` above already take: absence is a
-   * *state*, not a fault — the overwhelming majority of scenarios never cut away to an
-   * explain scene, so `doctor` must not fail an otherwise-healthy installation over a binary
-   * most runs will never invoke. `assertPlainmotion` (`recorder-playwright`) is the same
-   * probe a run's own first `demo.explain()` pays, so `doctor` cannot say plainmotion is fine
-   * and then a run refuse it.
+   * Whether a terminal scenario could be recorded right now: the vendored node-pty loads, and
+   * xterm.js and the terminal font are in place. Never folded into `problems` — the same stance as
+   * `speech` — because only a scenario declaring `terminal` needs any of it. Optional so a result
+   * written before terminals existed parses.
    */
-  plainmotion: z7.object({
-    installed: z7.boolean(),
-    /** plainmotion's own `--version` output. Absent when not installed. */
-    version: z7.string().optional(),
-    /** Why the probe failed, in the same words a run's own refusal would use. Absent when installed. */
-    note: z7.string().optional()
-  })
+  terminal: z8.object({
+    ready: z8.boolean(),
+    /** What is missing, in the words a refused run would use. Empty when ready. */
+    notes: z8.array(z8.string())
+  }).optional()
 });
 var okMatchesProblems = (value) => value.ok === (value.problems.length === 0);
-var ActivateReasonSchema = z7.enum([
+var ActivateReasonSchema = z8.enum([
   "empty-key",
   "not-found",
   "revoked",
@@ -1335,16 +1671,16 @@ var ActivateReasonSchema = z7.enum([
   "unexpected-response",
   "not-configured"
 ]);
-var ActivateResultSchema = z7.object({
+var ActivateResultSchema = z8.object({
   ...envelope("activate"),
   /** Present only when ok is false, so a machine reader can distinguish the classes. */
   reason: ActivateReasonSchema.optional(),
   /** Present only on success — a failed activation has no record. The key itself is
    * deliberately absent: the caller already has it, and stdout may be logged. */
-  licence: z7.object({
-    subject: z7.string().min(1),
-    activatedAt: z7.string().min(1),
-    uses: z7.number().int().nonnegative()
+  licence: z8.object({
+    subject: z8.string().min(1),
+    activatedAt: z8.string().min(1),
+    uses: z8.number().int().nonnegative()
   }).optional()
 }).refine(okMatchesProblems, "ok must be true iff problems is empty").refine(
   // Making the "present only when" comments above literally true, so a reader can
@@ -1352,25 +1688,25 @@ var ActivateResultSchema = z7.object({
   (value) => value.reason !== void 0 === !value.ok && (value.licence === void 0 || value.ok),
   "reason appears iff ok is false, and licence only on success"
 );
-var LicenceResultSchema = z7.discriminatedUnion("tier", [
-  z7.object({
+var LicenceResultSchema = z8.discriminatedUnion("tier", [
+  z8.object({
     ...envelope("licence"),
-    tier: z7.literal("free"),
+    tier: z8.literal("free"),
     /**
      * Why a present-but-unusable record degraded to free, in readLicense's own words.
      * Must never quote a filesystem path: assertNoAbsolutePaths exempts only `problems`.
      */
-    problem: z7.string().optional()
+    problem: z8.string().optional()
   }),
-  z7.object({
+  z8.object({
     ...envelope("licence"),
-    tier: z7.literal("pro"),
-    subject: z7.string().min(1),
-    activatedAt: z7.string().min(1),
-    uses: z7.number().int().nonnegative()
+    tier: z8.literal("pro"),
+    subject: z8.string().min(1),
+    activatedAt: z8.string().min(1),
+    uses: z8.number().int().nonnegative()
   })
 ]).refine(okMatchesProblems, "ok must be true iff problems is empty");
-var PublishReasonSchema = z7.enum([
+var PublishReasonSchema = z8.enum([
   "no-endpoint",
   "no-key",
   "invalid-store",
@@ -1380,39 +1716,82 @@ var PublishReasonSchema = z7.enum([
   "hash-mismatch",
   "length-mismatch",
   "conflict",
+  "taken-down",
   "unexpected-response"
 ]);
-var PublishResultSchema = z7.discriminatedUnion("ok", [
-  z7.object({
+var PublishResultSchema = z8.discriminatedUnion("ok", [
+  z8.object({
     ...envelope("publish"),
-    ok: z7.literal(false),
+    ok: z8.literal(false),
     reason: PublishReasonSchema
   }),
-  z7.object({
+  z8.object({
     ...envelope("publish"),
-    ok: z7.literal(true),
-    videoId: z7.string().regex(/^[a-z2-7]{26}$/, "must be a 26-char base32 share id"),
+    ok: z8.literal(true),
+    videoId: z8.string().regex(/^[a-z2-7]{26}$/, "must be a 26-char base32 share id"),
     /** The page viewers open — the endpoint plus the id. */
-    url: z7.string().regex(/^https?:\/\/\S+$/, "must be an http or https URL"),
+    url: z8.string().regex(/^https?:\/\/\S+$/, "must be an http or https URL"),
     /** False when the video was already on the service — nothing was uploaded. */
-    uploaded: z7.boolean(),
+    uploaded: z8.boolean(),
+    /**
+     * True when the share had been unpublished (or had expired) and this publish brought
+     * it back — `unpublish`'s undo. Defaults to false so a result written before the
+     * field existed still parses.
+     */
+    restored: z8.boolean().default(false),
     /**
      * Present only when `--remember` was asked: true when the key was stored beside
      * license.json, false when the key file could not be written. The service's
      * proof of the key (an accepted PUT, or the identity check on an already-shared
      * run) is part of every success, so it is never the reason.
      */
-    remembered: z7.boolean().optional(),
+    remembered: z8.boolean().optional(),
     /**
      * The ISO-8601 instant the share link now dies at — present only when an expiry
      * policy (`--expiry` or publish.json's `expiry`) was set. Absent means never
      * expires, exactly like a publish before the feature existed.
      */
-    expiresAt: z7.string().min(1).optional(),
-    captions: z7.boolean(),
-    chapters: z7.boolean(),
+    expiresAt: z8.string().min(1).optional(),
+    captions: z8.boolean(),
+    chapters: z8.boolean(),
     /** False is a state, not a fault: no FFmpeg on PATH means no poster frame. */
-    poster: z7.boolean()
+    poster: z8.boolean()
+  })
+]).refine(okMatchesProblems, "ok must be true iff problems is empty");
+var UnpublishReasonSchema = z8.enum([
+  "no-endpoint",
+  "no-key",
+  "invalid-store",
+  "not-a-bundle",
+  "invalid-target",
+  "endpoint-mismatch",
+  "unauthorized",
+  "forbidden",
+  "not-found",
+  "unreachable",
+  "unexpected-response"
+]);
+var UnpublishResultSchema = z8.discriminatedUnion("ok", [
+  z8.object({
+    ...envelope("unpublish"),
+    ok: z8.literal(false),
+    reason: UnpublishReasonSchema
+  }),
+  z8.object({
+    ...envelope("unpublish"),
+    ok: z8.literal(true),
+    videoId: z8.string().regex(/^[a-z2-7]{26}$/, "must be a 26-char base32 share id"),
+    /** The page that now answers 410. */
+    url: z8.string().regex(/^https?:\/\/\S+$/, "must be an http or https URL"),
+    /** When the share went dark; repeating an unpublish keeps the first instant. */
+    deletedAt: z8.string().min(1),
+    /**
+     * Who holds the tombstone. `admin` means the service's operator had already taken
+     * the share down — still a success (it is dark), but only the operator can undo it.
+     */
+    deletedBy: z8.enum(["producer", "admin", "expired"]),
+    /** When retention may delete the bytes for good; a republish before then restores. */
+    purgeAfter: z8.string().min(1)
   })
 ]).refine(okMatchesProblems, "ok must be true iff problems is empty");