@revola-ai/video-craft 0.2.1

package/dist/registry.js

@@ -0,0 +1,307 @@
+import { animatedBarChartTightBox } from "./rules/animatedBarChartTightBox.js";
+import { animatedBarChartWhenNotToUse } from "./rules/animatedBarChartWhenNotToUse.js";
+import { animatedBarChartWhenToUse } from "./rules/animatedBarChartWhenToUse.js";
+import { animatedLineChartWhenNotToUse } from "./rules/animatedLineChartWhenNotToUse.js";
+import { animatedLineChartWhenToUse } from "./rules/animatedLineChartWhenToUse.js";
+import { approvedSfxPaletteOnly } from "./rules/approvedSfxPaletteOnly.js";
+import { atmosphereGradientsFadeAtBothEnds } from "./rules/atmosphereGradientsFadeAtBothEnds.js";
+import { audioIsTheClock } from "./rules/audioIsTheClock.js";
+import { beatsDeriveFromTheirOwnSequence } from "./rules/beatsDeriveFromTheirOwnSequence.js";
+import { bestSceneSetsTheBar } from "./rules/bestSceneSetsTheBar.js";
+import { bumpBeforeRefreeze } from "./rules/bumpBeforeRefreeze.js";
+import { cameraIsTheNarrator } from "./rules/cameraIsTheNarrator.js";
+import { checkPinBeforeShip } from "./rules/checkPinBeforeShip.js";
+import { coldViewerClarity } from "./rules/coldViewerClarity.js";
+import { commitOrCutEffects } from "./rules/commitOrCutEffects.js";
+import { convertFramesAcrossClockBoundary } from "./rules/convertFramesAcrossClockBoundary.js";
+import { crossCutElementsLiveInTheHudLayer } from "./rules/crossCutElementsLiveInTheHudLayer.js";
+import { cursorClicksRealControls } from "./rules/cursorClicksRealControls.js";
+import { cutOnRealAudioPauses } from "./rules/cutOnRealAudioPauses.js";
+import { darkButNeverDim } from "./rules/darkButNeverDim.js";
+import { dataRadarTagsDeclared } from "./rules/dataRadarTagsDeclared.js";
+import { declareAVerticalZoneMap } from "./rules/declareAVerticalZoneMap.js";
+import { deleteRejectedRigsCompletely } from "./rules/deleteRejectedRigsCompletely.js";
+import { deriveSeamsDontMeasure } from "./rules/deriveSeamsDontMeasure.js";
+import { deterministicSceneSource } from "./rules/deterministicSceneSource.js";
+import { diegeticSoundForOnscreenActions } from "./rules/diegeticSoundForOnscreenActions.js";
+import { distinctTransitionPerBeat } from "./rules/distinctTransitionPerBeat.js";
+import { downloadOrDrawRichAssets } from "./rules/downloadOrDrawRichAssets.js";
+import { elementOnscreenForItsVoSentence } from "./rules/elementOnscreenForItsVoSentence.js";
+import { emitBuildNotes } from "./rules/emitBuildNotes.js";
+import { energyFromTimingNotPartCount } from "./rules/energyFromTimingNotPartCount.js";
+import { evidenceBeforeClaimingFixed } from "./rules/evidenceBeforeClaimingFixed.js";
+import { exactPeerLockstep } from "./rules/exactPeerLockstep.js";
+import { firstPassIsADraft } from "./rules/firstPassIsADraft.js";
+import { fixCrowdingByRebandingNotNudging } from "./rules/fixCrowdingByRebandingNotNudging.js";
+import { fixesPreserveApprovedElements } from "./rules/fixesPreserveApprovedElements.js";
+import { floatingNotBoxed } from "./rules/floatingNotBoxed.js";
+import { focusBeatsRecedeTheContext } from "./rules/focusBeatsRecedeTheContext.js";
+import { fontVarsBrandRemocn } from "./rules/fontVarsBrandRemocn.js";
+import { geometricSeamsNotCrossfades } from "./rules/geometricSeamsNotCrossfades.js";
+import { geometrySidecarExportsTyped } from "./rules/geometrySidecarExportsTyped.js";
+import { glowIsAFocalAccent } from "./rules/glowIsAFocalAccent.js";
+import { heroFillsTheFrame } from "./rules/heroFillsTheFrame.js";
+import { htmlMasksForAnimatedCounters } from "./rules/htmlMasksForAnimatedCounters.js";
+import { impactStackOnPayoffs } from "./rules/impactStackOnPayoffs.js";
+import { interactiveTargetsAreDeclaredData } from "./rules/interactiveTargetsAreDeclaredData.js";
+import { interpolateLiteralKeysMonotonic } from "./rules/interpolateLiteralKeysMonotonic.js";
+import { latenessIsStructuralOverlapTheBeats } from "./rules/latenessIsStructuralOverlapTheBeats.js";
+import { lessTextMoreVisualizations } from "./rules/lessTextMoreVisualizations.js";
+import { liveLinkDuplicateReactAlias } from "./rules/liveLinkDuplicateReactAlias.js";
+import { make2dElements3d } from "./rules/make2dElements3d.js";
+import { masterMixLoudnessTarget } from "./rules/masterMixLoudnessTarget.js";
+import { measureAlignmentDontEyeball } from "./rules/measureAlignmentDontEyeball.js";
+import { motionCarriesWeightAndMeaning } from "./rules/motionCarriesWeightAndMeaning.js";
+import { motionDensityFloor } from "./rules/motionDensityFloor.js";
+import { neverEditTierBVendored } from "./rules/neverEditTierBVendored.js";
+import { neverRestateDerivedFrameNumbersInComments } from "./rules/neverRestateDerivedFrameNumbersInComments.js";
+import { noAiGradientLook } from "./rules/noAiGradientLook.js";
+import { noColoredFlashToHideACut } from "./rules/noColoredFlashToHideACut.js";
+import { noDoubleFrameShift } from "./rules/noDoubleFrameShift.js";
+import { noDuplicateMotionPrimitives } from "./rules/noDuplicateMotionPrimitives.js";
+import { noLinearMotion } from "./rules/noLinearMotion.js";
+import { noNestedSvgFilters } from "./rules/noNestedSvgFilters.js";
+import { noRepeatedAssetAcrossShots } from "./rules/noRepeatedAssetAcrossShots.js";
+import { noShorthandWithUndefinedLonghand } from "./rules/noShorthandWithUndefinedLonghand.js";
+import { noStackedFadesAtACut } from "./rules/noStackedFadesAtACut.js";
+import { noStaticHolds } from "./rules/noStaticHolds.js";
+import { occlusionVisibleElements } from "./rules/occlusionVisibleElements.js";
+import { oneContinuousVoTrack } from "./rules/oneContinuousVoTrack.js";
+import { onePunchPerMomentClass } from "./rules/onePunchPerMomentClass.js";
+import { oneRenderPerRound } from "./rules/oneRenderPerRound.js";
+import { openingsAndClosingsCarryMore } from "./rules/openingsAndClosingsCarryMore.js";
+import { openStaticAfterAHardCut } from "./rules/openStaticAfterAHardCut.js";
+import { persistentDeviceFrames } from "./rules/persistentDeviceFrames.js";
+import { pixelDiffAnEmptyBandFirst } from "./rules/pixelDiffAnEmptyBandFirst.js";
+import { planIsPublishedNotGating } from "./rules/planIsPublishedNotGating.js";
+import { poweredByRevolaWatermark } from "./rules/poweredByRevolaWatermark.js";
+import { predrawContentPresentAtTheCut } from "./rules/predrawContentPresentAtTheCut.js";
+import { premiumSurfacesNotFlatBorders } from "./rules/premiumSurfacesNotFlatBorders.js";
+import { radarDispositionsAreHumanOnly } from "./rules/radarDispositionsAreHumanOnly.js";
+import { realAssetsNotPlaceholders } from "./rules/realAssetsNotPlaceholders.js";
+import { rebuildUiFromReconNotScreenshots } from "./rules/rebuildUiFromReconNotScreenshots.js";
+import { reconStrandsRunInParallel } from "./rules/reconStrandsRunInParallel.js";
+import { registryBeforeHandrolling } from "./rules/registryBeforeHandrolling.js";
+import { remapRateEndpointFormula } from "./rules/remapRateEndpointFormula.js";
+import { remocnContentTailwindChrome } from "./rules/remocnContentTailwindChrome.js";
+import { retimeOnlyViaPlaybackOrDesignTokens } from "./rules/retimeOnlyViaPlaybackOrDesignTokens.js";
+import { reviewTheRenderByFrameSweep } from "./rules/reviewTheRenderByFrameSweep.js";
+import { rollingNumberBoundedSequence } from "./rules/rollingNumberBoundedSequence.js";
+import { rollingNumberSequenceLayoutNone } from "./rules/rollingNumberSequenceLayoutNone.js";
+import { rollingNumberTightBoxAlignment } from "./rules/rollingNumberTightBoxAlignment.js";
+import { rollingNumberWhenNotToUse } from "./rules/rollingNumberWhenNotToUse.js";
+import { rollingNumberWhenToUse } from "./rules/rollingNumberWhenToUse.js";
+import { sameFamilySameProject } from "./rules/sameFamilySameProject.js";
+import { sampleBrandFromProduct } from "./rules/sampleBrandFromProduct.js";
+import { sampleVelocityFromPreviousFramePosition } from "./rules/sampleVelocityFromPreviousFramePosition.js";
+import { sceneRootTagDeclared } from "./rules/sceneRootTagDeclared.js";
+import { scrubDemoDataToGenericRoles } from "./rules/scrubDemoDataToGenericRoles.js";
+import { selfReviewThePlanForGaps } from "./rules/selfReviewThePlanForGaps.js";
+import { sourceArchivedBeforeBrief } from "./rules/sourceArchivedBeforeBrief.js";
+import { statisticsSelfExplanatory } from "./rules/statisticsSelfExplanatory.js";
+import { stopsAsRelativeSpacing } from "./rules/stopsAsRelativeSpacing.js";
+import { themePerSection } from "./rules/themePerSection.js";
+import { thesisDeclaredInBrief } from "./rules/thesisDeclaredInBrief.js";
+import { theWholeCanvasWorks } from "./rules/theWholeCanvasWorks.js";
+import { tierARequiresPropUnreachableEdit } from "./rules/tierARequiresPropUnreachableEdit.js";
+import { tinyBodyCopyAsRuledLines } from "./rules/tinyBodyCopyAsRuledLines.js";
+import { titlesPinnedOutsideCameraPush } from "./rules/titlesPinnedOutsideCameraPush.js";
+import { tokensNotRawHexes } from "./rules/tokensNotRawHexes.js";
+import { typeTokenDefaultedParamsAsString } from "./rules/typeTokenDefaultedParamsAsString.js";
+import { varyKitChoreographyAcrossSections } from "./rules/varyKitChoreographyAcrossSections.js";
+import { varyTheVisualizationGrammar } from "./rules/varyTheVisualizationGrammar.js";
+import { verifyCheapRenderDear } from "./rules/verifyCheapRenderDear.js";
+import { voAddressesTheViewer } from "./rules/voAddressesTheViewer.js";
+import { voIsAPerformance } from "./rules/voIsAPerformance.js";
+import { voScriptLocksSpokenWords } from "./rules/voScriptLocksSpokenWords.js";
+import { wrappersPreserveChildGeometry } from "./rules/wrappersPreserveChildGeometry.js";
+import RADAR_CHECK_IDS from "./radar-check-ids.json" with { type: "json" };
+const RULES = [
+  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 = /* @__PURE__ */ new Set(["gate", "craft", "process"]);
+const KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const COHERENCE_OWNER = "coherence";
+function validateRegistry(rules, checkIds = RADAR_CHECK_IDS) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  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}"`);
+    }
+    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 ?? []) {
+      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) {
+      errors.push(`rule "${rule.id}" carries both an anchor and an unanchorable reason`);
+    }
+    if (e.kind === "prose" && "unanchorable" in e && !e.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`);
+    }
+    if (rule.owner !== void 0 && 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}"`);
+    }
+  }
+  for (const field of ["whenToUse", "whenNotToUse"]) {
+    const counts = /* @__PURE__ */ new Map();
+    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;
+}
+export {
+  RULES,
+  validateRegistry
+};

