@revola-ai/video-craft 0.2.1

package/dist/rules/heroFillsTheFrame.js

@@ -0,0 +1,17 @@
+const heroFillsTheFrame = {
+  id: "hero-fills-the-frame",
+  claim: "The hero element of a shot fills roughly two thirds of the frame or more, legible at 1080p; a hero occupying a third of the screen is a defect, and when enlarging, overshoot rather than nudge.",
+  why: "Undersized heroes were flagged in five separate rounds across three videos, and every timid enlargement needed a second round; 'play big' is the single most repeated scale note in the corpus.",
+  learnedFrom: "claude-sessions-digest/revola-usecase-win-booth.md",
+  tier: "gate",
+  verify: "`video radar:scene --project <dir> --comp <id> --check hero-size`",
+  owner: "hero-size",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule is a composition judgment per shot; no single code location expresses it."
+  }
+};
+export {
+  heroFillsTheFrame
+};

package/dist/rules/htmlMasksForAnimatedCounters.js

@@ -0,0 +1,15 @@
+const htmlMasksForAnimatedCounters = {
+  id: "html-masks-for-animated-counters",
+  claim: "Build animated sliding-mask counters (odometers, digit rolls) in HTML/CSS rather than SVG clipPath; animated clipPath geometry is unreliable in headless renders.",
+  why: "The S3 odometer built on SVG clipPath rendered inconsistently in headless Chrome and had to be rebuilt in HTML; static clipPath (e.g. InkFill) remains fine.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/S3Line.tsx" }
+  }
+};
+export {
+  htmlMasksForAnimatedCounters
+};

package/dist/rules/impactStackOnPayoffs.js

@@ -0,0 +1,15 @@
+const impactStackOnPayoffs = {
+  id: "impact-stack-on-payoffs",
+  claim: "Land each payoff with several simultaneous signals on the same frame - ring pulse, scale punch, light sweep, one approved foley hit - and vary which signals each class of payoff uses.",
+  why: "A single fade or count-up reads as a value changing; the stacked signal reads as a moment landing, and varying the stack per payoff class is what keeps four payoffs in one film from reading as the same template beat.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A choreography discipline composed per beat from several primitives; it has no single owning symbol."
+  }
+};
+export {
+  impactStackOnPayoffs
+};

package/dist/rules/interactiveTargetsAreDeclaredData.js

@@ -0,0 +1,15 @@
+const interactiveTargetsAreDeclaredData = {
+  id: "interactive-targets-are-declared-data",
+  claim: "A control the cursor clicks and the cursor path that clicks it must read the same declared coordinate; if a target is measured off a render instead, record the measurement and re-verify it after any layout change.",
+  why: "Cursor targets positioned by eye drifted out from under their controls as the layout changed - one click landed 122px right and 155px below its button while the button lit up on its own - and nothing in the build could detect it.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/components/Cursor.tsx" }
+  }
+};
+export {
+  interactiveTargetsAreDeclaredData
+};

package/dist/rules/interpolateLiteralKeysMonotonic.js

