diff --git a/AGENTS.md b/AGENTS.md
index f4ac69a..5e651d5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,7 +15,7 @@ deterministic mp4 render. Human edits survive AI regeneration of the base.
 - `pnpm reframe batch <scene.ts> <data.json|csv>` — one mp4 per row (row keys are overlay addresses like `nodes.<id>.<prop>`)
 - `pnpm reframe logo <logo.svg | brand-slug> [--motion <preset>] [--energy n] [--seed n]` — animate a logo into a sting (published CLI command; `packages/render-cli/src/logoSting.ts`)
 - `pnpm reframe labels <scene.ts>` — print the compiled event clock (every timeline label → exact seconds; the timing source for `audio.cues` and beat debugging)
-- `pnpm reframe compile <scene.ts|.json> [-o out.json] [--stdin] [--code "<src>"] [--json]` — bundle + validate eDSL source into SceneIR JSON, NO render (no ffmpeg/chromium; fast). On failure: a concise classified error (`bundle`/`eval`/`validation`), never the base64 bundle; `--json` makes it `{ok:false,error,kind}`. The in-process equivalent is exported as `reframe-video/compile` (`loadScene`/`loadSceneFromCode`/`checkDeterminism`, server-only). Entry `packages/render-cli/src/compile.ts`; loader `loadScene.ts`.
+- `pnpm reframe compile <scene.ts|.json> [-o out.json] [--stdin] [--code "<src>"] [--json]` — bundle + validate eDSL source into SceneIR JSON, NO render (no ffmpeg/chromium; fast). On failure: a concise classified error (`bundle`/`eval`/`validation`), never the base64 bundle; `--json` makes it `{ok:false,error,kind,issues?}` where `issues` is the structured validation problems (each `{code,path,message}` — e.g. `code:"unknown-blend", path:"nodes.box"`). The in-process equivalent is exported as `reframe-video/compile` (`loadScene`/`loadSceneFromCode`/`checkDeterminism`, server-only); a thrown `SceneValidationError` carries `.issues` (and `.problems` for back-compat), and `SceneLoadError.issues` propagates them across the scene bundle. Entry `packages/render-cli/src/compile.ts`; loader `loadScene.ts`.
 - `pnpm reframe frame <scene.ts|.json> [--t <sec>] [-o out.png]` — render ONE frame at time `t` to a PNG (same renderer as `render`, no ffmpeg muxing; chromium only). For an agentic render-and-look loop (feed the frame back to a model). Reuses `renderFrameAt` (`frameLoop.ts`); entry `packages/render-cli/src/frame.ts`.
 - `pnpm reframe assemble <media...> [-o name] [--title "…"] [--bgm <synth>] [--hold s] [--seed N]` — the **files → scene** path: probe each image/video for its real duration (ffprobe) and scaffold an editable montage scene `.ts` wiring `photoMontage` (clip-aware holds, no freeze) + an optional `title` + a music bed. Probed numbers are baked in → the emitted scene is a normal deterministic scene. Probe `packages/render-cli/src/media/probe.ts`; entry `assemble.ts`.
 - `pnpm reframe manifest <scene.ts|.json> [--json]` — dump the scene's **addressable surface**: every node (+ its `editableProps` and `animatedProps`), state, timeline label (+ `patchable` params), beat, and behavior, each with the overlay address that reaches it. The map an AI/human editor reads to patch a scene surgically (vs regenerating). Core `sceneManifest(compiled)` (`packages/core/src/manifest.ts`, exported); entry `packages/render-cli/src/manifest.ts`.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index aa7129c..dd910c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,25 @@ versions may change them.
 
 ## [Unreleased]
 
