@revola-ai/video-craft 0.2.1

package/src/registry.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test } from "vitest";
+import { RULES, validateRegistry } from "./registry";
+import type { Rule } from "./types";
+
+const base: Rule = {
+  id: "a-rule",
+  claim: "Do the thing.",
+  why: "Otherwise the other thing breaks.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: { kind: "prose", unanchorable: "process guidance, no code to point at" },
+};
+
+describe("validateRegistry", () => {
+  test("accepts a well-formed registry", () => {
+    expect(validateRegistry([base])).toEqual([]);
+  });
+
+  test("rejects duplicate ids", () => {
+    const errors = validateRegistry([base, { ...base, claim: "Different." }]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatch(/duplicate rule id "a-rule"/);
+  });
+
+  test("rejects a non-kebab-case id", () => {
+    const errors = validateRegistry([{ ...base, id: "aRule" }]);
+    expect(errors[0]).toMatch(/id "aRule" is not kebab-case/);
+  });
+
+  test("rejects an empty learnedFrom", () => {
+    const errors = validateRegistry([{ ...base, learnedFrom: "" }]);
+    expect(errors[0]).toMatch(/rule "a-rule" has no learnedFrom/);
+  });
+
+  test("rejects two whenToUse rules for one component", () => {
+    const scope = { kind: "component", slug: "rolling-number", field: "whenToUse" } as const;
+    const errors = validateRegistry([
+      { ...base, id: "one", scope },
+      { ...base, id: "two", scope },
+    ]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatch(/component "rolling-number" has 2 whenToUse rules, expected at most 1/);
+  });
+
+  test("allows many gotcha rules for one component", () => {
+    const scope = { kind: "component", slug: "rolling-number", field: "gotcha" } as const;
+    expect(validateRegistry([
+      { ...base, id: "one", scope },
+      { ...base, id: "two", scope },
+    ])).toEqual([]);
+  });
+
+  test("rejects an empty claim", () => {
+    const errors = validateRegistry([{ ...base, claim: "  " }]);
+    expect(errors[0]).toMatch(/rule "a-rule" has an empty claim/);
+  });
+
+  test("rejects an empty why", () => {
+    const errors = validateRegistry([{ ...base, why: "" }]);
+    expect(errors[0]).toMatch(/rule "a-rule" has an empty why/);
+  });
+
+  test("rejects an empty unanchorable reason", () => {
+    const errors = validateRegistry([
+      { ...base, enforcement: { kind: "prose", unanchorable: " " } },
+    ]);
+    expect(errors[0]).toMatch(/rule "a-rule" has an empty unanchorable reason/);
+  });
+
+  test("rejects an anchor path that is not repo-relative POSIX", () => {
+    const errors = validateRegistry([
+      { ...base, enforcement: { kind: "prose", anchor: { file: "/abs/path.tsx" } } },
+      { ...base, id: "b-rule", enforcement: { kind: "prose", anchor: { file: "a\\b.tsx" } } },
+    ]);
+    expect(errors).toHaveLength(2);
+    expect(errors[0]).toMatch(/anchor file "\/abs\/path.tsx" is not a repo-relative POSIX path/);
+  });
+
+  test("rejects a source rule with no include globs", () => {
+    const errors = validateRegistry([
+      { ...base, enforcement: { kind: "source", check: { include: [], run: () => [] } } },
+    ]);
+    expect(errors[0]).toMatch(/rule "a-rule" has no include globs/);
+  });
+
+  test("rejects a non-kebab-case component slug", () => {
+    const errors = validateRegistry([
+      { ...base, scope: { kind: "component", slug: "RollingNumber", field: "gotcha" } },
+    ]);
+    expect(errors[0]).toMatch(/component slug "RollingNumber" is not kebab-case/);
+  });
+
+  test("rejects a prose rule carrying both an anchor and an unanchorable reason", () => {
+    const both = {
+      kind: "prose",
+      anchor: { file: "HOW_I_BUILD_VIDEOS.md" },
+      unanchorable: "also this",
+    } as Rule["enforcement"];
+    const errors = validateRegistry([{ ...base, enforcement: both }]);
+    expect(errors[0]).toMatch(/rule "a-rule" carries both an anchor and an unanchorable reason/);
+  });
+});
+
+describe("the real registry", () => {
+  test("is valid", () => {
+    expect(validateRegistry(RULES)).toEqual([]);
+  });
+
+  test("rolling-number carries usage guidance, not just gotchas", () => {
+    // WS1 builds its manifest from the generated sidecar; empty
+    // whenToUse/whenNotToUse would ship a component with no usage guidance.
+    const fields = RULES
+      .filter((r) => r.scope.kind === "component" && r.scope.slug === "rolling-number")
+      .map((r) => (r.scope as { field: string }).field);
+    expect(fields).toContain("whenToUse");
+    expect(fields).toContain("whenNotToUse");
+  });
+});
+
+// A gate is a claim that a violation blocks the ship. If nothing can discharge
+// it, it is a wish. `hero-fills-the-frame` states "a hero occupying a third of
+// the screen is a defect" and was violated by a hero occupying a third of the
+// screen, for five rounds, because no artifact ever tested it.
+describe("tier and verify", () => {
+  test("accepts a gate that says how it is settled", () => {
+    expect(validateRegistry([{ ...base, tier: "gate", verify: "video render-twice --comp x" }])).toEqual([]);
+  });
+
+  test("rejects a gate with no verify", () => {
+    const errors = validateRegistry([{ ...base, tier: "gate" }]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatch(/rule "a-rule" is a gate with no verify/);
+  });
+
+  test("rejects a gate whose verify is blank", () => {
+    expect(validateRegistry([{ ...base, tier: "gate", verify: "   " }])[0])
+      .toMatch(/rule "a-rule" is a gate with no verify/);
+  });
+
+  test("rejects an unknown tier", () => {
+    expect(validateRegistry([{ ...base, tier: "urgent" as unknown as Rule["tier"] }])[0])
+      .toMatch(/rule "a-rule" has an unknown tier "urgent"/);
+  });
+
+  test("lets a craft rule carry a verify without demanding one", () => {
+    expect(validateRegistry([{ ...base, verify: "video stills --at all" }])).toEqual([]);
+    expect(validateRegistry([base])).toEqual([]);
+  });
+
+  test("every shipped rule declares a tier", () => {
+    expect(RULES.filter((r) => !r.tier).map((r) => r.id)).toEqual([]);
+  });
+});
+
+// Task 23: every rule the radar discharges names its owner - a radar check id
+// (crossing the package boundary via the generated radar-check-ids.json, since
+// craft cannot import video-cli) or the literal "coherence" for a rule the
+// live coherence agent discharges instead of an automated check.
+describe("owner", () => {
+  test("accepts an owner that is a known radar check id", () => {
+    expect(validateRegistry([{ ...base, owner: "hero-size" }], ["hero-size", "static-hold"])).toEqual([]);
+  });
+
+  test("accepts the literal coherence owner without consulting the check-id list", () => {
+    expect(validateRegistry([{ ...base, owner: "coherence" }], [])).toEqual([]);
+  });
+
+  test("rejects an owner id that is not in the committed check-id list", () => {
+    const errors = validateRegistry([{ ...base, owner: "not-a-real-check" }], ["hero-size"]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatch(/rule "a-rule" owner "not-a-real-check" is not a known radar check id or "coherence"/);
+  });
+
+  test("rejects an owner naming more than one check (a compound value is not a single owner)", () => {
+    const errors = validateRegistry([{ ...base, owner: "hero-size,static-hold" }], ["hero-size", "static-hold"]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toMatch(/owner "hero-size,static-hold" is not a known radar check id or "coherence"/);
+  });
+
+  test("allows two different rules to share one check as their owner", () => {
+    // brief-structure discharges several distinct claims from one run
+    // (missing thesis, missing audience, unarchived source) - one check
+    // legitimately owns more than one craft rule's obligation.
+    expect(validateRegistry(
+      [
+        { ...base, id: "one", owner: "brief-structure" },
+        { ...base, id: "two", owner: "brief-structure" },
+      ],
+      ["brief-structure"],
+    )).toEqual([]);
+  });
+
+  test("allows many rules to share the coherence owner", () => {
+    expect(validateRegistry(
+      [
+        { ...base, id: "one", owner: "coherence" },
+        { ...base, id: "two", owner: "coherence" },
+      ],
+      [],
+    )).toEqual([]);
+  });
+
+  test("a rule with no owner is unaffected", () => {
+    expect(validateRegistry([base], [])).toEqual([]);
+  });
+});

package/src/registry.ts

@@ -0,0 +1,352 @@
+import { animatedBarChartTightBox } from "./rules/animatedBarChartTightBox";
+import { animatedBarChartWhenNotToUse } from "./rules/animatedBarChartWhenNotToUse";
+import { animatedBarChartWhenToUse } from "./rules/animatedBarChartWhenToUse";
+import { animatedLineChartWhenNotToUse } from "./rules/animatedLineChartWhenNotToUse";
+import { animatedLineChartWhenToUse } from "./rules/animatedLineChartWhenToUse";
+import { approvedSfxPaletteOnly } from "./rules/approvedSfxPaletteOnly";
+import { atmosphereGradientsFadeAtBothEnds } from "./rules/atmosphereGradientsFadeAtBothEnds";
+import { audioIsTheClock } from "./rules/audioIsTheClock";
+import { beatsDeriveFromTheirOwnSequence } from "./rules/beatsDeriveFromTheirOwnSequence";
+import { bestSceneSetsTheBar } from "./rules/bestSceneSetsTheBar";
+import { bumpBeforeRefreeze } from "./rules/bumpBeforeRefreeze";
+import { cameraIsTheNarrator } from "./rules/cameraIsTheNarrator";
+import { checkPinBeforeShip } from "./rules/checkPinBeforeShip";
+import { coldViewerClarity } from "./rules/coldViewerClarity";
+import { commitOrCutEffects } from "./rules/commitOrCutEffects";
+import { convertFramesAcrossClockBoundary } from "./rules/convertFramesAcrossClockBoundary";
+import { crossCutElementsLiveInTheHudLayer } from "./rules/crossCutElementsLiveInTheHudLayer";
+import { cursorClicksRealControls } from "./rules/cursorClicksRealControls";
+import { cutOnRealAudioPauses } from "./rules/cutOnRealAudioPauses";
+import { darkButNeverDim } from "./rules/darkButNeverDim";
+import { dataRadarTagsDeclared } from "./rules/dataRadarTagsDeclared";
+import { declareAVerticalZoneMap } from "./rules/declareAVerticalZoneMap";
+import { deleteRejectedRigsCompletely } from "./rules/deleteRejectedRigsCompletely";
+import { deriveSeamsDontMeasure } from "./rules/deriveSeamsDontMeasure";
+import { deterministicSceneSource } from "./rules/deterministicSceneSource";
+import { diegeticSoundForOnscreenActions } from "./rules/diegeticSoundForOnscreenActions";
+import { distinctTransitionPerBeat } from "./rules/distinctTransitionPerBeat";
+import { downloadOrDrawRichAssets } from "./rules/downloadOrDrawRichAssets";
+import { elementOnscreenForItsVoSentence } from "./rules/elementOnscreenForItsVoSentence";
+import { emitBuildNotes } from "./rules/emitBuildNotes";
+import { energyFromTimingNotPartCount } from "./rules/energyFromTimingNotPartCount";
+import { evidenceBeforeClaimingFixed } from "./rules/evidenceBeforeClaimingFixed";
+import { exactPeerLockstep } from "./rules/exactPeerLockstep";
+import { firstPassIsADraft } from "./rules/firstPassIsADraft";
+import { fixCrowdingByRebandingNotNudging } from "./rules/fixCrowdingByRebandingNotNudging";
+import { fixesPreserveApprovedElements } from "./rules/fixesPreserveApprovedElements";
+import { floatingNotBoxed } from "./rules/floatingNotBoxed";
+import { focusBeatsRecedeTheContext } from "./rules/focusBeatsRecedeTheContext";
+import { fontVarsBrandRemocn } from "./rules/fontVarsBrandRemocn";
+import { geometricSeamsNotCrossfades } from "./rules/geometricSeamsNotCrossfades";
+import { geometrySidecarExportsTyped } from "./rules/geometrySidecarExportsTyped";
+import { glowIsAFocalAccent } from "./rules/glowIsAFocalAccent";
+import { heroFillsTheFrame } from "./rules/heroFillsTheFrame";
+import { htmlMasksForAnimatedCounters } from "./rules/htmlMasksForAnimatedCounters";
+import { impactStackOnPayoffs } from "./rules/impactStackOnPayoffs";
+import { interactiveTargetsAreDeclaredData } from "./rules/interactiveTargetsAreDeclaredData";
+import { interpolateLiteralKeysMonotonic } from "./rules/interpolateLiteralKeysMonotonic";
+import { latenessIsStructuralOverlapTheBeats } from "./rules/latenessIsStructuralOverlapTheBeats";
+import { lessTextMoreVisualizations } from "./rules/lessTextMoreVisualizations";
+import { liveLinkDuplicateReactAlias } from "./rules/liveLinkDuplicateReactAlias";
+import { make2dElements3d } from "./rules/make2dElements3d";
+import { masterMixLoudnessTarget } from "./rules/masterMixLoudnessTarget";
+import { measureAlignmentDontEyeball } from "./rules/measureAlignmentDontEyeball";
+import { motionCarriesWeightAndMeaning } from "./rules/motionCarriesWeightAndMeaning";
+import { motionDensityFloor } from "./rules/motionDensityFloor";
+import { neverEditTierBVendored } from "./rules/neverEditTierBVendored";
+import { neverRestateDerivedFrameNumbersInComments } from "./rules/neverRestateDerivedFrameNumbersInComments";
+import { noAiGradientLook } from "./rules/noAiGradientLook";
+import { noColoredFlashToHideACut } from "./rules/noColoredFlashToHideACut";
+import { noDoubleFrameShift } from "./rules/noDoubleFrameShift";
+import { noDuplicateMotionPrimitives } from "./rules/noDuplicateMotionPrimitives";
+import { noLinearMotion } from "./rules/noLinearMotion";
+import { noNestedSvgFilters } from "./rules/noNestedSvgFilters";
+import { noRepeatedAssetAcrossShots } from "./rules/noRepeatedAssetAcrossShots";
+import { noShorthandWithUndefinedLonghand } from "./rules/noShorthandWithUndefinedLonghand";
+import { noStackedFadesAtACut } from "./rules/noStackedFadesAtACut";
+import { noStaticHolds } from "./rules/noStaticHolds";
+import { occlusionVisibleElements } from "./rules/occlusionVisibleElements";
+import { oneContinuousVoTrack } from "./rules/oneContinuousVoTrack";
+import { onePunchPerMomentClass } from "./rules/onePunchPerMomentClass";
+import { oneRenderPerRound } from "./rules/oneRenderPerRound";
+import { openingsAndClosingsCarryMore } from "./rules/openingsAndClosingsCarryMore";
+import { openStaticAfterAHardCut } from "./rules/openStaticAfterAHardCut";
+import { persistentDeviceFrames } from "./rules/persistentDeviceFrames";
+import { pixelDiffAnEmptyBandFirst } from "./rules/pixelDiffAnEmptyBandFirst";
+import { planIsPublishedNotGating } from "./rules/planIsPublishedNotGating";
+import { poweredByRevolaWatermark } from "./rules/poweredByRevolaWatermark";
+import { predrawContentPresentAtTheCut } from "./rules/predrawContentPresentAtTheCut";
+import { premiumSurfacesNotFlatBorders } from "./rules/premiumSurfacesNotFlatBorders";
+import { radarDispositionsAreHumanOnly } from "./rules/radarDispositionsAreHumanOnly";
+import { realAssetsNotPlaceholders } from "./rules/realAssetsNotPlaceholders";
+import { rebuildUiFromReconNotScreenshots } from "./rules/rebuildUiFromReconNotScreenshots";
+import { reconStrandsRunInParallel } from "./rules/reconStrandsRunInParallel";
+import { registryBeforeHandrolling } from "./rules/registryBeforeHandrolling";
+import { remapRateEndpointFormula } from "./rules/remapRateEndpointFormula";
+import { remocnContentTailwindChrome } from "./rules/remocnContentTailwindChrome";
+import { retimeOnlyViaPlaybackOrDesignTokens } from "./rules/retimeOnlyViaPlaybackOrDesignTokens";
+import { reviewTheRenderByFrameSweep } from "./rules/reviewTheRenderByFrameSweep";
+import { rollingNumberBoundedSequence } from "./rules/rollingNumberBoundedSequence";
+import { rollingNumberSequenceLayoutNone } from "./rules/rollingNumberSequenceLayoutNone";
+import { rollingNumberTightBoxAlignment } from "./rules/rollingNumberTightBoxAlignment";
+import { rollingNumberWhenNotToUse } from "./rules/rollingNumberWhenNotToUse";
+import { rollingNumberWhenToUse } from "./rules/rollingNumberWhenToUse";
+import { sameFamilySameProject } from "./rules/sameFamilySameProject";
+import { sampleBrandFromProduct } from "./rules/sampleBrandFromProduct";
+import { sampleVelocityFromPreviousFramePosition } from "./rules/sampleVelocityFromPreviousFramePosition";
+import { sceneRootTagDeclared } from "./rules/sceneRootTagDeclared";
+import { scrubDemoDataToGenericRoles } from "./rules/scrubDemoDataToGenericRoles";
+import { selfReviewThePlanForGaps } from "./rules/selfReviewThePlanForGaps";
+import { sourceArchivedBeforeBrief } from "./rules/sourceArchivedBeforeBrief";
+import { statisticsSelfExplanatory } from "./rules/statisticsSelfExplanatory";
+import { stopsAsRelativeSpacing } from "./rules/stopsAsRelativeSpacing";
+import { themePerSection } from "./rules/themePerSection";
+import { thesisDeclaredInBrief } from "./rules/thesisDeclaredInBrief";
+import { theWholeCanvasWorks } from "./rules/theWholeCanvasWorks";
+import { tierARequiresPropUnreachableEdit } from "./rules/tierARequiresPropUnreachableEdit";
+import { tinyBodyCopyAsRuledLines } from "./rules/tinyBodyCopyAsRuledLines";
+import { titlesPinnedOutsideCameraPush } from "./rules/titlesPinnedOutsideCameraPush";
+import { tokensNotRawHexes } from "./rules/tokensNotRawHexes";
+import { typeTokenDefaultedParamsAsString } from "./rules/typeTokenDefaultedParamsAsString";
+import { varyKitChoreographyAcrossSections } from "./rules/varyKitChoreographyAcrossSections";
+import { varyTheVisualizationGrammar } from "./rules/varyTheVisualizationGrammar";
+import { verifyCheapRenderDear } from "./rules/verifyCheapRenderDear";
+import { voAddressesTheViewer } from "./rules/voAddressesTheViewer";
+import { voIsAPerformance } from "./rules/voIsAPerformance";
+import { voScriptLocksSpokenWords } from "./rules/voScriptLocksSpokenWords";
+import { wrappersPreserveChildGeometry } from "./rules/wrappersPreserveChildGeometry";
+import type { Rule } from "./types";
+// The check-id list crossing the video-cli/video-craft package boundary
+// (Task 23): generated by `packages/video-cli/scripts/generate-radar-docs.ts`
+// from CHECKS, drift-tested there, and read here as a plain JSON import - a
+// static data import, not a runtime dependency on video-cli. Craft must never
+// import video-cli (ts-morph has no place in the CLI, and the reverse
+// boundary - waiverProjection.ts's waivers.generated.json - already runs the
+// same mechanism the other direction).
+// The `with { type: "json" }` attribute is load-bearing for the installed
+// world: the dist transpile keeps this import as-is, and plain node refuses a
+// JSON module without the attribute (tsx and vitest tolerate both forms).
+import RADAR_CHECK_IDS from "./radar-check-ids.json" with { type: "json" };
+
+/**
+ * Every durable craft rule. Rules are added by mining build notes, never by
+ * inventing them: a rule with no `learnedFrom` is an opinion, not knowledge.
+ */
+export const RULES: Rule[] = [
+  animatedBarChartTightBox,
+  animatedBarChartWhenNotToUse,
+  animatedBarChartWhenToUse,
+  animatedLineChartWhenNotToUse,
+  animatedLineChartWhenToUse,
+  approvedSfxPaletteOnly,
+  atmosphereGradientsFadeAtBothEnds,
+  audioIsTheClock,
+  bestSceneSetsTheBar,
+  bumpBeforeRefreeze,
+  cameraIsTheNarrator,
+  checkPinBeforeShip,
+  coldViewerClarity,
+  commitOrCutEffects,
+  convertFramesAcrossClockBoundary,
+  crossCutElementsLiveInTheHudLayer,
+  cursorClicksRealControls,
+  cutOnRealAudioPauses,
+  darkButNeverDim,
+  dataRadarTagsDeclared,
+  declareAVerticalZoneMap,
+  deleteRejectedRigsCompletely,
+  deriveSeamsDontMeasure,
+  deterministicSceneSource,
+  diegeticSoundForOnscreenActions,
+  distinctTransitionPerBeat,
+  downloadOrDrawRichAssets,
+  elementOnscreenForItsVoSentence,
+  emitBuildNotes,
+  energyFromTimingNotPartCount,
+  evidenceBeforeClaimingFixed,
+  exactPeerLockstep,
+  firstPassIsADraft,
+  fixCrowdingByRebandingNotNudging,
+  fixesPreserveApprovedElements,
+  floatingNotBoxed,
+  fontVarsBrandRemocn,
+  glowIsAFocalAccent,
+  heroFillsTheFrame,
+  htmlMasksForAnimatedCounters,
+  interpolateLiteralKeysMonotonic,
+  latenessIsStructuralOverlapTheBeats,
+  lessTextMoreVisualizations,
+  liveLinkDuplicateReactAlias,
+  make2dElements3d,
+  masterMixLoudnessTarget,
+  motionCarriesWeightAndMeaning,
+  neverEditTierBVendored,
+  neverRestateDerivedFrameNumbersInComments,
+  noAiGradientLook,
+  noColoredFlashToHideACut,
+  noDoubleFrameShift,
+  noDuplicateMotionPrimitives,
+  noLinearMotion,
+  noNestedSvgFilters,
+  noRepeatedAssetAcrossShots,
+  noStackedFadesAtACut,
+  noStaticHolds,
+  occlusionVisibleElements,
+  oneContinuousVoTrack,
+  onePunchPerMomentClass,
+  oneRenderPerRound,
+  openingsAndClosingsCarryMore,
+  openStaticAfterAHardCut,
+  persistentDeviceFrames,
+  pixelDiffAnEmptyBandFirst,
+  planIsPublishedNotGating,
+  poweredByRevolaWatermark,
+  predrawContentPresentAtTheCut,
+  radarDispositionsAreHumanOnly,
+  realAssetsNotPlaceholders,
+  rebuildUiFromReconNotScreenshots,
+  reconStrandsRunInParallel,
+  registryBeforeHandrolling,
+  remapRateEndpointFormula,
+  remocnContentTailwindChrome,
+  retimeOnlyViaPlaybackOrDesignTokens,
+  rollingNumberBoundedSequence,
+  rollingNumberSequenceLayoutNone,
+  rollingNumberTightBoxAlignment,
+  rollingNumberWhenNotToUse,
+  rollingNumberWhenToUse,
+  sameFamilySameProject,
+  sampleBrandFromProduct,
+  sampleVelocityFromPreviousFramePosition,
+  sceneRootTagDeclared,
+  scrubDemoDataToGenericRoles,
+  selfReviewThePlanForGaps,
+  sourceArchivedBeforeBrief,
+  statisticsSelfExplanatory,
+  stopsAsRelativeSpacing,
+  themePerSection,
+  thesisDeclaredInBrief,
+  theWholeCanvasWorks,
+  tierARequiresPropUnreachableEdit,
+  tinyBodyCopyAsRuledLines,
+  titlesPinnedOutsideCameraPush,
+  tokensNotRawHexes,
+  typeTokenDefaultedParamsAsString,
+  varyKitChoreographyAcrossSections,
+  varyTheVisualizationGrammar,
+  verifyCheapRenderDear,
+  voAddressesTheViewer,
+  voIsAPerformance,
+  voScriptLocksSpokenWords,
+  beatsDeriveFromTheirOwnSequence,
+  focusBeatsRecedeTheContext,
+  geometricSeamsNotCrossfades,
+  geometrySidecarExportsTyped,
+  impactStackOnPayoffs,
+  interactiveTargetsAreDeclaredData,
+  measureAlignmentDontEyeball,
+  motionDensityFloor,
+  noShorthandWithUndefinedLonghand,
+  premiumSurfacesNotFlatBorders,
+  reviewTheRenderByFrameSweep,
+  wrappersPreserveChildGeometry,
+];
+
+const TIERS = new Set<Rule["tier"]>(["gate", "craft", "process"]);
+const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+
+/** The literal owner value for a rule the live coherence agent discharges by
+ *  judgement, rather than an automated radar check (e.g.
+ *  `motion-density-floor`). Exempt from both the known-check-id check (it is
+ *  never a check id) and the one-rule-per-owner uniqueness check (many rules
+ *  can legitimately be "discharged by coherence review"). */
+const COHERENCE_OWNER = "coherence";
+
+export function validateRegistry(rules: Rule[], checkIds: string[] = RADAR_CHECK_IDS): string[] {
+  const errors: string[] = [];
+
+  const seen = new Set<string>();
+  for (const rule of rules) {
+    if (seen.has(rule.id)) errors.push(`duplicate rule id "${rule.id}"`);
+    seen.add(rule.id);
+
+    if (!KEBAB.test(rule.id)) errors.push(`id "${rule.id}" is not kebab-case`);
+    if (!rule.learnedFrom) errors.push(`rule "${rule.id}" has no learnedFrom`);
+    if (!rule.claim.trim()) errors.push(`rule "${rule.id}" has an empty claim`);
+    if (!rule.why.trim()) errors.push(`rule "${rule.id}" has an empty why`);
+
+    if (!TIERS.has(rule.tier)) {
+      errors.push(`rule "${rule.id}" has an unknown tier "${rule.tier}"`);
+    }
+    // A gate asserts that a violation blocks the ship, so something has to be
+    // able to discharge it. A manual procedure counts; nothing at all does not,
+    // because an unverifiable gate is indistinguishable from a strongly worded
+    // craft rule and gets treated as one.
+    if (rule.tier === "gate" && !rule.verify?.trim()) {
+      errors.push(`rule "${rule.id}" is a gate with no verify`);
+    }
+
+    if (rule.scope.kind === "component" && !KEBAB.test(rule.scope.slug)) {
+      errors.push(`component slug "${rule.scope.slug}" is not kebab-case`);
+    }
+
+    for (const ex of rule.exceptions ?? []) {
+      // An exception with a blank field is a waiver nobody can audit: the
+      // project tells you where it applies, the decision tells you what was
+      // chosen, and recordedIn tells you where to read the round that chose it.
+      if (!ex.project.trim() || !ex.decision.trim() || !ex.recordedIn.trim()) {
+        errors.push(`rule "${rule.id}" has an exception with an empty field`);
+      }
+      if (ex.recordedIn.startsWith("/") || ex.recordedIn.includes("\\")) {
+        errors.push(
+          `rule "${rule.id}": exception recordedIn "${ex.recordedIn}" is not a repo-relative POSIX path`,
+        );
+      }
+    }
+
+    const e = rule.enforcement;
+    if (e.kind === "prose" && "anchor" in e && "unanchorable" in e) {
+      // The two prose variants share a discriminant, so a composed object can
+      // carry both; that is ambiguous authorship, not a valid state.
+      errors.push(`rule "${rule.id}" carries both an anchor and an unanchorable reason`);
+    }
+    if (e.kind === "prose" && "unanchorable" in e && !(e as { unanchorable: string }).unanchorable.trim()) {
+      errors.push(`rule "${rule.id}" has an empty unanchorable reason`);
+    }
+    if (e.kind === "prose" && "anchor" in e) {
+      const { file } = e.anchor;
+      if (file.startsWith("/") || file.includes("\\")) {
+        errors.push(`rule "${rule.id}": anchor file "${file}" is not a repo-relative POSIX path`);
+      }
+    }
+    if (e.kind === "source" && e.check.include.length === 0) {
+      errors.push(`rule "${rule.id}" has no include globs`);
+    }
+
+    // One radar check can legitimately discharge more than one craft rule's
+    // obligation (brief-structure alone produces distinct missing-thesis,
+    // missing-audience, and unarchived-source claims), so ownership is
+    // validated one rule at a time - not tracked for cross-rule uniqueness.
+    if (rule.owner !== undefined && rule.owner !== COHERENCE_OWNER && !checkIds.includes(rule.owner)) {
+      errors.push(`rule "${rule.id}" owner "${rule.owner}" is not a known radar check id or "${COHERENCE_OWNER}"`);
+    }
+  }
+
+  // whenToUse and whenNotToUse are single strings in WS1's ComponentMeta, so a
+  // component can have at most one of each. This is a forcing function toward
+  // one crisp sentence rather than a paragraph that grows without review.
+  for (const field of ["whenToUse", "whenNotToUse"] as const) {
+    const counts = new Map<string, number>();
+    for (const rule of rules) {
+      if (rule.scope.kind !== "component" || rule.scope.field !== field) continue;
+      counts.set(rule.scope.slug, (counts.get(rule.scope.slug) ?? 0) + 1);
+    }
+    for (const [slug, count] of counts) {
+      if (count > 1) {
+        errors.push(`component "${slug}" has ${count} ${field} rules, expected at most 1`);
+      }
+    }
+  }
+
+  return errors;
+}

package/src/rules/animatedBarChartTightBox.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "../types";
+
+export const animatedBarChartTightBox: Rule = {
+  id: "animated-bar-chart-tight-box",
+  claim: "AnimatedBarChart fills its nearest positioned ancestor; give it a position: relative box sized to the intended width and height, and pass matching width/height props.",
+  why: "The component renders position: absolute inset 0 and centers its fixed-size SVG; in an unsized or oversized box the chart floats to the container's middle instead of sitting where the card design intends.",
+  learnedFrom: "revola-video/src/scenes/V2Beat4DashboardRemocn.tsx",
+  tier: "craft",
+  scope: { kind: "component", slug: "animated-bar-chart", field: "gotcha" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/animated-bar-chart.tsx" },
+  },
+};

package/src/rules/animatedBarChartWhenNotToUse.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "../types";
+
+export const animatedBarChartWhenNotToUse: Rule = {
+  id: "animated-bar-chart-when-not-to-use",
+  claim: "Do not use AnimatedBarChart for time-series trends (use the line chart), for a single headline number (use RollingNumber), or when bars must interleave with bespoke chrome inside the plot area.",
+  why: "A categorical bar race telling a trend story reads wrong, and the component owns its whole SVG plot area, so bespoke overlays inside it fight the layout.",
+  learnedFrom: "docs/superpowers/specs/2026-07-23-ws2-wave1-tier-a-seed-design.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "animated-bar-chart", field: "whenNotToUse" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/animated-bar-chart.tsx" },
+  },
+};

package/src/rules/animatedBarChartWhenToUse.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "../types";
+
+export const animatedBarChartWhenToUse: Rule = {
+  id: "animated-bar-chart-when-to-use",
+  claim: "Use AnimatedBarChart for a single categorical comparison beat (attention, volume, ranking) where staggered bar growth IS the story.",
+  why: "It is the kit's owned bar chart: themed gradient bars, staggered spring growth, category and value labels; hand-rolling one repeats the pre-registry _lib sprawl.",
+  learnedFrom: "docs/superpowers/specs/2026-07-23-ws2-wave1-tier-a-seed-design.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "animated-bar-chart", field: "whenToUse" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/animated-bar-chart.tsx" },
+  },
+};

package/src/rules/animatedLineChartWhenNotToUse.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "../types";
+
+export const animatedLineChartWhenNotToUse: Rule = {
+  id: "animated-line-chart-when-not-to-use",
+  claim: "Do not use AnimatedLineChart for categorical comparisons (use AnimatedBarChart) or a single headline number (use RollingNumber).",
+  why: "A trend-line draw-on telling a categorical comparison story reads wrong, and a single headline number does not need a plotted series at all.",
+  learnedFrom: "docs/superpowers/specs/2026-07-23-ws2-wave1-tier-a-seed-design.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "animated-line-chart", field: "whenNotToUse" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/animated-line-chart.tsx" },
+  },
+};