@@ -0,0 +1,79 @@
+import { Node, SyntaxKind } from "ts-morph";
+function literalValue(element) {
+  if (Node.isNumericLiteral(element)) return element.getLiteralValue();
+  if (Node.isPrefixUnaryExpression(element) && element.getOperatorToken() === SyntaxKind.MinusToken) {
+    const operand = element.getOperand();
+    if (Node.isNumericLiteral(operand)) return -operand.getLiteralValue();
+  }
+  return void 0;
+}
+const interpolateLiteralKeysMonotonic = {
+  id: "interpolate-literal-keys-monotonic",
+  claim: "A literal input-range array passed to interpolate() must be strictly ascending.",
+  why: "interpolate() throws at runtime on a non-monotonic range; a literal non-ascending array is a latent crash that renders fine until that frame is reached. The HERO_AT(134)/TILT_END(136) retime would have thrown.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "gate",
+  verify: "`vitest run packages/video-craft` - machine-checked over scene and kit source",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      // Unlike the JSX-only checks, this one also scans plain .ts/.js:
+      // interpolate() lives in non-JSX helpers feeding scenes
+      // (spec-videos/src/lib/transitions.ts, packages/video-kit/src/react/
+      // motion.ts, qse-investor-video/03_scenes/_lib/motion.js), and a
+      // non-monotonic literal range crashes wherever it is written.
+      include: [
+        "qpa-video/03_scenes/**/*.{js,jsx,ts,tsx}",
+        "reverence-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "workday-dple-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "revola-video/src/scenes/**/*.{js,jsx,ts,tsx}",
+        "datapeak-video/**/*.{js,jsx,ts,tsx}",
+        "datapeak-usecases/**/*.{js,jsx,ts,tsx}",
+        "qse-video/**/*.{js,jsx,ts,tsx}",
+        "qse-investor-video/**/*.{js,jsx,ts,tsx}",
+        "qse-qguard-video/src/**/*.{ts,tsx}",
+        "rcp-fund7-video/src/**/*.{ts,tsx}",
+        "expanse-video/src/**/*.{ts,tsx}",
+        "reverence-video/src/**/*.{ts,tsx}",
+        "spec-videos/**/*.{js,jsx,ts,tsx}",
+        // Added Task 23: klaviyo-segments-video and radar-fixture-video were
+        // silently excluded - the same gap deterministic-scene-source had.
+        "klaviyo-segments-video/src/**/*.{js,jsx,ts,tsx}",
+        "radar-fixture-video/src/**/*.{js,jsx,ts,tsx}",
+        "packages/video-kit/src/**/*.{ts,tsx}"
+      ],
+      run: (file, relPath) => {
+        const findings = [];
+        for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+          if (call.getExpression().getText() !== "interpolate") continue;
+          const range = call.getArguments()[1];
+          if (!range || !Node.isArrayLiteralExpression(range)) continue;
+          const values = [];
+          let allLiteral = true;
+          for (const element of range.getElements()) {
+            const value = literalValue(element);
+            if (value === void 0) {
+              allLiteral = false;
+              break;
+            }
+            values.push(value);
+          }
+          if (!allLiteral) continue;
+          const ascending = values.every((v, i) => i === 0 || values[i - 1] < v);
+          if (ascending) continue;
+          findings.push({
+            file: relPath,
+            line: call.getStartLineNumber(),
+            match: range.getText().replace(/\s+/g, " ").slice(0, 60),
+            message: `interpolate() input range [${values.join(", ")}] is not strictly ascending; interpolate() throws at runtime when this frame range is evaluated.`
+          });
+        }
+        return findings;
+      }
+    }
+  }
+};
+export {
+  interpolateLiteralKeysMonotonic
+};

package/dist/rules/latenessIsStructuralOverlapTheBeats.js

@@ -0,0 +1,15 @@
+const latenessIsStructuralOverlapTheBeats = {
+  id: "lateness-is-structural-overlap-the-beats",
+  claim: "When a key element arrives late, check whether the delay is structural (strictly sequential prerequisite beats) before shaving durations; the fix is to overlap beats, not to trim them.",
+  why: "Two shave passes (420f to 396f, deck 232 to 196) failed to fix a late deck because the hook, tilt, and field pop all had to finish first; overlapping them fixed it in one pass.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/S1Graveyard.tsx" }
+  }
+};
+export {
+  latenessIsStructuralOverlapTheBeats
+};

package/dist/rules/lessTextMoreVisualizations.js

@@ -0,0 +1,15 @@
+const lessTextMoreVisualizations = {
+  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."
+  }
+};
+export {
+  lessTextMoreVisualizations
+};

package/dist/rules/liveLinkDuplicateReactAlias.js

@@ -0,0 +1,15 @@
+const liveLinkDuplicateReactAlias = {
+  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" }
+  }
+};
+export {
+  liveLinkDuplicateReactAlias
+};

package/dist/rules/make2dElements3d.js

@@ -0,0 +1,15 @@
+const make2dElements3d = {
+  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."
+  }
+};
+export {
+  make2dElements3d
+};

package/dist/rules/masterMixLoudnessTarget.js

@@ -0,0 +1,17 @@
+const masterMixLoudnessTarget = {
+  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."
+  }
+};
+export {
+  masterMixLoudnessTarget
+};

package/dist/rules/measureAlignmentDontEyeball.js

@@ -0,0 +1,15 @@
+const measureAlignmentDontEyeball = {
+  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."
+  }
+};
+export {
+  measureAlignmentDontEyeball
+};

package/dist/rules/motionCarriesWeightAndMeaning.js