package/dist/rules/animatedBarChartTightBox.js

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

package/dist/rules/animatedBarChartWhenNotToUse.js

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

package/dist/rules/animatedBarChartWhenToUse.js

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

package/dist/rules/animatedLineChartWhenNotToUse.js

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

package/dist/rules/animatedLineChartWhenToUse.js

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

package/dist/rules/approvedSfxPaletteOnly.js

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

package/dist/rules/atmosphereGradientsFadeAtBothEnds.js

@@ -0,0 +1,15 @@
+const atmosphereGradientsFadeAtBothEnds = {
+  id: "atmosphere-gradients-fade-at-both-ends",
+  claim: "Make full-bleed atmosphere gradients (fog, haze) transparent at both ends and confine them to a declared world band.",
+  why: "A fog gradient that started opaque produced a hard black band that sliced the frame and cut the clock in half; band confinement guarantees it can never reach elements in other zones.",
+  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 {
+  atmosphereGradientsFadeAtBothEnds
+};

package/dist/rules/audioIsTheClock.js

@@ -0,0 +1,16 @@
+const audioIsTheClock = {
+  id: "audio-is-the-clock",
+  claim: "Record or generate the voiceover first, measure it, and fit the video to the audio; never re-time audio to fit the video.",
+  why: "Reversing the order forces re-recording or hand-stretching audio every time timing shifts, and every feedback round shifts timing; deriving durations from the measured WAV makes a re-time a re-measure.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "gate",
+  verify: "`ffprobe -show_entries stream=nb_frames <render>` equals `total` in .video/timing.json",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/measure.ts" }
+  }
+};
+export {
+  audioIsTheClock
+};

