@revola-ai/video-craft 0.2.1

package/src/rules/lessTextMoreVisualizations.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from docs/style/CREATIVE_EDGE.md directive 4 ("less text more
+ * visualizations", "the voiceover should be what drives most of the textual
+ * information so the video should be primarily visuals and animations",
+ * "remove unnecessary text") - balanced by the one counter-round where a
+ * scene needed orientation copy added back ("add some more text in scene 6
+ * and enhance animations so users are not lost").
+ */
+export const lessTextMoreVisualizations: Rule = {
+  id: "less-text-more-visualizations",
+  claim: "The voiceover carries the information and the screen carries evidence: cut every text element that restates the VO or a neighboring label, replace word-lists with the actual marks and drawn subjects, and keep only text with a job - a name, a number with its denominator, the story spine for sound-off viewing, or one line of orientation copy where a viewer would otherwise be lost.",
+  why: "'Less text more visualizations' and 'too boring, no animations, text heavy and bad' recurred across videos - text-on-screen scenes got the PowerPoint verdict - while the one under-explained scene needed orientation copy added back, so comprehension, not word count, is the target.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A per-element editorial judgment against the VO script; no single code location expresses it.",
+  },
+};

package/src/rules/liveLinkDuplicateReactAlias.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "If the live-link render fails with a
+ * duplicate React/Remotion instance error, add the webpack alias override
+ * from the link-kit workflow." Note: the doc's "see remotion.config.ts
+ * mitigation" pointer does not currently resolve to live code in either
+ * project config (recorded follow-up in the design doc); linkKit is where
+ * the live-link workflow lives.
+ */
+export const liveLinkDuplicateReactAlias: Rule = {
+  id: "live-link-duplicate-react-alias",
+  claim: "If a live-linked kit render fails with a duplicate React or Remotion instance error, fix it with the webpack alias override in the project's Remotion config, not by abandoning the link.",
+  why: "The symlinked kit can resolve a second React or Remotion copy from the monorepo root; without the known fix, the failure looks like a kit bug and costs a debugging session.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/kitShell.ts", symbol: "linkKit" },
+  },
+};

package/src/rules/make2dElements3d.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from docs/style/CREATIVE_EDGE.md directive 3 ("make 2d elements 3d",
+ * "much more cinematic, with amazing transitions - something zooming inside
+ * another one, a 3D effect, something rotating and changing", "More 3D
+ * elements too"). The cabinet-projection buildings and orbit camera moves
+ * were the approved implementations.
+ */
+export const make2dElements3d: Rule = {
+  id: "make-2d-elements-3d",
+  claim: "Give flat hero elements depth: perspective or cabinet projection, parallax planes, rotation in space, zoom-through or orbit camera moves, ground-contact plus long-throw shadows; a flat cutout sitting on a flat ground is an amplify target, and external 3D packages are welcome when they serve the look.",
+  why: "'Make 2d elements 3d' and 'more 3D elements too' were standing amplify notes across videos; flat-on-flat heroes read as clipart while projected depth is what earned 'cinematic' in review.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A depth-treatment judgment per hero element; no single code location expresses it.",
+  },
+};

package/src/rules/masterMixLoudnessTarget.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from claude-sessions-digest/portfolio-reels.md: an external
+ * frame-by-frame audit flagged the mix at -20.3 LUFS as "objectively too
+ * quiet"; the fix normalized to -14 LUFS integrated with a -1 dBTP limiter
+ * (the streaming-platform standard), verified with ffmpeg loudnorm.
+ */
+export const masterMixLoudnessTarget: Rule = {
+  id: "master-mix-loudness-target",
+  claim: "Master the final mix to -14 LUFS integrated with a -1 dBTP true-peak limit, and verify with ffmpeg loudnorm before delivery.",
+  why: "A -20 LUFS master shipped and was caught only by an external audit; the target is a fixed number, so missing it is pure process failure.",
+  learnedFrom: "claude-sessions-digest/portfolio-reels.md",
+  tier: "gate",
+  verify: "`video radar:film --project <dir> --video <mp4> --check loudness`",
+  owner: "loudness",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The check runs on the rendered file at delivery time; no repo code location expresses it yet.",
+  },
+};