@@ -0,0 +1,15 @@
+const motionCarriesWeightAndMeaning = {
+  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."
+  }
+};
+export {
+  motionCarriesWeightAndMeaning
+};

package/dist/rules/motionDensityFloor.js

@@ -0,0 +1,15 @@
+const motionDensityFloor = {
+  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."
+  }
+};
+export {
+  motionDensityFloor
+};

package/dist/rules/neverEditTierBVendored.js

@@ -0,0 +1,15 @@
+const neverEditTierBVendored = {
+  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" }
+  }
+};
+export {
+  neverEditTierBVendored
+};

package/dist/rules/neverRestateDerivedFrameNumbersInComments.js

@@ -0,0 +1,15 @@
+const neverRestateDerivedFrameNumbersInComments = {
+  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" }
+  }
+};
+export {
+  neverRestateDerivedFrameNumbersInComments
+};

package/dist/rules/noAiGradientLook.js

@@ -0,0 +1,15 @@
+const noAiGradientLook = {
+  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" }
+  }
+};
+export {
+  noAiGradientLook
+};

package/dist/rules/noColoredFlashToHideACut.js

@@ -0,0 +1,22 @@
+const noColoredFlashToHideACut = {
+  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" }
+  }
+};
+export {
+  noColoredFlashToHideACut
+};

package/dist/rules/noDoubleFrameShift.js

@@ -0,0 +1,126 @@
+import { Node, SyntaxKind } from "ts-morph";
+const noDoubleFrameShift = {
+  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) {
+        const windowForNames = /* @__PURE__ */ new Set();
+        const windowsNames = /* @__PURE__ */ new Set();
+        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 [];
+        const windowVars = /* @__PURE__ */ new Set();
+        const unwrap = (node) => {
+          let n = node;
+          while (Node.isParenthesizedExpression(n) || Node.isAsExpression(n) || Node.isNonNullExpression(n) || Node.isSatisfiesExpression(n)) {
+            n = n.getExpression();
+          }
+          return n;
+        };
+        const rootIdentifier = (node) => {
+          let n = unwrap(node);
+          while (Node.isPropertyAccessExpression(n) || Node.isElementAccessExpression(n) || Node.isCallExpression(n)) {
+            n = unwrap(n.getExpression());
+          }
+          return Node.isIdentifier(n) ? n.getText() : void 0;
+        };
+        const isWindowExpr = (node) => {
+          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;
+          }
+          const root = rootIdentifier(n);
+          return root !== void 0 && windowsNames.has(root);
+        };
+        const varDecls = file.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
+        const binaryExprs = file.getDescendantsOfKind(SyntaxKind.BinaryExpression);
+        for (let grew = true; grew; ) {
+          grew = false;
+          const taint = (name) => {
+            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());
+          }
+          for (const bin of binaryExprs) {
+            if (bin.getOperatorToken().getKind() !== SyntaxKind.EqualsToken) continue;
+            if (!isWindowExpr(bin.getRight())) continue;
+            taint(unwrap(bin.getLeft()));
+          }
+        }
+        const findings = [];
+        const report = (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);
+        }
+        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;
+      }
+    }
+  }
+};
+export {
+  noDoubleFrameShift
+};

package/dist/rules/noDuplicateMotionPrimitives.js

@@ -0,0 +1,15 @@
+const noDuplicateMotionPrimitives = {
+  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" }
+  }
+};
+export {
+  noDuplicateMotionPrimitives
+};

package/dist/rules/noLinearMotion.js

@@ -0,0 +1,22 @@
+const noLinearMotion = {
+  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" }
+  }
+};
+export {
+  noLinearMotion
+};

package/dist/rules/noNestedSvgFilters.js

