@revola-ai/video-craft 0.2.1

package/src/fixtures/data-radar-forwarded/plan.fixture.yaml

@@ -0,0 +1,13 @@
+doctrine: 1
+sections:
+  - id: once
+    kind: motion
+    component: Scene
+    vo: "A cookie. And a copy of it."
+    names:
+      - cue: 0
+        element: cookie-chip
+        says: "a cookie"
+      - cue: 1
+        element: cookie-chip-copy
+        says: "a copy of it"

package/src/fixtures/data-radar-opaque/Scene.tsx

@@ -0,0 +1,15 @@
+import React from "react";
+import { AbsoluteFill } from "remotion";
+
+// The case the gate must NOT read as clean: the tag is computed, nothing in
+// the project ever passes it a literal, and no template gives it a stable
+// shape. "hero" might or might not be tagged at runtime - the source cannot
+// say, so the rule reports the SITE rather than either fabricating a finding
+// against "hero" or banking a false clean.
+const ids: Record<string, string> = { a: "hero" };
+
+export const Scene: React.FC<{ which: string }> = ({ which }) => (
+  <AbsoluteFill>
+    <div data-radar={ids[which]} style={{ width: 100, height: 100 }} />
+  </AbsoluteFill>
+);

package/src/fixtures/data-radar-opaque/plan.fixture.yaml

@@ -0,0 +1,10 @@
+doctrine: 1
+sections:
+  - id: once
+    kind: motion
+    component: Scene
+    vo: "One named thing."
+    names:
+      - cue: 0
+        element: hero
+        says: "one named thing"

package/src/fixtures/data-radar-tags/SceneClean.tsx

@@ -0,0 +1,10 @@
+import React from "react";
+import { AbsoluteFill } from "remotion";
+
+// Declares one names: binding ("hero") in the sibling plan.fixture.yaml, and
+// tags it. No missing tags - the clean case.
+export const SceneClean: React.FC = () => (
+  <AbsoluteFill>
+    <div data-radar="hero" style={{ width: 100, height: 100 }} />
+  </AbsoluteFill>
+);

package/src/fixtures/data-radar-tags/SceneNullBinding.tsx

@@ -0,0 +1,12 @@
+import React from "react";
+import { AbsoluteFill } from "remotion";
+
+// The sibling plan.fixture.yaml's "untagged-null" section declares a null
+// binding (element: null, why: given) for its one cue - an honest "this cue
+// names no single subject", not an untagged element. Nothing here should be
+// flagged even though no data-radar attribute exists at all.
+export const SceneNullBinding: React.FC = () => (
+  <AbsoluteFill>
+    <div style={{ width: 100, height: 100 }}>Establishing shot</div>
+  </AbsoluteFill>
+);

package/src/fixtures/data-radar-tags/SceneWithGap.tsx

@@ -0,0 +1,11 @@
+import React from "react";
+import { AbsoluteFill } from "remotion";
+
+// Declares two names: bindings ("hero", "cta") in the sibling plan.fixture.yaml,
+// but only tags "hero" here - "cta" has no matching data-radar attribute.
+export const SceneWithGap: React.FC = () => (
+  <AbsoluteFill>
+    <div data-radar="hero" style={{ width: 100, height: 100 }} />
+    <div style={{ width: 50, height: 20 }}>Call to action</div>
+  </AbsoluteFill>
+);

package/src/fixtures/data-radar-tags/plan.fixture.yaml

@@ -0,0 +1,29 @@
+doctrine: 1
+sections:
+  - id: gap
+    kind: motion
+    component: SceneWithGap
+    vo: "The hero image sits beside a call to action."
+    names:
+      - cue: 0
+        element: hero
+        says: "the hero image"
+      - cue: 1
+        element: cta
+        says: "a call to action"
+  - id: clean
+    kind: motion
+    component: SceneClean
+    vo: "Only the hero is named here."
+    names:
+      - cue: 0
+        element: hero
+        says: "the hero image"
+  - id: untagged-null
+    kind: motion
+    component: SceneNullBinding
+    vo: "This cue names no single subject."
+    names:
+      - cue: 0
+        element: null
+        why: "establishing shot, no single subject"

package/src/fixtures/deterministic-scene.tsx

@@ -0,0 +1,15 @@
+import React from "react";
+
+// Seeded pseudo-random and explicit dates are the sanctioned alternatives.
+const seededRandom = (seed: number) => ((seed * 9301 + 49297) % 233280) / 233280;
+
+export const Stable: React.FC = () => {
+  const jitter = seededRandom(42);
+  const fixed = new Date("2026-01-01T00:00:00Z");
+  const label = "Math.random and Date.now mentioned in a string";
+  return (
+    <div style={{ opacity: jitter }}>
+      {fixed.getFullYear()} {label}
+    </div>
+  );
+};