package/src/rules/measureAlignmentDontEyeball.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from the product-room build: 'the knowledge blocks aren't centered'
+ * was diagnosed by loading the PNG and comparing the card's left edge (x=203)
+ * to its first text pixel (x=205), which proved padding was being wiped.
+ * Eyeballing had missed it across three rounds.
+ */
+export const measureAlignmentDontEyeball: Rule = {
+  id: "measure-alignment-dont-eyeball",
+  claim: "Answer an alignment or centering complaint with measured pixels - panel edge versus first content pixel, sibling baselines against each other - never by eye.",
+  why: "Eyeballing a downscaled frame hid a 2px content inset where 20px was intended and a 6px spread across three sibling CTAs; both were unarguable once measured, and the measurement also proved the fix.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A review-time discipline over rendered PNGs; there is no source symbol that can assert it.",
+  },
+};

package/src/rules/motionCarriesWeightAndMeaning.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from docs/style/CREATIVE_EDGE.md directive 11 ("the building can
+ * fall from the sky and hit the ground, with impact and dust", "something
+ * should jump out of the cards and fade away, like giving the message that
+ * it falls", versus "the 4 things do not have to revolve - just make them
+ * bigger").
+ */
+export const motionCarriesWeightAndMeaning: Rule = {
+  id: "motion-carries-weight-and-meaning",
+  claim: "Motion is physical and means something: objects obey weight - they fall, land with squash and dust, dock flush with a contact pulse, slam with a punch on settle - and the VO's verbs become literal choreography; ornamental motion with no narrative meaning (revolving for its own sake, dashed rings) gets cut.",
+  why: "Weighted, meaningful motion was requested by name ('fall from the sky and hit the ground, with impact and dust') and meaningless ornament was cut by name ('the 4 things do not have to revolve'); motion that neither enacts the script nor obeys physics read as filler.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A meaning-per-motion judgment against the VO script; no single code location expresses it.",
+  },
+};

package/src/rules/motionDensityFloor.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from the product-room build: round one added continuous drift to
+ * every layer and was still rejected as static. The craft digest quantifies
+ * the target - ~15 beat starts in 348 design frames, 2-3 concurrent through
+ * the middle - and pairs it with lateness-is-structural-overlap-the-beats.
+ */
+export const motionDensityFloor: Rule = {
+  id: "motion-density-floor",
+  claim: "Hold a visible state change roughly every half second, with two or three beats overlapping through the middle of a section; continuous background drift alone does not clear the bar.",
+  why: "A first pass that satisfied the no-static-holds rule with idle drift still came back as 'not much animation, just static screens'; the reference films run about one beat start every 0.6s with beats deliberately overlapping, and that density is what reads as authored.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A pacing property of a whole section, measurable only across its beat schedule.",
+  },
+};

package/src/rules/neverEditTierBVendored.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "They are used unmodified - theming is
+ * props + CSS vars, never edits (edits move you into the port lane and
+ * forfeit updates)." The hash-vs-upstream check needs network access, so it
+ * is not a vitest-gate source check; the rule text is what stops the edit.
+ */
+export const neverEditTierBVendored: Rule = {
+  id: "never-edit-tier-b-vendored",
+  claim: "Never edit a Tier B vendored remocn source file; theme it only via props and CSS vars.",
+  why: "An edit silently moves the component into the port lane and forfeits update-safety: shadcn add can no longer pull upstream fixes without clobbering or conflicting.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/components/remocn/backdrop.tsx" },
+  },
+};

package/src/rules/neverRestateDerivedFrameNumbersInComments.ts