package/dist/rules/beatsDeriveFromTheirOwnSequence.js

@@ -0,0 +1,15 @@
+const beatsDeriveFromTheirOwnSequence = {
+  id: "beats-derive-from-their-own-sequence",
+  claim: "Compute a beat's frame from the duration of the Sequence it renders in, never from a parent's or a section's length.",
+  why: "A click beat derived from its section's length landed 10 frames past the last frame its shorter in-frame sequence ever draws, so the cursor drifted toward the button and the scene cut away before the press - the beat silently did not exist, and nothing failed.",
+  learnedFrom: "claude-sessions-digest/product-room-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/productroom/PRColdOpen.tsx" }
+  }
+};
+export {
+  beatsDeriveFromTheirOwnSequence
+};

package/dist/rules/bestSceneSetsTheBar.js

@@ -0,0 +1,15 @@
+const bestSceneSetsTheBar = {
+  id: "best-scene-sets-the-bar",
+  claim: "The moment a scene is approved it becomes the film's standard: take it as inspiration for every other scene, name it in review, and measure the weakest scene against the strongest every round.",
+  why: "'Amazing, move on to the next scene, now you know what I like' and 'make it match the first 3 scenes' animation quality' show approval creating a bar; rounds that ignored it re-litigated settled taste scene by scene.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A cross-scene quality comparison made during review rounds; no single code location expresses it."
+  }
+};
+export {
+  bestSceneSetsTheBar
+};