package/src/fixtures/double-shift/aliased.tsx

@@ -0,0 +1,13 @@
+import React from "react";
+import { useCurrentFrame } from "remotion";
+import { windowFor } from "./layout";
+
+// Mutation: the window is aliased through a second binding before its `from`
+// is read. A regex for `windowFor(...).from` misses this; the rule must not.
+export const Aliased: React.FC = () => {
+  const frame = useCurrentFrame();
+  const win = windowFor("mechanism");
+  const w = win;
+  const lf = frame - w.from;
+  return <div style={{ opacity: lf > 0 ? 1 : 0 }} />;
+};

package/src/fixtures/double-shift/assigned.tsx

@@ -0,0 +1,13 @@
+import React from "react";
+import { useCurrentFrame } from "remotion";
+import { windowFor } from "./layout";
+
+// Mutation: the window arrives through a plain ASSIGNMENT (`w = windowFor(...)`),
+// not a VariableDeclaration initializer - initializer-only taint misses it.
+export const Assigned: React.FC = () => {
+  const frame = useCurrentFrame();
+  let w;
+  w = windowFor("mechanism");
+  const lf = frame - w.from;
+  return <div style={{ opacity: lf > 0 ? 1 : 0 }} />;
+};

package/src/fixtures/double-shift/clean.tsx

@@ -0,0 +1,19 @@
+import React from "react";
+import { interpolate, useCurrentFrame } from "remotion";
+import { cue, cueEnd, windowFor } from "./layout";
+
+// The sanctioned shapes, none of which may fire:
+// - cue()/cueEnd() as the in-scene clock;
+// - a window's durationInFrames (its length is Sequence-local by definition);
+// - `.from` on objects that are NOT section windows (a token, Array.from).
+const XFORM = { vignette: { from: 0.4, mid: 0.2 } } as const;
+
+export const Clean: React.FC = () => {
+  const frame = useCurrentFrame();
+  const W = windowFor("mechanism");
+  const enter = interpolate(frame, [cue("mechanism", 0), cueEnd("mechanism", 0)], [0, 1]);
+  const exit = interpolate(frame, [W.durationInFrames - 14, W.durationInFrames - 1], [1, 0]);
+  const vignette = interpolate(enter, [0, 1], [XFORM.vignette.from, XFORM.vignette.mid]);
+  const dots = Array.from({ length: 4 }).map((_, i) => i);
+  return <div style={{ opacity: enter * exit * vignette }}>{dots.length}</div>;
+};

package/src/fixtures/double-shift/destructured.tsx

@@ -0,0 +1,12 @@
+import React from "react";
+import { useCurrentFrame } from "remotion";
+import { windowFor } from "./layout";
+
+// Mutation: `from` is destructured (and renamed) out of the window, so no
+// `.from` property access ever appears in the source text.
+export const Destructured: React.FC = () => {
+  const frame = useCurrentFrame();
+  const { from: sectionStart } = windowFor("mechanism");
+  const lf = frame - sectionStart;
+  return <div style={{ opacity: lf > 0 ? 1 : 0 }} />;
+};

package/src/fixtures/double-shift/elementAccess.tsx

@@ -0,0 +1,12 @@
+import React from "react";
+import { useCurrentFrame } from "remotion";
+import { windowFor } from "./layout";
+
+// Mutation: the `from` read is an element access - `win["from"]` - so a
+// property-access-only walk misses it entirely.
+export const ElementAccess: React.FC = () => {
+  const frame = useCurrentFrame();
+  const win = windowFor("mechanism");
+  const lf = frame - win["from"];
+  return <div style={{ opacity: lf > 0 ? 1 : 0 }} />;
+};

package/src/fixtures/double-shift/layout.ts

@@ -0,0 +1,24 @@
+// Minimal stand-in for a project layout module (the rcp-fund7-video/src/
+// layout.ts pattern), so the double-shift fixtures typecheck and carry the
+// exact import shape the rule keys on: a module whose specifier basename is
+// "layout" exporting windowFor / SECTION_WINDOWS / cue / cueEnd.
+
+export type SectionWindow = {
+  id: string;
+  from: number;
+  durationInFrames: number;
+};
+
+export const SECTION_WINDOWS: SectionWindow[] = [
+  { id: "waste", from: 0, durationInFrames: 300 },
+  { id: "mechanism", from: 300, durationInFrames: 264 },
+];
+
+export const windowFor = (id: string): SectionWindow => {
+  const w = SECTION_WINDOWS.find((s) => s.id === id);
+  if (!w) throw new Error(`fixture layout: no window for "${id}"`);
+  return w;
+};
+
+export const cue = (_id: string, _index: number): number => 12;
+export const cueEnd = (_id: string, _index: number): number => 24;