@@ -0,0 +1,20 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from revola-video/BUILD_NOTES_CRAFT.md: "S_S3's comment said 624
+ * while the computed value was 588 (stale from when D_S1 was 384) - cost a
+ * wasted render batch aimed at the wrong seam." The derived S_S2 = S_S1 +
+ * P_S1 chain in tokensCraft.ts is what comments must not restate.
+ */
+export const neverRestateDerivedFrameNumbersInComments: Rule = {
+  id: "never-restate-derived-frame-numbers-in-comments",
+  claim: "Do not hand-copy derived frame values into comments; a comment stating a computed seam or start frame goes stale the moment an upstream duration moves.",
+  why: "S_S3's comment said 624 while the computed value was 588, stale from an earlier D_S1, which aimed an entire render batch at the wrong seam.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/tokensCraft.ts" },
+  },
+};

package/src/rules/noAiGradientLook.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from claude-sessions-digest/portfolio-reels.md ("Is it too
+ * blue-purple, like AI?"; "Don't use purple-blue; use the original colors")
+ * and the use-case digests ("the blue-purple gives AI vibes"; "the gradient
+ * colors are ai generated in scene 4"). The single most repeated feedback
+ * category across every video: generic blue-purple gradient washes, blob
+ * shapes, and heavy blur/glow backdrops read as AI-template output.
+ */
+export const noAiGradientLook: Rule = {
+  id: "no-ai-gradient-look",
+  claim: "Never style with generic blue-purple gradient washes, blob shapes, or heavy blur/glow backdrops; backgrounds are a brand-appropriate base plus at most a subtle single-hue aura.",
+  why: "Viewers read the blue-purple gradient wash as AI-template output before they can name why; it was rejected in every single video and purple hexes kept creeping back into new code, costing repeated grep-and-purge rounds.",
+  learnedFrom: "claude-sessions-digest/portfolio-reels.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/react/theme.tsx" },
+  },
+};

package/src/rules/noColoredFlashToHideACut.ts

@@ -0,0 +1,29 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from revola-video/BUILD_NOTES_CRAFT.md: "Violet light bridge. Fixed
+ * the hole ... but read as a purple wash on the frame. ... even tightened to
+ * ~14f it was rejected. The colour is the problem, not the timing." The rig
+ * was deleted, so the anchor is CraftStage's file - the place such an overlay
+ * would be reintroduced.
+ */
+export const noColoredFlashToHideACut: Rule = {
+  id: "no-colored-flash-to-hide-a-cut",
+  claim: "Do not hide a cut behind a colored light flash or bloom bridge; the color reads as a wash on the frame regardless of how short you make it.",
+  why: "The violet light bridge made the cut genuinely invisible yet was rejected twice, at 40f and again tightened to ~14f, because the problem was the color, not the timing.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  exceptions: [
+    {
+      project: "qse-qguard-video",
+      decision:
+        "client chose ACT854's transition verbatim for the QGuard restyle, accent flash at the blade's apex included, over the sanctioned white LightSweep",
+      recordedIn: "qse-qguard-video/docs/motion-brand-spec.md",
+    },
+  ],
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/craftKit.tsx" },
+  },
+};

package/src/rules/noDoubleFrameShift.test.ts