package/dist/rules/bumpBeforeRefreeze.js

@@ -0,0 +1,15 @@
+const bumpBeforeRefreeze = {
+  id: "bump-before-refreeze",
+  claim: "If kit content changed, bump the kit version before re-freezing; never repack the same version with different bytes.",
+  why: "A same-version repack is a silent wrong pin: npm sees an unchanged dep string, keeps old content locally, and breaks fresh installs elsewhere.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "process",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/kitShell.ts", symbol: "freezeKit" }
+  }
+};
+export {
+  bumpBeforeRefreeze
+};

package/dist/rules/cameraIsTheNarrator.js

@@ -0,0 +1,15 @@
+const cameraIsTheNarrator = {
+  id: "camera-is-the-narrator",
+  claim: "The camera tells the story with few, motivated, committed moves - a push into the element the VO names, a continuous journey through stations, following typing as it happens, a dive through an element into the next scene - each aimed at one subject with dwell time at the destination; unmotivated, whiplash, or decorative in-out moves read as mistakes.",
+  why: "'Amazing camera effects' was the recurring ask and 'camera buggy and clumsy ... it zooms in and suddenly zooms out' the recurring complaint; three deliberate moves consistently out-reviewed five micro-keys, and editorial single-subject framing beat crowded ensemble frames.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A camera-arc judgment across a scene's key schedule; no single code location expresses it."
+  }
+};
+export {
+  cameraIsTheNarrator
+};

package/dist/rules/checkPinBeforeShip.js

@@ -0,0 +1,16 @@
+const checkPinBeforeShip = {
+  id: "check-pin-before-ship",
+  claim: "Run check-pin --project <dir> before any video ships; ship only on a frozen, committed, integrity-matching tarball pin.",
+  why: "Shipping on a live link or stale tarball makes the delivered render non-reproducible: the exact bytes that rendered it cannot be recovered later.",
+  learnedFrom: "HOW_I_BUILD_VIDEOS.md",
+  tier: "gate",
+  verify: "`video check-pin --project <dir>`",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-cli/src/cli.ts" }
+  }
+};
+export {
+  checkPinBeforeShip
+};

package/dist/rules/coldViewerClarity.js

@@ -0,0 +1,15 @@
+const coldViewerClarity = {
+  id: "cold-viewer-clarity",
+  claim: "Every scene passes the cold-viewer test: someone outside the company can say what the scene is about; confusion is fixed with orientation copy, clearer visual metaphors, or slower reveals, because clarity and spectacle are the same axis, not a trade.",
+  why: "'I showed someone this video and they said they don't get it' triggered rebuilds of scenes that were already visually approved; polish that fails to communicate is not polish.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A comprehension judgment requiring an outside-context reading of the scene; no single code location expresses it."
+  }
+};
+export {
+  coldViewerClarity
+};

package/dist/rules/commitOrCutEffects.js

