@plaintake/scenario 1.17.0 → 1.24.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",
@@ -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,27 @@ 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 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 +195,24 @@ 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 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"),
+  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 +230,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 +239,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),
@@ -227,120 +287,120 @@ 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.
      */
-    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"),
+    viewport: z5.tuple([z5.literal(1920), z5.literal(1080)]),
+    deviceScaleFactor: z5.literal(1)
   }),
-  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)
+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)
 });
-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),
+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 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 +413,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 +451,11 @@ 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()
 });
-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)
@@ -408,18 +468,18 @@ var CursorSchema = z6.object({
     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 +507,39 @@ 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()
 });
-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$/)
 });
-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 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()
 });
-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 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 +551,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 +564,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 +594,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 +606,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 +621,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 +640,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,9 +657,9 @@ 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),
+  sampleRate: z7.literal(24e3),
+  channels: z7.literal(1),
+  clips: z7.array(SpeechClipSchema).min(1),
   engine: SpeechEngineSchema.optional()
 }).refine(
   ({ clips }) => new Set(clips.map((clip) => clip.id)).size === clips.length && clips.every(
@@ -625,14 +685,14 @@ var SpeechSchema = z6.object({
   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,17 +754,17 @@ 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
@@ -727,8 +787,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,
     {
@@ -742,12 +802,12 @@ var RenderPlanSchema = z6.object({
       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 +821,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 +840,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,12 +859,12 @@ 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)
   }),
-  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(),
@@ -838,6 +898,31 @@ var RenderPlanSchema = z6.object({
    * older binary's own re-parse has stripped `theme` out of.
    */
   theme: ThemeSchema.optional(),
+  /**
+   * The one video this plan renders to, named for the scenario: `output/create-api-key.mp4`
+   * for `id: 'create-api-key'`. Frozen once, at record time, from the scenario's own id —
+   * `ScenarioMetaSchema`'s lowercase-kebab id rule is what the path regex above mirrors, so
+   * the two cannot drift apart silently.
+   *
+   * Optional and **never defaulted**, for the same reason as `theme`: a Zod `.default()`
+   * materialises on parse, and every parse-and-rewrite of an older plan (a `--aspect`
+   * re-cut re-freezes `render/render-plan.json`) would inject the field into bundles
+   * recorded before per-scenario names existed. Absent means exactly that — a plan frozen
+   * before 1.21, whose video is the historical `output/demo.mp4` the renderer's arg
+   * builders fall back to.
+   *
+   * Top-level — a sibling of `theme`, not a key inside `video` (which `recutPlan` rewrites
+   * wholesale) — so `recutPlan`'s `{...plan}` spread carries it through `--aspect` re-cuts
+   * unchanged.
+   *
+   * The frozen `ffmpeg` arrays remain the runtime source of truth: `renderBundle` replays
+   * them verbatim and `outputPathOf` reads the destination back out of them, which is what
+   * lets a bundle frozen under any earlier naming scheme render unchanged. This field
+   * exists for the *re*-freezes — `recutPlan` and the multi-actor splice rebuild their
+   * 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: 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
@@ -861,11 +946,11 @@ var RenderPlanSchema = z6.object({
    * 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(TransitionCardSchema).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];
@@ -936,95 +1021,95 @@ 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
   }).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.
    *
@@ -1033,119 +1118,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
@@ -1160,20 +1256,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.
    *
@@ -1184,13 +1280,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
@@ -1207,19 +1303,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
@@ -1231,20 +1327,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:
@@ -1252,12 +1348,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.
    *
@@ -1267,8 +1363,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.
    *
@@ -1277,12 +1373,12 @@ 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
@@ -1293,16 +1389,16 @@ var DoctorResultSchema = z7.object({
    * probe a run's own first `demo.explain()` pays, so `doctor` cannot say plainmotion is fine
    * and then a run refuse it.
    */
-  plainmotion: z7.object({
-    installed: z7.boolean(),
+  plainmotion: z8.object({
+    installed: z8.boolean(),
     /** plainmotion's own `--version` output. Absent when not installed. */
-    version: z7.string().optional(),
+    version: z8.string().optional(),
     /** Why the probe failed, in the same words a run's own refusal would use. Absent when installed. */
-    note: z7.string().optional()
+    note: 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",
@@ -1310,16 +1406,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
@@ -1327,22 +1423,67 @@ 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 = z8.enum([
+  "no-endpoint",
+  "no-key",
+  "invalid-store",
+  "not-a-bundle",
+  "unauthorized",
+  "unreachable",
+  "hash-mismatch",
+  "length-mismatch",
+  "conflict",
+  "unexpected-response"
+]);
+var PublishResultSchema = z8.discriminatedUnion("ok", [
+  z8.object({
+    ...envelope("publish"),
+    ok: z8.literal(false),
+    reason: PublishReasonSchema
+  }),
+  z8.object({
+    ...envelope("publish"),
+    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: 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: z8.boolean(),
+    /**
+     * 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: 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: 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: z8.boolean()
   })
 ]).refine(okMatchesProblems, "ok must be true iff problems is empty");