@@ -0,0 +1,95 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Project, ts } from "ts-morph";
+import { describe, expect, test } from "vitest";
+import { toolchainRepoRoot as repoRoot } from "../testSupport";
+import { checkFile } from "../sourceCheck";
+import { noDoubleFrameShift } from "./noDoubleFrameShift";
+
+const check = () => {
+  if (noDoubleFrameShift.enforcement.kind !== "source") throw new Error("expected a source rule");
+  return noDoubleFrameShift.enforcement.check;
+};
+
+const run = (name: string) => {
+  const rel = `packages/video-craft/src/fixtures/double-shift/${name}`;
+  return checkFile(check(), join(repoRoot, rel), rel, repoRoot);
+};
+
+/** The verbatim pre-fix scene is frozen as .tsx.txt (its real imports do not
+ *  resolve inside video-craft, so it must stay outside the typecheck globs);
+ *  parse it through a virtual .tsx path so the check sees real TSX. */
+const runFrozen = (name: string) => {
+  const rel = `packages/video-craft/src/fixtures/double-shift/${name}`;
+  const text = readFileSync(join(repoRoot, rel), "utf8");
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: { allowJs: true, jsx: ts.JsxEmit.ReactJSX },
+  });
+  return check().run(project.createSourceFile("frozen-fixture.tsx", text), rel, repoRoot);
+};
+
+describe("noDoubleFrameShift", () => {
+  test("fires on build 4's pre-fix mechanism.tsx verbatim (`const lf = frame - win.from` inside a Sequence)", () => {
+    const findings = runFrozen("mechanism-prefix.tsx.txt");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].match).toBe("win.from");
+    expect(findings[0].line).toBe(155);
+    expect(findings[0].message).toMatch(/Sequence already localizes/);
+    expect(findings[0].message).toMatch(/cue\(\)/);
+  });
+
+  test("fires on the aliased variant (window rebound through a second binding)", () => {
+    const findings = run("aliased.tsx");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].match).toBe("w.from");
+  });
+
+  test("fires on the destructured variant (no `.from` access in the text)", () => {
+    const findings = run("destructured.tsx");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].match).toBe("from: sectionStart");
+  });
+
+  test("fires on the wrapped variants (helpers over windowFor and SECTION_WINDOWS)", () => {
+    const findings = run("wrapped.tsx");
+    expect(findings.map((f) => f.match)).toEqual([
+      "windowFor(\"mechanism\").from",
+      "SECTION_WINDOWS[0].from",
+    ]);
+  });
+
+  test("fires on the element-access variant (`win[\"from\"]`)", () => {
+    const findings = run("elementAccess.tsx");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].match).toBe("win[\"from\"]");
+  });
+
+  test("fires when the window flows through a plain assignment, not a declaration initializer", () => {
+    const findings = run("assigned.tsx");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].match).toBe("w.from");
+  });
+
+  test("does not fire on cue()/cueEnd(), durationInFrames, non-window `.from`, or Array.from", () => {
+    expect(run("clean.tsx")).toEqual([]);
+  });
+
+  test("does not fire on a file with no layout-module import at all", () => {
+    // Any existing fixture without a layout import works as the null case.
+    const rel = "packages/video-craft/src/fixtures/deterministic-scene.tsx";
+    expect(checkFile(check(), join(repoRoot, rel), rel, repoRoot)).toEqual([]);
+  });
+
+  test("scopes to scene subtrees and exempts geometry sidecars and the qguard film-level Chrome layer", () => {
+    expect(check().include).toEqual([
+      "*/src/scenes/**/*.{js,jsx,ts,tsx}",
+      "*/03_scenes/**/*.{js,jsx,ts,tsx}",
+    ]);
+    expect(check().exclude).toEqual([
+      "*/src/scenes/scene.*.geometry.ts",
+      "qse-qguard-video/src/scenes/Chrome.tsx",
+      "reverence-video/src/scenes/Mix.tsx",
+    ]);
+  });
+});

package/src/rules/noDoubleFrameShift.ts