+## [0.6.43] - 2026-06-21
+
+### Added
+
+#### Structured validation errors (`code` + `path` alongside the message)
+
+- `SceneValidationError` now carries **`.issues: ValidationIssue[]`** — each problem is
+  `{ code, path, message }` with a stable machine `code` (`unknown-blend`, `duplicate-node-id`,
+  `unknown-timeline-label`, `bad-duration`, …) and a `path` locator (`nodes.box`,
+  `timeline.beat(in)[0]`, `camera.zoom`, `audio.cues[0]`), so a consumer can categorize a
+  failure and point a UI at the offending element instead of parsing prose.
+- Propagated in-process: `SceneLoadError.issues` carries them across the scene's own bundled
+  core (read as a plain property, since `instanceof` can't cross the bundle), and
+  `reframe compile --json` failures include `issues` (`{ ok:false, error, kind, issues? }`).
+  `ValidationIssue` is exported from `@reframe/core` and `reframe-video/compile`.
+- **Fully back-compat / additive**: every message is byte-identical, and `.problems` (string[])
+  + `.message` + the class identity are unchanged — the existing `toThrow(/…/)` suite passes
+  untouched. Validation isn't on the render path, so goldens are unaffected.
+
 ## [0.6.42] - 2026-06-21
 
 ### Added
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index e39dae1..19fa8a0 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -1,6 +1,6 @@
 export * from "./ir.js";
 export * from "./dsl.js";
-export { validateScene, validateComposition, SceneValidationError, PROPS_BY_TYPE } from "./validate.js";
+export { validateScene, validateComposition, SceneValidationError, PROPS_BY_TYPE, type ValidationIssue } from "./validate.js";
 export {
   compileComposition,
   type CompiledComposition,
diff --git a/packages/core/src/validate.ts b/packages/core/src/validate.ts
index 81e1903..8377148 100644
--- a/packages/core/src/validate.ts
+++ b/packages/core/src/validate.ts
@@ -29,71 +29,92 @@ export const PROPS_BY_TYPE: Record<NodeIR["type"], string[]> = {
   group: COMMON_PROPS,
 };
 
+/**
+ * One validation problem, structured so a UI can point at the offending element
+ * (`path`) and a consumer can categorize (`code`) without parsing prose. `message`
+ * is the human string (unchanged). Codes are stable kebab strings; see the `add(...)`
+ * call sites in `validateScene`/`validateComposition`.
+ */
+export interface ValidationIssue {
+  code: string;
+  /** Locator for the offending element, e.g. `nodes.box`, `timeline.beat(in)[0]`, `camera.zoom`, `audio.cues[0]`. */
+  path: string;
+  message: string;
+}
+
 export class SceneValidationError extends Error {
-  constructor(public problems: string[]) {
-    super(`Scene validation failed:\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+  /** Structured form of the problems (code + path + message). */
+  readonly issues: ValidationIssue[];
+  /** Back-compat: the human messages, one per issue. */
+  readonly problems: string[];
+  constructor(issues: ValidationIssue[]) {
+    super(`Scene validation failed:\n${issues.map((i) => `  - ${i.message}`).join("\n")}`);
     this.name = "SceneValidationError";
+    this.issues = issues;
+    this.problems = issues.map((i) => i.message);
   }
 }
 
 export function validateScene(ir: SceneIR): void {
-  const problems: string[] = [];
+  const issues: ValidationIssue[] = [];
+  const add = (code: string, path: string, message: string) => issues.push({ code, path, message });
   const nodeById = new Map<string, NodeIR>();
   // video `start: "<label>"` anchors — collected during the node walk, checked
   // after all timeline labels are known.
   const startAnchors: { id: string; at: string }[] = [];
 
   // a fill/stroke is a color string (unchecked, as today) OR a gradient object
-  const checkPaint = (where: string, value: unknown) => {
+  const checkPaint = (where: string, path: string, value: unknown) => {
     if (typeof value !== "object" || value === null) return;
     const g = value as { kind?: unknown; stops?: unknown };
     if (g.kind !== "linear" && g.kind !== "radial" && g.kind !== "conic") {
-      problems.push(`${where}: a paint object must be a gradient with kind "linear" / "radial" / "conic"`);
+      add("bad-gradient", path, `${where}: a paint object must be a gradient with kind "linear" / "radial" / "conic"`);
       return;
     }
     if (!Array.isArray(g.stops) || g.stops.length === 0) {
-      problems.push(`${where}: gradient "${g.kind}" needs at least one color stop`);
+      add("bad-gradient", path, `${where}: gradient "${g.kind}" needs at least one color stop`);
       return;
     }
     g.stops.forEach((s: unknown, i: number) => {
       const st = s as { offset?: unknown; color?: unknown };
-      if (typeof st?.color !== "string") problems.push(`${where}: gradient stop ${i} needs a color string`);
+      if (typeof st?.color !== "string") add("gradient-stop", path, `${where}: gradient stop ${i} needs a color string`);
       if (typeof st?.offset !== "number" || st.offset < 0 || st.offset > 1) {
-        problems.push(`${where}: gradient stop ${i} "offset" must be a number in 0..1`);
+        add("gradient-stop", path, `${where}: gradient stop ${i} "offset" must be a number in 0..1`);
       }
     });
   };
 
   const collect = (nodes: NodeIR[]) => {
     for (const node of nodes) {
+      const np = `nodes.${node.id}`;
       if (nodeById.has(node.id)) {
-        problems.push(`duplicate node id "${node.id}" — every node id must be unique`);
+        add("duplicate-node-id", np, `duplicate node id "${node.id}" — every node id must be unique`);
       }
       nodeById.set(node.id, node);
       const props = node.props as unknown as Record<string, unknown>;
-      checkPaint(`node "${node.id}" fill`, props.fill);
-      checkPaint(`node "${node.id}" stroke`, props.stroke);
-      if (typeof props.blur === "number" && props.blur < 0) problems.push(`node "${node.id}": blur must be >= 0`);
-      if (typeof props.shadowBlur === "number" && props.shadowBlur < 0) problems.push(`node "${node.id}": shadowBlur must be >= 0`);
-      if (typeof props.blend === "string" && !BLEND_MODES.has(props.blend)) problems.push(`node "${node.id}": unknown blend "${props.blend}" — use ${[...BLEND_MODES].join(", ")}`);
-      if (typeof props.fit === "string" && !IMAGE_FITS.has(props.fit)) problems.push(`node "${node.id}": unknown fit "${props.fit}" — use ${[...IMAGE_FITS].join(", ")}`);
+      checkPaint(`node "${node.id}" fill`, np, props.fill);
+      checkPaint(`node "${node.id}" stroke`, np, props.stroke);
+      if (typeof props.blur === "number" && props.blur < 0) add("negative-effect", np, `node "${node.id}": blur must be >= 0`);
+      if (typeof props.shadowBlur === "number" && props.shadowBlur < 0) add("negative-effect", np, `node "${node.id}": shadowBlur must be >= 0`);
+      if (typeof props.blend === "string" && !BLEND_MODES.has(props.blend)) add("unknown-blend", np, `node "${node.id}": unknown blend "${props.blend}" — use ${[...BLEND_MODES].join(", ")}`);
+      if (typeof props.fit === "string" && !IMAGE_FITS.has(props.fit)) add("unknown-fit", np, `node "${node.id}": unknown fit "${props.fit}" — use ${[...IMAGE_FITS].join(", ")}`);
       if (node.type === "video" && typeof node.props.start === "string") startAnchors.push({ id: node.id, at: node.props.start });
       if (node.type === "group") {
         const clip = node.props.clip;
         if (clip) {
           if (clip.kind !== "rect" && clip.kind !== "ellipse") {
-            problems.push(`group "${node.id}" clip: unknown kind "${(clip as { kind: string }).kind}" — use "rect" or "ellipse"`);
+            add("unknown-clip-kind", np, `group "${node.id}" clip: unknown kind "${(clip as { kind: string }).kind}" — use "rect" or "ellipse"`);
           }
           if (!(clip.width > 0) || !(clip.height > 0)) {
-            problems.push(`group "${node.id}" clip: width and height must be > 0`);
+            add("clip-size", np, `group "${node.id}" clip: width and height must be > 0`);
           }
         }
         const matte = (node.props as { matte?: unknown }).matte;
         if (matte !== undefined) {
           if (matte !== "alpha" && matte !== "luma") {
-            problems.push(`group "${node.id}" matte: unknown mode "${String(matte)}" — use "alpha" or "luma"`);
+            add("unknown-matte-mode", np, `group "${node.id}" matte: unknown mode "${String(matte)}" — use "alpha" or "luma"`);
           } else if (node.children.length < 2) {
-            problems.push(`group "${node.id}" matte: needs ≥2 children (first masks the rest)`);
+            add("matte-children", np, `group "${node.id}" matte: needs ≥2 children (first masks the rest)`);
           }
         }
         collect(node.children);
@@ -108,24 +129,20 @@ export function validateScene(ir: SceneIR): void {
     if (nodeId === "camera" && !nodeById.has("camera")) {
       for (const key of Object.keys(props)) {
         if (!CAMERA_PROPS.includes(key)) {
-          problems.push(`${where}: "${key}" is not a camera prop — valid props: ${CAMERA_PROPS.join(", ")}`);
+          add("unknown-camera-prop", `camera.${key}`, `${where}: "${key}" is not a camera prop — valid props: ${CAMERA_PROPS.join(", ")}`);
         }
       }
       return;
     }
     const node = nodeById.get(nodeId);
     if (!node) {
-      problems.push(
-        `${where} targets unknown node "${nodeId}" — known ids: ${[...nodeById.keys()].join(", ")}`,
-      );
+      add("unknown-node", `nodes.${nodeId}`, `${where} targets unknown node "${nodeId}" — known ids: ${[...nodeById.keys()].join(", ")}`);
       return;
     }
     const allowed = PROPS_BY_TYPE[node.type];
     for (const key of Object.keys(props)) {
       if (!allowed.includes(key)) {
-        problems.push(
-          `${where}: "${key}" is not a prop of ${node.type} "${nodeId}" — valid props: ${allowed.join(", ")}`,
-        );
+        add("unknown-prop", `nodes.${nodeId}.${key}`, `${where}: "${key}" is not a prop of ${node.type} "${nodeId}" — valid props: ${allowed.join(", ")}`);
       }
     }
   };
@@ -138,9 +155,7 @@ export function validateScene(ir: SceneIR): void {
   }
 
   if (ir.initial !== undefined && !(ir.initial in states)) {
-    problems.push(
-      `initial state "${ir.initial}" is not defined — defined states: ${Object.keys(states).join(", ") || "(none)"}`,
-    );
+    add("undefined-initial", "initial", `initial state "${ir.initial}" is not defined — defined states: ${Object.keys(states).join(", ") || "(none)"}`);
   }
 
   const labels = new Set<string>();
@@ -150,7 +165,7 @@ export function validateScene(ir: SceneIR): void {
     if (ease === undefined) return;
     if (typeof ease === "string") {
       if (!EASE_SET.has(ease)) {
-        problems.push(`${path}: unknown ease "${ease}" — valid: ${EASE_NAMES.join(", ")} (note: there are no *Sine eases)`);
+        add("unknown-ease", path, `${path}: unknown ease "${ease}" — valid: ${EASE_NAMES.join(", ")} (note: there are no *Sine eases)`);
       }
       return;
     }
@@ -159,20 +174,18 @@ export function validateScene(ir: SceneIR): void {
       if ("spring" in o) return;
       if ("cubicBezier" in o) {
         if (!Array.isArray(o.cubicBezier) || o.cubicBezier.length !== 4) {
-          problems.push(`${path}: ease cubicBezier must be [x1, y1, x2, y2]`);
+          add("bad-ease", path, `${path}: ease cubicBezier must be [x1, y1, x2, y2]`);
         }
         return;
       }
     }
-    problems.push(`${path}: invalid ease — use a name, { spring }, or { cubicBezier: [x1,y1,x2,y2] }`);
+    add("bad-ease", path, `${path}: invalid ease — use a name, { spring }, or { cubicBezier: [x1,y1,x2,y2] }`);
   };
 
   const checkTimeline = (tl: TimelineIR, path: string) => {
     if ("label" in tl && tl.label !== undefined) {
       if (labels.has(tl.label)) {
-        problems.push(
-          `${path}: duplicate timeline label "${tl.label}" — labels are overlay addresses and must be unique`,
-        );
+        add("duplicate-label", path, `${path}: duplicate timeline label "${tl.label}" — labels are overlay addresses and must be unique`);
       }
       labels.add(tl.label);
     }
@@ -182,27 +195,25 @@ export function validateScene(ir: SceneIR): void {
         tl.children.forEach((c, i) => checkTimeline(c, `${path}.${tl.kind}[${i}]`));
         break;
       case "stagger":
-        if (tl.interval < 0) problems.push(`${path}: stagger interval must be >= 0`);
+        if (tl.interval < 0) add("bad-duration", path, `${path}: stagger interval must be >= 0`);
         tl.children.forEach((c, i) => checkTimeline(c, `${path}.stagger[${i}]`));
         break;
       case "to":
         if (!(tl.state in states)) {
-          problems.push(
-            `${path}: to("${tl.state}") references an undefined state — defined states: ${Object.keys(states).join(", ") || "(none)"}`,
-          );
+          add("unknown-state", path, `${path}: to("${tl.state}") references an undefined state — defined states: ${Object.keys(states).join(", ") || "(none)"}`);
         }
         if (tl.duration !== undefined && tl.duration <= 0) {
-          problems.push(`${path}: to("${tl.state}") duration must be > 0`);
+          add("bad-duration", path, `${path}: to("${tl.state}") duration must be > 0`);
         }
         checkEase(path, (tl as { ease?: unknown }).ease);
         for (const id of tl.filter ?? []) {
-          if (!nodeById.has(id)) problems.push(`${path}: filter contains unknown node "${id}"`);
+          if (!nodeById.has(id)) add("unknown-node", path, `${path}: filter contains unknown node "${id}"`);
         }
         break;
       case "tween":
         checkProps(path, tl.target, tl.props);
         if (tl.duration !== undefined && tl.duration <= 0) {
-          problems.push(`${path}: tween duration must be > 0`);
+          add("bad-duration", path, `${path}: tween duration must be > 0`);
         }
         checkEase(path, (tl as { ease?: unknown }).ease);
         break;
@@ -211,45 +222,39 @@ export function validateScene(ir: SceneIR): void {
         const isSceneCamera = tl.target === "camera" && !node;
         if (!isSceneCamera) {
           if (!node) {
-            problems.push(
-              `${path}: motionPath targets unknown node "${tl.target}" — known ids: ${[...nodeById.keys()].join(", ")}`,
-            );
+            add("unknown-node", path, `${path}: motionPath targets unknown node "${tl.target}" — known ids: ${[...nodeById.keys()].join(", ")}`);
           } else if (node.type === "line") {
-            problems.push(`${path}: motionPath cannot target a line (no x/y) — "${tl.target}"`);
+            add("motionpath-target", path, `${path}: motionPath cannot target a line (no x/y) — "${tl.target}"`);
           }
         }
-        if (tl.points.length < 1) problems.push(`${path}: motionPath "${tl.target}" needs at least 1 point`);
+        if (tl.points.length < 1) add("motionpath-points", path, `${path}: motionPath "${tl.target}" needs at least 1 point`);
         if (tl.duration !== undefined && tl.duration <= 0) {
-          problems.push(`${path}: motionPath "${tl.target}" duration must be > 0`);
+          add("bad-duration", path, `${path}: motionPath "${tl.target}" duration must be > 0`);
         }
         if (tl.curviness !== undefined && tl.curviness < 0) {
-          problems.push(`${path}: motionPath "${tl.target}" curviness must be >= 0`);
+          add("motionpath-curviness", path, `${path}: motionPath "${tl.target}" curviness must be >= 0`);
         }
         checkEase(path, (tl as { ease?: unknown }).ease);
         break;
       }
       case "wait":
-        if (tl.duration < 0) problems.push(`${path}: wait duration must be >= 0`);
+        if (tl.duration < 0) add("bad-duration", path, `${path}: wait duration must be >= 0`);
         break;
       case "beat":
         if (labels.has(tl.name)) {
-          problems.push(
-            `${path}: duplicate timeline label "${tl.name}" (beat name) — labels are overlay addresses and must be unique`,
-          );
+          add("duplicate-label", path, `${path}: duplicate timeline label "${tl.name}" (beat name) — labels are overlay addresses and must be unique`);
         }
         labels.add(tl.name);
         if (typeof tl.at === "string") beatAnchors.push({ name: tl.name, at: tl.at, path });
         if (tl.duration !== undefined && tl.duration <= 0) {
-          problems.push(`${path}: beat "${tl.name}" duration must be > 0`);
+          add("bad-duration", path, `${path}: beat "${tl.name}" duration must be > 0`);
         }
         if (tl.scale !== undefined && tl.scale <= 0) {
-          problems.push(`${path}: beat "${tl.name}" scale must be > 0`);
+          add("beat-scale", path, `${path}: beat "${tl.name}" scale must be > 0`);
         }
         for (const id of tl.nodes ?? []) {
           if (!nodeById.has(id)) {
-            problems.push(
-              `${path}: beat "${tl.name}" owns unknown node "${id}" — known ids: ${[...nodeById.keys()].join(", ")}`,
-            );
+            add("beat-owns-unknown", path, `${path}: beat "${tl.name}" owns unknown node "${id}" — known ids: ${[...nodeById.keys()].join(", ")}`);
           }
         }
         tl.children.forEach((c, i) => checkTimeline(c, `${path}.beat(${tl.name})[${i}]`));
@@ -261,18 +266,14 @@ export function validateScene(ir: SceneIR): void {
   // beat label-anchors: the target label must exist and not be the beat itself.
   for (const a of beatAnchors) {
     if (a.at === a.name) {
-      problems.push(`${a.path}: beat "${a.name}" at: "${a.at}" cannot anchor to itself`);
+      add("beat-self-anchor", a.path, `${a.path}: beat "${a.name}" at: "${a.at}" cannot anchor to itself`);
     } else if (!labels.has(a.at)) {
-      problems.push(
-        `${a.path}: beat "${a.name}" at: "${a.at}" — unknown timeline label — known labels: ${[...labels].join(", ") || "(none)"}`,
-      );
+      add("unknown-timeline-label", a.path, `${a.path}: beat "${a.name}" at: "${a.at}" — unknown timeline label — known labels: ${[...labels].join(", ") || "(none)"}`);
     }
   }
   for (const a of startAnchors) {
     if (!labels.has(a.at)) {
-      problems.push(
-        `video "${a.id}" start: "${a.at}" — unknown timeline label — known labels: ${[...labels].join(", ") || "(none)"}`,
-      );
+      add("unknown-timeline-label", `nodes.${a.id}.start`, `video "${a.id}" start: "${a.at}" — unknown timeline label — known labels: ${[...labels].join(", ") || "(none)"}`);
     }
   }
 
@@ -281,70 +282,69 @@ export function validateScene(ir: SceneIR): void {
   }
 
   if (ir.duration !== undefined && ir.duration <= 0) {
-    problems.push("scene duration must be > 0");
+    add("bad-duration", "scene.duration", "scene duration must be > 0");
   }
 
   if (ir.camera) {
     if (nodeById.has("camera")) {
-      problems.push(`camera: a node is already named "camera" — rename that node or drop the scene camera (the id "camera" can't be both)`);
+      add("camera-node-conflict", "camera", `camera: a node is already named "camera" — rename that node or drop the scene camera (the id "camera" can't be both)`);
     }
     for (const [key, value] of Object.entries(ir.camera)) {
       if (key === "zSort") {
         // discrete, non-animatable flag (kept out of the numeric CAMERA_PROPS)
-        if (typeof value !== "boolean") problems.push(`camera.zSort must be a boolean`);
+        if (typeof value !== "boolean") add("camera-type", "camera.zSort", `camera.zSort must be a boolean`);
       } else if (!CAMERA_PROPS.includes(key)) {
-        problems.push(`camera: "${key}" is not a camera prop — valid props: ${CAMERA_PROPS.join(", ")}, zSort`);
+        add("unknown-camera-prop", `camera.${key}`, `camera: "${key}" is not a camera prop — valid props: ${CAMERA_PROPS.join(", ")}, zSort`);
       } else if (typeof value !== "number") {
-        problems.push(`camera.${key} must be a number`);
+        add("camera-type", `camera.${key}`, `camera.${key} must be a number`);
       } else if (key === "perspective" && value <= 0) {
-        problems.push(`camera.perspective must be > 0 (focal distance in px) — drop it to disable perspective`);
+        add("camera-perspective", "camera.perspective", `camera.perspective must be > 0 (focal distance in px) — drop it to disable perspective`);
       } else if (key === "aperture" && value < 0) {
-        problems.push(`camera.aperture must be >= 0 (blur px per unit depth) — 0 disables depth of field`);
+        add("camera-aperture", "camera.aperture", `camera.aperture must be >= 0 (blur px per unit depth) — 0 disables depth of field`);
       }
     }
   }
 
   for (const [i, cue] of (ir.audio?.cues ?? []).entries()) {
+    const cp = `audio.cues[${i}]`;
     if (typeof cue.at === "string" && !labels.has(cue.at)) {
-      problems.push(
-        `audio.cues[${i}]: unknown timeline label "${cue.at}" — known labels: ${[...labels].join(", ") || "(none)"}`,
-      );
+      add("unknown-timeline-label", cp, `${cp}: unknown timeline label "${cue.at}" — known labels: ${[...labels].join(", ") || "(none)"}`);
     }
     if (typeof cue.at === "number" && cue.at < 0) {
-      problems.push(`audio.cues[${i}]: "at" must be >= 0`);
+      add("bad-duration", cp, `${cp}: "at" must be >= 0`);
     }
     if ((cue.sfx === undefined) === (cue.file === undefined)) {
-      problems.push(`audio.cues[${i}]: exactly one of "sfx" or "file" is required`);
+      add("audio-cue-source", cp, `${cp}: exactly one of "sfx" or "file" is required`);
     }
     if (cue.sfx !== undefined && !(SFX_NAMES as readonly string[]).includes(cue.sfx)) {
-      problems.push(`audio.cues[${i}]: unknown sfx "${cue.sfx}" — valid: ${SFX_NAMES.join(", ")}`);
+      add("unknown-sfx", cp, `${cp}: unknown sfx "${cue.sfx}" — valid: ${SFX_NAMES.join(", ")}`);
     }
     if (cue.gain !== undefined && cue.gain < 0) {
-      problems.push(`audio.cues[${i}]: gain must be >= 0`);
+      add("audio-range", cp, `${cp}: gain must be >= 0`);
     }
     if (cue.fadeIn !== undefined && cue.fadeIn < 0) {
-      problems.push(`audio.cues[${i}]: fadeIn must be >= 0`);
+      add("audio-range", cp, `${cp}: fadeIn must be >= 0`);
     }
     if (cue.fadeOut !== undefined && cue.fadeOut < 0) {
-      problems.push(`audio.cues[${i}]: fadeOut must be >= 0`);
+      add("audio-range", cp, `${cp}: fadeOut must be >= 0`);
     }
     if (cue.pan !== undefined && (cue.pan < -1 || cue.pan > 1)) {
-      problems.push(`audio.cues[${i}]: pan must be in [-1, 1] (-1 left … +1 right)`);
+      add("audio-range", cp, `${cp}: pan must be in [-1, 1] (-1 left … +1 right)`);
     }
   }
   const duck = ir.audio?.bgm?.duck;
   if (typeof duck === "object" && duck !== null && duck.depth !== undefined && (duck.depth < 0 || duck.depth > 1)) {
-    problems.push("audio.bgm.duck.depth must be in [0, 1]");
+    add("audio-range", "audio.bgm.duck.depth", "audio.bgm.duck.depth must be in [0, 1]");
   }
   if (ir.audio?.bgm?.file !== undefined && ir.audio.bgm.synth !== undefined) {
-    problems.push('audio.bgm: use either "file" or "synth", not both');
+    add("bgm-both", "audio.bgm", 'audio.bgm: use either "file" or "synth", not both');
   }
   const bgmSynth = ir.audio?.bgm?.synth;
   if (bgmSynth !== undefined && !(BGM_SYNTHS as readonly string[]).includes(bgmSynth)) {
-    problems.push(`audio.bgm.synth: unknown synth "${bgmSynth}" — valid: ${BGM_SYNTHS.join(", ")}`);
+    add("unknown-synth", "audio.bgm.synth", `audio.bgm.synth: unknown synth "${bgmSynth}" — valid: ${BGM_SYNTHS.join(", ")}`);
   }
 
-  if (problems.length > 0) throw new SceneValidationError(problems);
+  if (issues.length > 0) throw new SceneValidationError(issues);
 }
 
 const TRANSITIONS = ["cut", "crossfade"];
@@ -352,8 +352,9 @@ const TRANSITIONS = ["cut", "crossfade"];
 /** Validate a composition: each scene is valid, scene ids are unique, transitions
  *  are known, and `at` strings parse. Throws SceneValidationError on any problem. */
 export function validateComposition(comp: CompositionIR): void {
-  const problems: string[] = [];
-  if (comp.scenes.length === 0) problems.push("composition has no scenes");
+  const issues: ValidationIssue[] = [];
+  const add = (code: string, path: string, message: string) => issues.push({ code, path, message });
+  if (comp.scenes.length === 0) add("empty-composition", "scenes", "composition has no scenes");
   const seen = new Set<string>();
   for (const [i, entry] of comp.scenes.entries()) {
     const where = `scenes[${i}]`;
@@ -361,22 +362,23 @@ export function validateComposition(comp: CompositionIR): void {
       validateScene(entry.scene);
     } catch (err) {
       if (err instanceof SceneValidationError) {
-        for (const p of err.problems) problems.push(`${where} (scene "${entry.scene.id}"): ${p}`);
+        // keep each child issue's code; nest its path + prefix its message
+        for (const issue of err.issues) add(issue.code, `${where}.${issue.path}`, `${where} (scene "${entry.scene.id}"): ${issue.message}`);
       } else throw err;
     }
     if (seen.has(entry.scene.id)) {
-      problems.push(`${where}: duplicate scene id "${entry.scene.id}" — scene ids must be unique in a composition`);
+      add("duplicate-scene-id", where, `${where}: duplicate scene id "${entry.scene.id}" — scene ids must be unique in a composition`);
     }
     seen.add(entry.scene.id);
     if (entry.transition !== undefined && !TRANSITIONS.includes(entry.transition)) {
-      problems.push(`${where}: unknown transition "${entry.transition}" — valid: ${TRANSITIONS.join(", ")}`);
+      add("unknown-transition", where, `${where}: unknown transition "${entry.transition}" — valid: ${TRANSITIONS.join(", ")}`);
     }
     if (typeof entry.at === "string" && Number.isNaN(Number(entry.at))) {
-      problems.push(`${where}: "at" string "${entry.at}" is not a number (use "-0.5"/"+0.5" or a number)`);
+      add("bad-at", where, `${where}: "at" string "${entry.at}" is not a number (use "-0.5"/"+0.5" or a number)`);
     }
     if (typeof entry.at === "number" && entry.at < 0) {
-      problems.push(`${where}: absolute "at" must be >= 0`);
+      add("bad-at", where, `${where}: absolute "at" must be >= 0`);
     }
   }
-  if (problems.length > 0) throw new SceneValidationError(problems);
+  if (issues.length > 0) throw new SceneValidationError(issues);
 }
diff --git a/packages/core/test/validate-issues.test.ts b/packages/core/test/validate-issues.test.ts
new file mode 100644
index 0000000..dc1d1b3
--- /dev/null
+++ b/packages/core/test/validate-issues.test.ts
@@ -0,0 +1,72 @@
+/**
+ * Structured validation: every problem carries a stable `code` + a `path` locator
+ * alongside the verbatim `message`. Back-compat (`.problems`/`.message`/class) is
+ * covered by the existing toThrow tests staying green; this pins the structure.
+ */
+import { describe, expect, it } from "vitest";
+import type { CompositionIR, SceneIR } from "../src/ir.js";
+import { SceneValidationError, validateComposition, validateScene, type ValidationIssue } from "../src/validate.js";
+
+function issuesOf(run: () => void): ValidationIssue[] {
+  try {
+    run();
+  } catch (e) {
+    if (e instanceof SceneValidationError) return e.issues;
+    throw e;
+  }
+  throw new Error("expected validation to throw");
+}
+const has = (issues: ValidationIssue[], code: string, path: string) =>
+  issues.some((i) => i.code === code && i.path === path);
+
+describe("structured validation issues", () => {
+  const bad: SceneIR = {
+    version: 1,
+    id: "t",
+    size: { width: 100, height: 100 },
+    nodes: [
+      { type: "rect", id: "box", props: { x: 0, y: 0, width: 10, height: 10, fill: "#fff", blend: "nope" } },
+      { type: "rect", id: "box", props: { x: 0, y: 0, width: 10, height: 10, fill: "#fff" } }, // duplicate id
+    ],
+    timeline: { kind: "beat", name: "b", at: "ghost", children: [{ kind: "wait", duration: 0.5 }] },
+  } as unknown as SceneIR;
+
+  it("each problem gets a stable code + path locator", () => {
+    const issues = issuesOf(() => validateScene(bad));
+    expect(has(issues, "unknown-blend", "nodes.box")).toBe(true);
+    expect(has(issues, "duplicate-node-id", "nodes.box")).toBe(true);
+    expect(has(issues, "unknown-timeline-label", "timeline")).toBe(true); // the beat's anchor
+  });
+
+  it("a prop error points at nodes.<id>.<prop>", () => {
+    const ir = {
+      version: 1, id: "t", size: { width: 100, height: 100 },
+      nodes: [{ type: "rect", id: "r", props: { x: 0, y: 0, width: 1, height: 1, fill: "#fff" } }],
+      states: { s: { r: { content: "x" } } }, // content is not a rect prop
+    } as unknown as SceneIR;
+    const issues = issuesOf(() => validateScene(ir));
+    expect(has(issues, "unknown-prop", "nodes.r.content")).toBe(true);
+  });
+
+  it("back-compat: .problems mirrors the messages and .message is the joined format", () => {
+    const issues = issuesOf(() => validateScene(bad));
+    const err = (() => {
+      try { validateScene(bad); } catch (e) { return e as SceneValidationError; }
+      throw new Error("unreachable");
+    })();
+    expect(err.problems).toEqual(issues.map((i) => i.message));
+    expect(err.message.startsWith("Scene validation failed:\n  - ")).toBe(true);
+    // a message is verbatim (byte-identical to the pre-refactor string)
+    expect(err.problems).toContain(`node "box": unknown blend "nope" — use normal, multiply, screen, overlay, lighten, darken, add, color-dodge, soft-light, hard-light, difference`);
+  });
+
+  it("composition issues keep the child code and nest the path", () => {
+    const mk = (id: string, blend?: string): SceneIR =>
+      ({ version: 1, id, size: { width: 1, height: 1 },
+         nodes: [{ type: "rect", id: "r", props: { x: 0, y: 0, width: 1, height: 1, fill: "#fff", ...(blend && { blend }) } }] } as unknown as SceneIR);
+    const comp = { id: "c", scenes: [{ scene: mk("a", "nope") }, { scene: mk("a") }] } as unknown as CompositionIR;
+    const issues = issuesOf(() => validateComposition(comp));
+    expect(has(issues, "unknown-blend", "scenes[0].nodes.r")).toBe(true); // nested path
+    expect(issues.some((i) => i.code === "duplicate-scene-id")).toBe(true);
+  });
+});
diff --git a/packages/reframe-video/package.json b/packages/reframe-video/package.json
index 72c9ca0..fb37134 100644
--- a/packages/reframe-video/package.json
+++ b/packages/reframe-video/package.json
@@ -1,6 +1,6 @@
 {
   "name": "reframe-video",
-  "version": "0.6.42",
+  "version": "0.6.43",
   "description": "Declarative motion graphics that AI can write and humans can tweak — human edits survive AI regeneration. Deterministic mp4 renders from a plain-data scene format.",
   "keywords": [
     "motion-graphics",
diff --git a/packages/reframe-video/scripts/build.ts b/packages/reframe-video/scripts/build.ts
index 52bf066..57242d6 100644
--- a/packages/reframe-video/scripts/build.ts
+++ b/packages/reframe-video/scripts/build.ts
@@ -100,12 +100,14 @@ await writeFile(join(PKG, "dist", "index.d.ts"), 'export * from "./types/index.j
 await writeFile(
   join(PKG, "dist", "compile-api.d.ts"),
   [
-    'import type { CompositionIR, SceneIR } from "./index.js";',
-    'export declare class SceneLoadError extends Error { readonly kind: "bundle" | "eval" | "validation"; }',
+    'import type { CompositionIR, SceneIR, ValidationIssue, LintFinding } from "./index.js";',
+    'export type { ValidationIssue } from "./index.js";',
+    'export declare class SceneLoadError extends Error { readonly kind: "bundle" | "eval" | "validation"; readonly issues?: ValidationIssue[]; }',
     "export declare function loadScene(path: string): Promise<SceneIR>;",
     "export declare function loadSceneFromCode(code: string, resolveDir?: string): Promise<SceneIR>;",
     "export declare function isComposition(def: unknown): def is CompositionIR;",
     'export declare function loadModule(path: string): Promise<{ kind: "scene"; ir: SceneIR } | { kind: "composition"; ir: CompositionIR }>;',
+    "export declare function checkDeterminism(path: string): Promise<{ deterministic: boolean; findings: LintFinding[] }>;",
     "",
   ].join("\n"),
 );
diff --git a/packages/render-cli/src/compile.ts b/packages/render-cli/src/compile.ts
index 0758c52..00f5a0e 100644
--- a/packages/render-cli/src/compile.ts
+++ b/packages/render-cli/src/compile.ts
@@ -66,8 +66,9 @@ async function main() {
 
 main().catch((err: unknown) => {
   const kind = err instanceof SceneLoadError ? err.kind : "eval";
+  const issues = err instanceof SceneLoadError ? err.issues : undefined;
   const message = err instanceof Error ? err.message : String(err);
-  if (jsonMode) process.stdout.write(`${JSON.stringify({ ok: false, error: message, kind })}\n`);
+  if (jsonMode) process.stdout.write(`${JSON.stringify({ ok: false, error: message, kind, ...(issues && { issues }) })}\n`);
   else console.error(`error: ${message}`);
   process.exit(1);
 });
diff --git a/packages/render-cli/src/compileApi.ts b/packages/render-cli/src/compileApi.ts
index 3ea86cc..f130e72 100644
--- a/packages/render-cli/src/compileApi.ts
+++ b/packages/render-cli/src/compileApi.ts
@@ -11,3 +11,4 @@
  */
 export { isComposition, loadModule, loadScene, loadSceneFromCode, SceneLoadError } from "./loadScene.js";
 export { checkDeterminism } from "./determinism.js";
+export type { ValidationIssue } from "@reframe/core";
diff --git a/packages/render-cli/src/loadScene.ts b/packages/render-cli/src/loadScene.ts
index 83380c6..d9a8c5a 100644
--- a/packages/render-cli/src/loadScene.ts
+++ b/packages/render-cli/src/loadScene.ts
@@ -16,7 +16,7 @@ import { build, type BuildOptions } from "esbuild";
 import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { validateComposition, validateScene, type CompositionIR, type SceneIR } from "@reframe/core";
+import { validateComposition, validateScene, type CompositionIR, type SceneIR, type ValidationIssue } from "@reframe/core";
 
 // In the published package the loader sits at dist/cli.js and core is the
 // prebuilt dist/index.js; in the repo it aliases to core's TS source.
@@ -30,10 +30,13 @@ const CORE_ENTRY =
 /** A load failure with a coarse stage so callers can branch / report structured errors. */
 export class SceneLoadError extends Error {
   readonly kind: "bundle" | "eval" | "validation";
-  constructor(kind: "bundle" | "eval" | "validation", message: string, options?: { cause?: unknown }) {
+  /** Structured validation problems (code + path + message), present for `kind === "validation"`. */
+  readonly issues?: ValidationIssue[];
+  constructor(kind: "bundle" | "eval" | "validation", message: string, options?: { cause?: unknown; issues?: ValidationIssue[] }) {
     super(message, options);
     this.name = "SceneLoadError";
     this.kind = kind;
+    if (options?.issues) this.issues = options.issues;
   }
 }
 
@@ -78,9 +81,12 @@ async function importDefault(code: string, label: string): Promise<unknown> {
   } catch (err) {
     // scene() runs validateScene at construction; that SceneValidationError
     // surfaces here. It comes from the scene's own bundled core, so match by
-    // name (cross-bundle `instanceof` would not).
-    const kind = err instanceof Error && err.name === "SceneValidationError" ? "validation" : "eval";
-    throw new SceneLoadError(kind, clean(err), { cause: err });
+    // name (cross-bundle `instanceof` would not). `.issues` is a plain-object
+    // property, so it reads across the bundle boundary even though the class
+    // identity differs.
+    const isValidation = err instanceof Error && err.name === "SceneValidationError";
+    const issues = isValidation ? (err as { issues?: ValidationIssue[] }).issues : undefined;
+    throw new SceneLoadError(isValidation ? "validation" : "eval", clean(err), { cause: err, ...(issues && { issues }) });
   }
   if (mod.default === undefined) throw new SceneLoadError("eval", `${label} must default-export a scene or composition`);
   return mod.default;
diff --git a/packages/render-cli/test/loadSceneIssues.test.ts b/packages/render-cli/test/loadSceneIssues.test.ts
new file mode 100644
index 0000000..6bd5512
--- /dev/null
+++ b/packages/render-cli/test/loadSceneIssues.test.ts
@@ -0,0 +1,41 @@
+/**
+ * `loadScene` surfaces structured validation issues on `SceneLoadError`. The error
+ * is thrown by the scene's OWN bundled core (cross-bundle), so `instanceof` fails and
+ * `.issues` must be read as a plain-object property — this guards that path.
+ */
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, describe, expect, it } from "vitest";
+import { loadScene, SceneLoadError } from "../src/loadScene.js";
+
+const dirs: string[] = [];
+async function fixture(src: string): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "reframe-issues-"));
+  dirs.push(dir);
+  const path = join(dir, "scene.ts");
+  await writeFile(path, src, "utf8");
+  return path;
+}
+afterAll(async () => {
+  await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })));
+});
+
+describe("loadScene → structured validation issues", () => {
+  it("attaches .issues (code + path) across the scene bundle boundary", async () => {
+    const src = `import { scene, rect } from "@reframe/core";
+export default scene({ id: "t", size: { width: 100, height: 100 },
+  nodes: [rect({ id: "box", x: 0, y: 0, width: 10, height: 10, fill: "#fff", blend: "nope" as never })] });`;
+    const path = await fixture(src);
+    try {
+      await loadScene(path);
+      throw new Error("expected load to throw");
+    } catch (e) {
+      expect(e).toBeInstanceOf(SceneLoadError);
+      const err = e as SceneLoadError;
+      expect(err.kind).toBe("validation");
+      expect(err.issues).toBeDefined();
+      expect(err.issues!.some((i) => i.code === "unknown-blend" && i.path === "nodes.box")).toBe(true);
+    }
+  }, 30_000);
+});