@@ -0,0 +1,29 @@
+const commitOrCutEffects = {
+  id: "commit-or-cut-effects",
+  claim: "An effect either commits or gets cut: a half-committed effect that barely registers is as much a defect as one stamped on every beat, and film grain is out entirely.",
+  why: "Review rounds flagged both failure directions - 'don't overuse the reveal effect' alongside 'the blur effect is so minimal and low effort' - so the only approved states for an effect are absent or unmistakable.",
+  learnedFrom: "docs/style/CREATIVE_EDGE.md",
+  tier: "craft",
+  // The blanket "film grain is out entirely" half of this claim contradicted
+  // the shipped kit, which exports and documents `FilmGrain` (video-kit
+  // src/craft/stage.tsx), and QGuard renders it twice in Shell.tsx. Unwaived,
+  // the projection read as a standing instruction to delete a deliberate,
+  // spec'd element - so an agent following CLAUDE.md would strip working
+  // work. The ban itself is real client feedback ("just don't like that grain
+  // effect", CREATIVE_EDGE directive 15), so it stands everywhere else.
+  exceptions: [
+    {
+      project: "qse-qguard-video",
+      decision: "client chose ACT854's persistent frame chrome for the QGuard restyle, film grain included - specified in the mounted-once cinematic overlay as a 256px feTurbulence tile at mixBlendMode overlay (motion-brand-spec \xA76.1)",
+      recordedIn: "qse-qguard-video/docs/motion-brand-spec.md"
+    }
+  ],
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    unanchorable: "A commitment-level judgment per effect instance; no single code location expresses it."
+  }
+};
+export {
+  commitOrCutEffects
+};

package/dist/rules/convertFramesAcrossClockBoundary.js

@@ -0,0 +1,15 @@
+const convertFramesAcrossClockBoundary = {
+  id: "convert-frames-across-clock-boundary",
+  claim: "When design and playback clocks coexist, route every cross-boundary value through the remap: values mirroring scene-internal beats convert design-to-playback, and values measuring the film read the composition timeline.",
+  why: "A design frame used where a playback frame is meant drifts silently: raw design-frame cue anchors would have been ~1.5s off picture at 1.34x, and the on-screen counter would have claimed a 60s runtime the 56.6s film does not have.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/mix.tsx", symbol: "at1" }
+  }
+};
+export {
+  convertFramesAcrossClockBoundary
+};

package/dist/rules/crossCutElementsLiveInTheHudLayer.js

@@ -0,0 +1,15 @@
+const crossCutElementsLiveInTheHudLayer = {
+  id: "cross-cut-elements-live-in-the-hud-layer",
+  claim: "Render any element that must hold an exact screen position across a scene cut (a seam contract) in the HUD/screen-space layer, never in world space under the camera.",
+  why: "In world space the camera drags the element wherever the last key happens to be, so any recut silently moves the seam and invalidates the neighbouring scene's match cut.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/scenes/craft/craftKit.tsx", symbol: "CraftStage" }
+  }
+};
+export {
+  crossCutElementsLiveInTheHudLayer
+};

package/dist/rules/cursorClicksRealControls.js

@@ -0,0 +1,15 @@
+const cursorClicksRealControls = {
+  id: "cursor-clicks-real-controls",
+  claim: "Every cursor click lands on a real, visible control and causes a visible state change; click ripples appear only on genuine navigation clicks, never as decorative presses inside content.",
+  why: "Decorative presses that change nothing read as confusing and 'really bad' to clients, and the ripple fix needed a second round because leftover presses survived; interaction realism is what sells a walkthrough as the real product.",
+  learnedFrom: "claude-sessions-digest/act854-qpa-video.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "packages/video-kit/src/pure/walk.ts" }
+  }
+};
+export {
+  cursorClicksRealControls
+};

package/dist/rules/cutOnRealAudioPauses.js

@@ -0,0 +1,15 @@
+const cutOnRealAudioPauses = {
+  id: "cut-on-real-audio-pauses",
+  claim: "Place scene boundaries inside real pauses in the recorded read, verified with ffmpeg silencedetect, never by arithmetic division of the audio.",
+  why: "An arithmetic cut point lands mid-word or mid-breath; verifying against detected silences guarantees each scene change coincides with a pause in the narration.",
+  learnedFrom: "revola-video/BUILD_NOTES_CRAFT.md",
+  tier: "craft",
+  scope: { kind: "pipeline" },
+  enforcement: {
+    kind: "prose",
+    anchor: { file: "revola-video/src/tokensCraft.ts" }
+  }
+};
+export {
+  cutOnRealAudioPauses
+};