reframe-video 0.6.32 → 0.6.34

package/dist/labels.js

@@ -728,12 +728,12 @@ function validateScene(ir) {
   if (problems.length > 0) throw new SceneValidationError(problems);
 }
 
-// ../core/src/presets.ts
-var SET = 1 / 120;
-
 // ../core/src/evaluate.ts
 var DEG = Math.PI / 180;
 
+// ../core/src/presets.ts
+var SET = 1 / 120;
+
 // ../render-cli/src/loadScene.ts
 import { build } from "esbuild";
 import { readFile } from "node:fs/promises";

package/dist/trace-cli.js

@@ -93,12 +93,12 @@ function wait(duration, label) {
   return { kind: "wait", duration, ...label !== void 0 && { label } };
 }
 
-// ../core/src/presets.ts
-var SET = 1 / 120;
-
 // ../core/src/evaluate.ts
 var DEG = Math.PI / 180;
 
+// ../core/src/presets.ts
+var SET = 1 / 120;
+
 // ../core/src/motion.ts
 var EASE_BY_CLASS = {
   accelerating: "easeInCubic",

package/dist/types/autoFoley.d.ts

@@ -0,0 +1,18 @@
+/**
+ * autoFoley — the animation scores its own sound effects, deterministically.
+ *
+ * A pure analysis pass over the compiled motion: it samples each node's own
+ * (camera-independent) x/y/scale/opacity over the timeline and emits sound cues
+ * for the gestures it sees — a fast move → whoosh, a moving-then-stopping settle
+ * → impact, a scale-in → pop — panned by screen position. Because it re-derives
+ * cues from `sampleProp` (the same deterministic sampler `evaluate` uses), the
+ * sound follows retiming and AI regeneration for free, and any manual `audio.cues`
+ * still layer on top. The audio analogue of evaluate(scene, t); the motion
+ * generalization of `textTypeCues`.
+ *
+ * MVP scope: translation / settle / scale-in + pan. Deferred: sustained scale
+ * riser→impact, rotation→swish.
+ */
+import type { CompiledScene } from "./compile.js";
+import type { AudioCueIR, AutoFoleyOptions } from "./ir.js";
+export declare function autoFoley(compiled: CompiledScene, opts?: AutoFoleyOptions): AudioCueIR[];

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export { composeScene, formatComposeReport, type OverlayDoc, type ComposeReport,
 export { compileScene, type CompiledScene, type PropertySegment, type LabelSpan, type MotionDriver } from "./compile.js";
 export { pathPoint, pathTangentAngle, type Pt } from "./path.js";
 export { cameraTo, cameraFit, cameraMatrix, CAMERA_ID, CAMERA_PROPS } from "./camera.js";
+export { autoFoley } from "./autoFoley.js";
 export { linearGradient, radialGradient, conicGradient, isGradient } from "./gradient.js";
 export { glow, dropShadow } from "./effects.js";
 export { row, column, grid, type RowOpts, type GridOpts } from "./layout.js";

package/dist/types/ir.d.ts

@@ -467,6 +467,31 @@ export interface AudioIR {
         } | false;
     };
     cues?: AudioCueIR[];
+    /**
+     * Auto-generate sound cues from node motion (move→whoosh, settle→impact,
+     * scale-in→pop, panned by position). Deterministic + retime-safe (re-derived
+     * from the motion each render); manual `cues` still layer on top.
+     */
+    autoFoley?: boolean | AutoFoleyOptions;
+}
+/** Knobs for {@link AudioIR.autoFoley}. */
+export interface AutoFoleyOptions {
+    /** Master gain applied to every auto cue (default 0.5). */
+    gain?: number;
+    /** Emit a whoosh/swish at a fast move's velocity peak (default true). */
+    whoosh?: boolean;
+    /** Emit a thud/knock when a moving node settles to a stop (default true). */
+    impact?: boolean;
+    /** Emit a pop when a node scales in (default true). */
+    pop?: boolean;
+    /** Stereo-pan each cue by the node's x position (default true). */
+    pan?: boolean;
+    /** Only foley these node ids (default: every node). */
+    nodes?: string[];
+    /** Cap the number of cues, keeping the loudest (default 32). */
+    maxCues?: number;
+    /** Scale the detection thresholds: >1 = more sensitive / more cues (default 1). */
+    sensitivity?: number;
 }
 /**
  * The scene camera: a viewport over the whole scene. `(x,y)` is the scene point

package/guides/edsl-guide.md

@@ -578,6 +578,16 @@ explicitly with `params`: `{ sfx: "blip", params: { seed: 4 } }` (pick the varia
 `{ sfx: "tick", params: { pitch: 1.5 } }` (an explicit frequency multiplier; `2` = octave
 up). `params.gainDb` trims a single hit.
 
+**Auto-foley — the motion scores itself.** `audio: { autoFoley: true }` derives sound
+cues from node motion, no manual cues needed: a fast move → `whoosh`/`swish` at the
+velocity peak, a moving node that settles → `thud`/`knock`, a scale-in → `pop`, each
+panned by its on-screen x. It's a pure pass over the compiled motion, so it's
+deterministic AND **retime/regeneration-safe** — retime a step and the sound follows.
+Manual `cues` still layer on top (and win). Best for discrete-element scenes; on dense
+scenes use the options to stay tasteful: `autoFoley: { gain?, whoosh?, impact?, pop?,
+pan?, sensitivity?, maxCues?, nodes?: [ids] }` (`maxCues` keeps the loudest, `nodes`
+allowlists). See `examples/scenes/auto-foley-demo.ts` (zero manual cues).
+
 **bgm beds**: synthesized via `bgm.synth` (`ambient-pad` `lofi` `pulse` `tension`
 `uplift`), or a file via `bgm.file` — bundled CC0 music: `bgm-song21.mp3` (ambient),
 `bgm-synthwave.mp3` (chill), `bgm-piano.mp3` (elegant), `bgm-battle.mp3` (energetic),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reframe-video",
-  "version": "0.6.32",
+  "version": "0.6.34",
   "description": "Declarative motion graphics that AI can write and humans can tweak — human edits survive AI regeneration. Deterministic mp4 renders from a plain-data scene format.",
   "keywords": [
     "motion-graphics",