@@ -0,0 +1,193 @@
+import { Node, SyntaxKind } from "ts-morph";
+import type { Rule, SourceFinding } from "../types";
+
+/**
+ * Mined from build 4 (docs/superpowers/specs/2026-08-13-build-speed-phase-spec.md,
+ * WS5): 2 of 3 generated scenes computed `const lf = frame - win.from` INSIDE
+ * their section's Sequence. A Sequence already localizes useCurrentFrame(),
+ * so subtracting the window's composition-space `from` shifts the clock twice -
+ * harmless for section 0 (from === 0), catastrophic after it: mechanism's
+ * whole rig rendered 264 frames in the past, and nothing failed. Layout's
+ * cue()/cueEnd() are the sanctioned in-scene clock; a scene module has no
+ * business reading a section window's `from` at all.
+ *
+ * The check is AST-level, not a regex, because the evasion shapes are the
+ * natural way a generator writes the bug: an aliased window
+ * (`const w = win; frame - w.from`), a destructured `from`
+ * (`const { from } = windowFor(id)`), and helper wrappers whose call sites
+ * never mention `from`. It activates only in files that import `windowFor`
+ * or `SECTION_WINDOWS` (aliases included) from a module whose specifier
+ * basename is `layout`, then taints every binding transitively assigned a
+ * window and reports each `.from` read (property access or destructure) on a
+ * tainted expression. `.from` on anything untainted (a token object,
+ * `Array.from`) never matches, and `durationInFrames` stays legal - a
+ * window's length is Sequence-local by definition.
+ *
+ * Scoping carries the other half of the semantics: film-level seam math is
+ * legitimate (Film.tsx computing SFX anchors from a window's `from` reads the
+ * composition timeline), so the globs cover only scene subtrees, and the three
+ * known scene-directory residents that run on the composition clock - geometry
+ * sidecars, qse-qguard's Chrome layer (rendered outside any Sequence in
+ * QGuardFilm.tsx), and reverence-video's Mix layer (same, in ReverenceFilm.tsx)
+ * - are excluded by name. The tell for this class is always where the
+ * component is MOUNTED, never where the file lives.
+ */
+export const noDoubleFrameShift: Rule = {
+  id: "no-double-frame-shift",
+  claim: "Never rebase a scene's clock by its section window's `from`: a Sequence already localizes frames, so a scene module must not read `windowFor(...).from` (aliased, destructured, or wrapped included); layout's cue()/cueEnd() are the sanctioned clock.",
+  why: "Build 4's mechanism scene computed `frame - win.from` inside its Sequence, shifting the clock twice; the whole rig rendered 264 frames in the past and nothing failed - the film shipped a round late because only human eyes caught it.",
+  learnedFrom: "docs/superpowers/specs/2026-08-13-build-speed-phase-spec.md",
+  tier: "gate",
+  verify: "`vitest run packages/video-craft` - machine-checked over every scene subtree",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      // Scene subtrees only, every project (`*` head = wildcard coverage):
+      // the rule keys on a layout-module import, so projects without the
+      // windowFor pattern are inert by construction. Film-level modules live
+      // outside scenes/ and stay exempt; the two composition-clock residents
+      // OF scenes/ are excluded by name (see the header comment).
+      include: [
+        "*/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "*/03_scenes/**/*.{js,jsx,ts,tsx}",
+      ],
+      exclude: [
+        "*/src/scenes/scene.*.geometry.ts",
+        "qse-qguard-video/src/scenes/Chrome.tsx",
+        // The film's SFX mixer, not a scene: ReverenceFilm.tsx mounts <Mix /> as
+        // a sibling of the SECTION_WINDOWS.map() block, outside every section
+        // Sequence, so its `windowFor(id).from + local` IS the composition
+        // timeline - the same film-level seam math this rule's header calls
+        // legitimate, and the same shape as rcp-fund7's Film.tsx SFX anchors.
+        "reverence-video/src/scenes/Mix.tsx",
+      ],
+      run(file, relPath): SourceFinding[] {
+        // 1. Local names bound to windowFor / SECTION_WINDOWS from a module
+        // whose specifier basename is "layout" (aliased imports included).
+        const windowForNames = new Set<string>();
+        const windowsNames = new Set<string>();
+        for (const imp of file.getImportDeclarations()) {
+          const specifier = imp.getModuleSpecifierValue();
+          if (specifier.split("/").pop() !== "layout") continue;
+          for (const named of imp.getNamedImports()) {
+            const source = named.getName();
+            const local = named.getAliasNode()?.getText() ?? source;
+            if (source === "windowFor") windowForNames.add(local);
+            if (source === "SECTION_WINDOWS") windowsNames.add(local);
+          }
+        }
+        if (windowForNames.size === 0 && windowsNames.size === 0) return [];
+
+        // 2. Taint every binding transitively assigned a window. Fixpoint,
+        // because aliases can chain (`const w = win`) in either source order.
+        const windowVars = new Set<string>();
+        const unwrap = (node: Node): Node => {
+          let n = node;
+          while (
+            Node.isParenthesizedExpression(n) ||
+            Node.isAsExpression(n) ||
+            Node.isNonNullExpression(n) ||
+            Node.isSatisfiesExpression(n)
+          ) {
+            n = n.getExpression();
+          }
+          return n;
+        };
+        /** The leftmost identifier of an access/call chain, e.g.
+         *  `SECTION_WINDOWS[0]`, `SECTION_WINDOWS.find(...)`. */
+        const rootIdentifier = (node: Node): string | undefined => {
+          let n = unwrap(node);
+          while (
+            Node.isPropertyAccessExpression(n) ||
+            Node.isElementAccessExpression(n) ||
+            Node.isCallExpression(n)
+          ) {
+            n = unwrap(n.getExpression());
+          }
+          return Node.isIdentifier(n) ? n.getText() : undefined;
+        };
+        const isWindowExpr = (node: Node): boolean => {
+          const n = unwrap(node);
+          if (Node.isIdentifier(n)) return windowVars.has(n.getText());
+          if (Node.isCallExpression(n)) {
+            const callee = unwrap(n.getExpression());
+            if (Node.isIdentifier(callee) && windowForNames.has(callee.getText())) return true;
+          }
+          // Anything rooted at SECTION_WINDOWS (an index, a .find(...)) is a
+          // window as far as a `.from` read is concerned.
+          const root = rootIdentifier(n);
+          return root !== undefined && windowsNames.has(root);
+        };
+
+        // Known limitation: no inter-procedural taint. A window flowing
+        // through a FUNCTION PARAMETER (`const helper = (w) => frame - w.from`)
+        // is not tracked - the parameter binding is never tainted, so `.from`
+        // reads inside the helper's body escape this rule.
+        //
+        // The AST is never mutated, so descendant queries are hoisted out of
+        // the fixpoint loop and the cached arrays are iterated instead.
+        const varDecls = file.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+        const binaryExprs = file.getDescendantsOfKind(SyntaxKind.BinaryExpression);
+        for (let grew = true; grew; ) {
+          grew = false;
+          const taint = (name: Node) => {
+            if (Node.isIdentifier(name) && !windowVars.has(name.getText())) {
+              windowVars.add(name.getText());
+              grew = true;
+            }
+          };
+          for (const decl of varDecls) {
+            const init = decl.getInitializer();
+            if (!init || !isWindowExpr(init)) continue;
+            taint(decl.getNameNode());
+          }
+          // Assignment taint: `let w; w = windowFor(id)` - a plain `=` whose
+          // right-hand side is a window taints the assigned identifier just
+          // like a declaration initializer would.
+          for (const bin of binaryExprs) {
+            if (bin.getOperatorToken().getKind() !== SyntaxKind.EqualsToken) continue;
+            if (!isWindowExpr(bin.getRight())) continue;
+            taint(unwrap(bin.getLeft()));
+          }
+        }
+
+        // 3. Report every `.from` read on a tainted expression: property
+        // accesses and destructures alike.
+        const findings: SourceFinding[] = [];
+        const report = (node: Node) => {
+          findings.push({
+            file: relPath,
+            line: node.getStartLineNumber(),
+            match: node.getText().replace(/\s+/g, " ").slice(0, 60),
+            message:
+              "a Sequence already localizes the clock: reading a section window's `from` inside a scene " +
+              "module double-shifts every frame it feeds (build 4's mechanism rendered 264 frames in the " +
+              "past); use layout's cue()/cueEnd() for in-scene beats",
+          });
+        };
+        for (const access of file.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
+          if (access.getName() !== "from") continue;
+          if (isWindowExpr(access.getExpression())) report(access);
+        }
+        // Element access spelling: `win["from"]` reads the same field a
+        // property access does; only literal "from" keys match.
+        for (const access of file.getDescendantsOfKind(SyntaxKind.ElementAccessExpression)) {
+          const arg = unwrap(access.getArgumentExpression() ?? access);
+          if (!Node.isStringLiteral(arg) || arg.getLiteralText() !== "from") continue;
+          if (isWindowExpr(access.getExpression())) report(access);
+        }
+        for (const decl of varDecls) {
+          const name = decl.getNameNode();
+          const init = decl.getInitializer();
+          if (!Node.isObjectBindingPattern(name) || !init || !isWindowExpr(init)) continue;
+          for (const element of name.getElements()) {
+            const property = element.getPropertyNameNode()?.getText() ?? element.getName();
+            if (property === "from") report(element);
+          }
+        }
+        return findings;
+      },
+    },
+  },
+};