@@ -0,0 +1,93 @@
+import { Node, SyntaxKind } from "ts-morph";
+function hasStyleFilter(element) {
+  const attributes = Node.isJsxOpeningElement(element) || Node.isJsxSelfClosingElement(element) ? element.getAttributes() : [];
+  for (const attribute of attributes) {
+    if (!Node.isJsxAttribute(attribute)) continue;
+    if (attribute.getNameNode().getText() !== "style") continue;
+    const initializer = attribute.getInitializer();
+    if (!initializer || !Node.isJsxExpression(initializer)) continue;
+    const expression = initializer.getExpression();
+    if (!expression) continue;
+    const literals = Node.isObjectLiteralExpression(expression) ? [expression] : expression.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+    for (const literal of literals) {
+      for (const property of literal.getProperties()) {
+        if (Node.isShorthandPropertyAssignment(property) && property.getName() === "filter") return true;
+        if (!Node.isPropertyAssignment(property)) continue;
+        if (property.getName() !== "filter") continue;
+        const value = property.getInitializer()?.getText() ?? "";
+        if (value !== `"none"` && value !== `'none'`) return true;
+      }
+    }
+  }
+  return false;
+}
+const ELEMENT_KINDS = [SyntaxKind.JsxOpeningElement, SyntaxKind.JsxSelfClosingElement];
+const noNestedSvgFilters = {
+  id: "no-nested-svg-filters",
+  claim: "Never nest CSS filters in SVG. Put one flat filter on one layer.",
+  why: "Chrome silently drops the children of a CSS-filtered group when those children also carry CSS filters. Nothing errors and nothing warns: the elements simply do not render, which reads as a logic bug and costs a debugging session to localise.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "gate",
+  verify: "`vitest run packages/video-craft` - machine-checked over scene and kit source",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "source",
+    check: {
+      include: [
+        "qpa-video/03_scenes/**/*.jsx",
+        "reverence-video/src/scenes/**/*.tsx",
+        "workday-dple-video/src/scenes/**/*.tsx",
+        "revola-video/src/scenes/**/*.tsx",
+        "datapeak-video/**/*.{jsx,tsx}",
+        "datapeak-usecases/**/*.{jsx,tsx}",
+        "qse-video/**/*.{jsx,tsx}",
+        "qse-investor-video/**/*.{jsx,tsx}",
+        "qse-qguard-video/src/**/*.tsx",
+        "rcp-fund7-video/src/**/*.tsx",
+        "expanse-video/src/**/*.tsx",
+        "reverence-video/src/**/*.tsx",
+        "spec-videos/**/*.{jsx,tsx}",
+        // Added Task 23: klaviyo-segments-video and radar-fixture-video were
+        // silently excluded - the same gap deterministic-scene-source had.
+        "klaviyo-segments-video/src/**/*.tsx",
+        "radar-fixture-video/src/**/*.tsx",
+        "packages/video-kit/src/**/*.tsx"
+      ],
+      run: (file, relPath) => {
+        const findings = [];
+        for (const kind of ELEMENT_KINDS) {
+          for (const element of file.getDescendantsOfKind(kind)) {
+            if (!hasStyleFilter(element)) continue;
+            const own = Node.isJsxOpeningElement(element) ? element.getParent() : element;
+            let insideSvg = false;
+            let filteredAncestor = false;
+            let ancestor = own.getParent();
+            while (ancestor) {
+              if (Node.isJsxElement(ancestor)) {
+                const opening = ancestor.getOpeningElement();
+                if (opening.getTagNameNode().getText() === "svg") {
+                  insideSvg = true;
+                  break;
+                }
+                if (hasStyleFilter(opening)) filteredAncestor = true;
+              }
+              ancestor = ancestor.getParent();
+            }
+            if (insideSvg && filteredAncestor) {
+              findings.push({
+                file: relPath,
+                line: element.getStartLineNumber(),
+                match: element.getText().replace(/\s+/g, " ").slice(0, 60),
+                message: `nested CSS filter in SVG: this element sets style.filter inside an ancestor that also does. Chrome drops the inner content silently. Flatten to one filter on one layer.`
+              });
+            }
+          }
+        }
+        return findings;
+      }
+    }
+  }
+};
+export {
+  noNestedSvgFilters
+};

package/dist/rules/noRepeatedAssetAcrossShots.js

@@ -0,0 +1,15 @@
+const noRepeatedAssetAcrossShots = {
+  id: "no-repeated-asset-across-shots",
+  claim: "Never show the same asset (a product video, screenshot, or illustration) in two shots of one video; each shot earns its screen time with new material.",
+  why: "A repeated asset reads as filler and was flagged the moment it appeared; the fix was always replacing the repeat with new content, never keeping it.",
+  learnedFrom: "claude-sessions-digest/revola-usecase-book-meeting.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule is a cross-shot content judgment; no single code location expresses it."
+  }
+};
+export {
+  noRepeatedAssetAcrossShots
+};