package/src/rules/animatedLineChartWhenToUse.ts

@@ -0,0 +1,14 @@
+import type { Rule } from "../types";
+
+export const animatedLineChartWhenToUse: Rule = {
+  id: "animated-line-chart-when-to-use",
+  claim: "Use AnimatedLineChart for a continuous trend over time (growth, decline, rate) where the draw-on reveal IS the story.",
+  why: "It is the kit's owned line chart: themed gradient stroke, spring-driven draw-on with a leading dot; hand-rolling one repeats the pre-registry _lib sprawl.",
+  learnedFrom: "docs/superpowers/specs/2026-07-23-ws2-wave1-tier-a-seed-design.md",
+  tier: "craft",
+  scope: { kind: "component", slug: "animated-line-chart", field: "whenToUse" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/motion/animated-line-chart.tsx" },
+  },
+};

package/src/rules/approvedSfxPaletteOnly.ts

@@ -0,0 +1,23 @@
+import type { Rule } from "../types";
+
+/**
+ * Mined from claude-sessions-digest/portfolio-reels.md and
+ * revola-craft-video.md: synthesized SFX (whoosh, reveal risers, success
+ * chimes, bling, fake typewriters) were rejected roughly eight times across
+ * projects ("I hate the whoosh sound"; "the success sound is annoying";
+ * "This is not the right typewriter effect"); only real recordings survived
+ * (asmr-typing.wav, the real keyboard recording, soft plops), with the
+ * direction "it should please the ear not irritate".
+ */
+export const approvedSfxPaletteOnly: Rule = {
+  id: "approved-sfx-palette-only",
+  claim: "Source SFX only from the approved library of real recordings (ASMR typing, UI clicks, soft plops); synthesized whooshes, reveal risers, success chimes, and bling tones are banned, no single sound is overused, and SFX sit above the music in the mix.",
+  why: "Every synthesized or harsh sound was rejected on first listen, across three videos; the approved recordings were the only sounds that ever survived review.",
+  learnedFrom: "claude-sessions-digest/portfolio-reels.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "The rule is an asset-selection judgment over audio files; no code location expresses it.",
+  },
+};