package/src/rules/noDuplicateMotionPrimitives.ts

@@ -0,0 +1,19 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "Note revola-video already has a
+ * hand-built WhipPan in src/transitions/; do not create a third." The anchor
+ * is the existing primitive the doc warns against duplicating.
+ */
+export const noDuplicateMotionPrimitives: Rule = {
+  id: "no-duplicate-motion-primitives",
+  claim: "Before adding a registry component or porting one, check for an existing hand-built equivalent in the project; never create a second implementation of the same primitive.",
+  why: "Two implementations of the same transition drift apart and double every future styling and timing fix - the _lib fork problem at component granularity.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/transitions/WhipPan.tsx" },
+  },
+};

package/src/rules/noLinearMotion.ts

@@ -0,0 +1,29 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from HOW_I_BUILD_VIDEOS.md: "everything animates via spring() or
+ * eased interpolate() - nothing linear". Demoted from an AST check because
+ * flagging interpolate() without an easing option would hit legitimate
+ * non-visible uses (progress plumbing, spring-driven inputs); this is
+ * doctrine, not mechanics.
+ */
+export const noLinearMotion: Rule = {
+  id: "no-linear-motion",
+  claim: "Animate everything with spring() or eased interpolate(); never linear interpolation for visible motion.",
+  why: "Linear motion reads as mechanical and cheap - the doctrine violation viewers perceive even when they cannot name it.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  exceptions: [
+    {
+      project: "qse-qguard-video",
+      decision:
+        "ACT854's un-eased win()/camPush() envelopes are ported verbatim at the client's direction; eased variants ship alongside behind a one-line flag",
+      recordedIn: "qse-qguard-video/docs/motion-brand-spec.md",
+    },
+  ],
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/react/motion.ts" },
+  },
+};

package/src/rules/noNestedSvgFilters.test.ts

@@ -0,0 +1,47 @@
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { toolchainRepoRoot as repoRoot } from "../testSupport";
+import { checkFile } from "../sourceCheck";
+import { noNestedSvgFilters } from "./noNestedSvgFilters";
+
+const check = () => {
+  if (noNestedSvgFilters.enforcement.kind !== "source") throw new Error("expected a source rule");
+  return noNestedSvgFilters.enforcement.check;
+};
+
+const run = (name: string) => {
+  const rel = `packages/video-craft/src/fixtures/${name}`;
+  return checkFile(check(), join(repoRoot, rel), rel, repoRoot);
+};
+
+describe("noNestedSvgFilters", () => {
+  test("fires on a filtered element inside a filtered ancestor, once, on the inner element", () => {
+    const findings = run("nested-filters-broken.tsx");
+    expect(findings).toHaveLength(1);
+    expect(findings[0].message).toMatch(/nested CSS filter/);
+    expect(findings[0].line).toBe(8);
+    expect(findings[0].match).toContain('<path d="M0 0 L10 30"');
+    expect(findings[0].match.length).toBeLessThanOrEqual(60);
+  });
+
+  test("does not fire when only the outer layer is filtered", () => {
+    expect(run("nested-filters-fixed.tsx")).toEqual([]);
+  });
+
+  test("does not fire on filtered siblings", () => {
+    expect(run("nested-filters-siblings.tsx")).toEqual([]);
+  });
+
+  test("does not fire on nested filters outside an <svg>", () => {
+    expect(run("nested-filters-html.tsx")).toEqual([]);
+  });
+
+  test("does not fire when the filtered ancestor is an HTML wrapper around the <svg>", () => {
+    expect(run("nested-filters-html-wrapper.tsx")).toEqual([]);
+  });
+
+  test("covers both project layouts", () => {
+    expect(check().include).toContain("qpa-video/03_scenes/**/*.jsx");
+    expect(check().include).toContain("revola-video/src/scenes/**/*.tsx");
+  });
+});