@hyperframes/core 0.8.159 → 0.8.161

package/dist/audioSections.js

@@ -0,0 +1,117 @@
+/**
+ * Sections from signal processing: band energies and chroma averaged into half-second blocks, a self-similarity matrix, and
+ * Foote's checkerboard novelty, whose peaks are where the music changes. Boundaries snap to the nearest beat.
+ */
+import { bandFramesOf, medianInterval, rhythm } from "./audioRhythm.js";
+import { snapper } from "./audioSnap.js";
+const BLOCK_SECONDS = 0.5;
+/** Checkerboard half-width: eight seconds of music either side of a candidate boundary. */
+const KERNEL_BLOCKS = 16;
+const SAME_SECTION = 0.9;
+const round = (t) => Math.round(t * 1000) / 1000;
+function meanOf(frames) {
+    const sum = new Array(frames[0]?.length ?? 0).fill(0);
+    for (const frame of frames)
+        for (let b = 0; b < sum.length; b++)
+            sum[b] += frame[b];
+    return sum.map((v) => v / (frames.length || 1));
+}
+/** Each band moved to zero mean and unit spread over time, in place. */
+function standardizeBands(blocks) {
+    for (let b = 0; b < (blocks[0]?.length ?? 0); b++) {
+        const column = blocks.map((block) => block[b]);
+        const mean = column.reduce((a, v) => a + v, 0) / column.length;
+        const spread = Math.sqrt(column.reduce((a, v) => a + (v - mean) ** 2, 0) / column.length);
+        for (const block of blocks)
+            block[b] = (block[b] - mean) / (spread || 1);
+    }
+}
+/** Block means of the band energies and of the log chroma, each part unit length within a block. */
+function blockParts({ fps, bands, chroma, chromaFps }) {
+    const per = Math.max(1, Math.round(BLOCK_SECONDS * fps));
+    const chromaPer = Math.max(1, Math.round(BLOCK_SECONDS * chromaFps));
+    const blocks = [];
+    for (let start = 0, b = 0; start + per <= bands.length; start += per, b++) {
+        const pitch = meanOf(chroma.slice(b * chromaPer, (b + 1) * chromaPer)).map(Math.log1p);
+        blocks.push([...meanOf(bands.slice(start, start + per)), ...unit(pitch)]);
+    }
+    return blocks;
+}
+function blockFeatures(frames) {
+    const blocks = blockParts(frames);
+    standardizeBands(blocks);
+    const split = frames.bands[0]?.length ?? 0;
+    return blocks.map((block) => [...unit(block.slice(0, split)), ...unit(block.slice(split))].map((v) => v * Math.SQRT1_2));
+}
+function unit(vector) {
+    const length = Math.hypot(...vector) || 1;
+    return vector.map((v) => v / length);
+}
+const dot = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
+/** The checkerboard kernel, offsets -KERNEL_BLOCKS…KERNEL_BLOCKS-1 each way: + within a side, − across, tapered. */
+const CHECKERBOARD = (() => {
+    const offsets = Array.from({ length: 2 * KERNEL_BLOCKS }, (_, k) => k - KERNEL_BLOCKS);
+    const taper = (k) => Math.exp(-0.5 * (((k < 0 ? -k - 1 : k) + 0.5) / (KERNEL_BLOCKS / 2)) ** 2);
+    return offsets.map((a) => offsets.map((b) => (a < 0 === b < 0 ? 1 : -1) * taper(a) * taper(b)));
+})();
+/** Foote novelty at block `i`: similarity within each side of it minus similarity across it. */
+function noveltyAt(blocks, i) {
+    let sum = 0;
+    CHECKERBOARD.forEach((row, a) => {
+        const x = blocks[i + a - KERNEL_BLOCKS];
+        if (!x)
+            return;
+        row.forEach((weight, b) => {
+            const y = blocks[i + b - KERNEL_BLOCKS];
+            if (y)
+                sum += weight * dot(x, y);
+        });
+    });
+    return sum;
+}
+const novelty = (blocks) => blocks.map((_, i) => noveltyAt(blocks, i));
+/** Blocks where novelty peaks over its neighbourhood and clears the mean by a standard deviation. */
+function boundaryBlocks(curve, minBlocks) {
+    const mean = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
+    const spread = Math.sqrt(curve.reduce((a, v) => a + (v - mean) ** 2, 0) / (curve.length || 1));
+    const peaks = [];
+    for (let i = minBlocks; i <= curve.length - minBlocks; i++) {
+        const neighbourhood = curve.slice(Math.max(0, i - minBlocks), i + minBlocks + 1);
+        if (curve[i] < Math.max(...neighbourhood) || curve[i] <= mean + spread)
+            continue;
+        if (!peaks.length || i - peaks[peaks.length - 1] >= minBlocks)
+            peaks.push(i);
+    }
+    return peaks;
+}
+/** A letter per span: the letter of the first earlier span whose mean features are this alike, else a new one. */
+function labels(blocks, edges) {
+    const means = [];
+    const letters = [];
+    for (let s = 0; s + 1 < edges.length; s++) {
+        const part = blocks.slice(edges[s], edges[s + 1]);
+        const mean = unit(part[0].map((_, b) => part.reduce((a, block) => a + block[b], 0)));
+        const match = means.findIndex((other) => dot(other, mean) >= SAME_SECTION);
+        letters.push(match >= 0 ? letters[match] : String.fromCharCode(65 + (new Set(letters).size % 26)));
+        means.push(mean);
+    }
+    return letters;
+}
+/** Half the median beat interval: a boundary moves to a beat, never past one. */
+const beatTolerance = (beats) => (medianInterval(beats) ?? 0) / 2;
+export function sections(signal, options = {}) {
+    const duration = round((signal.channels[0]?.length ?? 0) / signal.sampleRate);
+    const blocks = blockFeatures(bandFramesOf(signal));
+    const minBlocks = Math.max(1, Math.round((options.minSeconds ?? 4) / BLOCK_SECONDS));
+    if (blocks.length < 2 * minBlocks)
+        return { spans: [{ start: 0, end: duration, label: "A" }] };
+    const edges = [0, ...boundaryBlocks(novelty(blocks), minBlocks), blocks.length];
+    const letters = labels(blocks, edges);
+    const beats = rhythm(signal).beats.times;
+    const onBeat = snapper(beats, beatTolerance(beats), "signal beats");
+    const times = edges.map((e, i) => i === 0 ? 0 : i === edges.length - 1 ? duration : round(onBeat.snap(e * BLOCK_SECONDS)));
+    return {
+        spans: letters.map((label, s) => ({ start: times[s], end: times[s + 1], label })),
+        snap: onBeat.report(),
+    };
+}

package/dist/audioSnap.d.ts

@@ -0,0 +1,18 @@
+/** Moving reported times onto measured ones, one at a time, and saying how far they moved. */
+export interface SnapReport {
+    /** What the times were moved onto. */
+    reference: string;
+    toleranceMs: number;
+    /** Times moved onto a measured one. */
+    snapped: number;
+    /** Times with nothing measured within the tolerance, kept as reported. */
+    unsnapped: number[];
+    /** Median distance between a reported time and the measured one it moved to, in ms: low means they agreed. */
+    medianShiftMs: number | null;
+}
+export interface Snapper {
+    snap: (t: number) => number;
+    report: () => SnapReport;
+}
+/** Snaps each time to the nearest of `measured` (ascending) when one is within `toleranceSeconds`, else keeps it. */
+export declare function snapper(measured: readonly number[], toleranceSeconds: number, reference: string): Snapper;

package/dist/audioSnap.js

@@ -0,0 +1,41 @@
+/** Moving reported times onto measured ones, one at a time, and saying how far they moved. */
+/** Index of the value in ascending `sorted` nearest `t`. */
+function nearestIndex(sorted, t) {
+    let low = 0;
+    let high = sorted.length - 1;
+    while (low < high) {
+        const mid = (low + high) >> 1;
+        if (sorted[mid] < t)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    return low > 0 && t - sorted[low - 1] <= sorted[low] - t ? low - 1 : low;
+}
+/** Snaps each time to the nearest of `measured` (ascending) when one is within `toleranceSeconds`, else keeps it. */
+export function snapper(measured, toleranceSeconds, reference) {
+    const shifts = [];
+    const unsnapped = [];
+    return {
+        snap(t) {
+            const nearest = measured.length ? measured[nearestIndex(measured, t)] : null;
+            if (nearest === null || Math.abs(nearest - t) > toleranceSeconds) {
+                unsnapped.push(t);
+                return t;
+            }
+            shifts.push(Math.abs(nearest - t));
+            return nearest;
+        },
+        report() {
+            const sorted = [...shifts].sort((a, b) => a - b);
+            const median = sorted.length ? sorted[sorted.length >> 1] : null;
+            return {
+                reference,
+                toleranceMs: Math.round(toleranceSeconds * 1000),
+                snapped: shifts.length,
+                unsnapped: [...unsnapped],
+                medianShiftMs: median === null ? null : Math.round(median * 1000),
+            };
+        },
+    };
+}

package/dist/beats/beatDetection.d.ts

@@ -1,13 +1,12 @@
-type BpmDetect = (buffer: AudioBuffer) => number;
-export declare function loadBpmDetective(importFn?: () => Promise<unknown>): Promise<BpmDetect | null>;
+import { type AudioSignal } from "../audioAnalysis.js";
 export interface MusicBeatAnalysis {
     beatTimes: number[];
     /** Per-beat loudness 0–1 (local RMS / peak), aligned by index with beatTimes. */
     beatStrengths: number[];
     bpm: number | null;
     bpmConfidence: "high" | "low" | "uncertain";
-    /** Decoded mono samples — retained so strength can be measured at user-added
-     *  beats. Audio-file coordinates. May be null if decode data was dropped. */
+    /** Per-sample level across channels — retained so strength can be measured at
+     *  user-added beats. Audio-file coordinates. May be null if decode data was dropped. */
     channelData: Float32Array | null;
     sampleRate: number;
     /** Reference peak RMS used to normalize beat strengths. */
@@ -17,11 +16,10 @@ export interface MusicBeatAnalysis {
 export declare function computeRmsAt(channelData: Float32Array, sampleRate: number, time: number): number;
 /** Normalized beat strength (0–1) at an audio-file time, using a track peak. */
 export declare function strengthAtTime(analysis: Pick<MusicBeatAnalysis, "channelData" | "sampleRate" | "peak">, time: number): number;
-export declare function detectBeats(audioBuffer: AudioBuffer): Promise<number[]>;
 export interface MusicAnalysisOptions {
     pause?: () => Promise<void>;
 }
-export declare function analyzeMusicFromBuffer(audioBuffer: AudioBuffer, { pause }?: MusicAnalysisOptions): Promise<MusicBeatAnalysis>;
-export declare function detectBeatsFromUrl(url: string): Promise<number[]>;
+/** Beats, tempo and per-beat strength of decoded audio; no beats and a null bpm when it has no steady beat. */
+export declare function analyzeMusicFromSignal(signal: AudioSignal, { pause }?: MusicAnalysisOptions): Promise<MusicBeatAnalysis>;
+export declare function analyzeMusicFromBuffer(audioBuffer: AudioBuffer, options?: MusicAnalysisOptions): Promise<MusicBeatAnalysis>;
 export declare function analyzeMusicFromUrl(url: string, options?: MusicAnalysisOptions): Promise<MusicBeatAnalysis>;
-export {};

package/dist/beats/beatDetection.js

@@ -1,28 +1,5 @@
-let bpmDetectivePromise = null;
-const defaultBpmDetectiveImport = () => 
-// @ts-ignore -- no type declarations for bpm-detective
-import("bpm-detective");
-export function loadBpmDetective(importFn = defaultBpmDetectiveImport) {
-    const useCache = importFn === defaultBpmDetectiveImport;
-    if (useCache && bpmDetectivePromise) {
-        return bpmDetectivePromise;
-    }
-    const promise = importFn()
-        .then((m) => (m.default ?? m) || null)
-        .catch(() => {
-        // Reset the cached promise so a transient import failure can be retried
-        // on the next call instead of being cached as null for the session.
-        if (useCache)
-            bpmDetectivePromise = null;
-        return null;
-    });
-    if (useCache) {
-        bpmDetectivePromise = promise;
-    }
-    return promise;
-}
-const WINDOW_SIZE = 1024;
-const HOP_SIZE = 512;
+import { energyMix } from "../audioAnalysis.js";
+import { bandFramesOf, rhythm, tempoOf } from "../audioRhythm.js";
 const STRENGTH_WINDOW_S = 0.05; // ±50ms RMS window
 /** Local RMS amplitude at a given audio-file time. */
 export function computeRmsAt(channelData, sampleRate, time) {
@@ -43,208 +20,39 @@ export function strengthAtTime(analysis, time) {
         return 0.5;
     return Math.min(1, computeRmsAt(analysis.channelData, analysis.sampleRate, time) / analysis.peak);
 }
-// fallow-ignore-next-line complexity
-export async function detectBeats(audioBuffer) {
-    const channelData = audioBuffer.getChannelData(0);
-    const sampleRate = audioBuffer.sampleRate;
-    const energies = [];
-    for (let i = 0; i < channelData.length - WINDOW_SIZE; i += HOP_SIZE) {
-        let sum = 0;
-        for (let j = 0; j < WINDOW_SIZE; j++) {
-            const sample = channelData[i + j];
-            sum += sample * sample;
-        }
-        energies.push(sum / WINDOW_SIZE);
-    }
-    const beats = [];
-    const localWindowSize = 20;
-    for (let i = localWindowSize; i < energies.length - localWindowSize; i++) {
-        let localMean = 0;
-        for (let j = i - localWindowSize; j < i + localWindowSize; j++) {
-            localMean += energies[j];
-        }
-        localMean /= localWindowSize * 2;
-        const threshold = localMean * 1.5;
-        const current = energies[i];
-        if (current > threshold &&
-            current > (energies[i - 1] ?? 0) &&
-            current > (energies[i + 1] ?? 0)) {
-            const timeInSeconds = (i * HOP_SIZE) / sampleRate;
-            if (beats.length === 0 || timeInSeconds - beats[beats.length - 1] > 0.1) {
-                beats.push(Math.round(timeInSeconds * 1000) / 1000);
-            }
-        }
-    }
-    return beats;
-}
-function computeBpmFromBeats(beatTimes) {
-    if (beatTimes.length < 4)
-        return null;
-    const iois = [];
-    for (let i = 1; i < beatTimes.length; i++) {
-        iois.push(beatTimes[i] - beatTimes[i - 1]);
-    }
-    const sorted = [...iois].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    const medianIoi = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-    if (medianIoi <= 0)
-        return null;
-    return Math.round((60 / medianIoi) * 10) / 10;
-}
-// Fold into 60–120 for octave-safe BPM comparison
-function canonicalizeBpm(bpm) {
-    let b = bpm;
-    while (b > 120)
-        b /= 2;
-    while (b < 60)
-        b *= 2;
-    return b;
-}
-// Pick the *2/÷2 octave of `bpm` whose beat interval is closest to the onset
-// pulse, so a half-time detective reading (e.g. 174 for an 87bpm song) doesn't
-// produce a double-density grid.
-function octaveAlignBpm(bpm, reference) {
-    const candidates = [bpm / 2, bpm, bpm * 2];
-    let best = bpm;
-    let bestDist = Number.POSITIVE_INFINITY;
-    for (const c of candidates) {
-        if (c <= 0)
-            continue;
-        const dist = Math.abs(c - reference);
-        if (dist < bestDist) {
-            bestDist = dist;
-            best = c;
-        }
-    }
-    return best;
-}
-// fallow-ignore-next-line complexity
-function regularizeBeats(rawBeats, bpm, duration) {
-    if (rawBeats.length === 0 || bpm <= 0 || duration <= 0)
-        return rawBeats;
-    const beatInterval = 60 / bpm;
-    // Guard against a pathological (octave-misread) tempo producing a millisecond
-    // interval → tens of thousands of grid beats that freeze the timeline. 480 BPM
-    // (0.125s) is well above any real music tempo; bail to the raw onsets instead.
-    if (beatInterval < 0.125)
-        return rawBeats;
-    const threshold = beatInterval * 0.25;
-    // Find phase offset that maximally aligns with raw onsets
-    let bestOffset = 0;
-    let bestScore = -1;
-    for (const anchor of rawBeats.slice(0, 10)) {
-        const offset = ((anchor % beatInterval) + beatInterval) % beatInterval;
-        let score = 0;
-        for (const rb of rawBeats) {
-            const phase = ((rb % beatInterval) + beatInterval) % beatInterval;
-            const dist = Math.min(Math.abs(phase - offset), beatInterval - Math.abs(phase - offset));
-            if (dist < threshold)
-                score++;
-        }
-        if (score > bestScore) {
-            bestScore = score;
-            bestOffset = offset;
-        }
-    }
-    const beats = [];
-    for (let t = bestOffset; t <= duration + 0.001; t += beatInterval) {
-        beats.push(Math.round(t * 1000) / 1000);
-    }
-    return beats;
-}
-// Drop beats that fall in silent/near-silent regions (e.g. intro/outro) and
-// score each surviving beat's loudness (local RMS / peak) for brightness.
-function gateBeatsBySilence(beats, channelData, sampleRate) {
-    if (beats.length === 0)
-        return { times: beats, strengths: [], peak: 1e-6 };
-    const energies = beats.map((t) => computeRmsAt(channelData, sampleRate, t));
+/** At or above this the tempo is reported as "high" confidence. */
+const HIGH_CONFIDENCE = 0.35;
+/** Each beat's local RMS against the loudest beat's, and that loudest RMS. */
+function beatStrengths(beats, levels, sampleRate) {
+    const energies = beats.map((t) => computeRmsAt(levels, sampleRate, t));
     const peak = Math.max(...energies, 1e-6);
-    const threshold = peak * 0.12;
-    const times = [];
-    const strengths = [];
-    for (let i = 0; i < beats.length; i++) {
-        if (energies[i] >= threshold) {
-            times.push(beats[i]);
-            strengths.push(Math.min(1, energies[i] / peak));
-        }
-    }
-    return { times, strengths, peak };
+    return { strengths: energies.map((e) => Math.min(1, e / peak)), peak };
 }
-// fallow-ignore-next-line complexity
-export async function analyzeMusicFromBuffer(audioBuffer, { pause } = {}) {
-    const channelData = audioBuffer.getChannelData(0);
-    const sampleRate = audioBuffer.sampleRate;
-    const duration = audioBuffer.duration;
+/** Beats, tempo and per-beat strength of decoded audio; no beats and a null bpm when it has no steady beat. */
+export async function analyzeMusicFromSignal(signal, { pause } = {}) {
     await pause?.();
-    const rawBeats = await detectBeats(audioBuffer);
-    const onsetBpm = computeBpmFromBeats(rawBeats);
-    let detectiveBpm = null;
-    const detect = await loadBpmDetective();
+    bandFramesOf(signal);
     await pause?.();
-    try {
-        if (detect)
-            detectiveBpm = detect(audioBuffer);
-    }
-    catch {
-        // Not enough peaks or browser context unavailable
-    }
-    let bpm = onsetBpm;
-    let confidence = "uncertain";
-    let regularizeBpm = null;
-    if (onsetBpm !== null && detectiveBpm !== null) {
-        const pctDiff = Math.abs(canonicalizeBpm(onsetBpm) - canonicalizeBpm(detectiveBpm)) /
-            canonicalizeBpm(detectiveBpm);
-        if (pctDiff < 0.05) {
-            // Detective folds tempo into 90–180; re-pick the octave nearest the onset
-            // pulse so a half-time track isn't gridded at double density.
-            bpm = octaveAlignBpm(detectiveBpm, onsetBpm);
-            confidence = "high";
-            regularizeBpm = bpm;
-        }
-        else if (pctDiff < 0.1) {
-            bpm = Math.round((onsetBpm + detectiveBpm) / 2);
-            confidence = "low";
-            regularizeBpm = bpm;
-        }
-        else {
-            bpm = onsetBpm;
-            confidence = "uncertain";
-        }
-    }
-    else if (onsetBpm !== null) {
-        bpm = onsetBpm;
-        confidence = "low";
-        regularizeBpm = onsetBpm;
-    }
-    else if (detectiveBpm !== null) {
-        bpm = detectiveBpm;
-        confidence = "low";
-        regularizeBpm = detectiveBpm;
-    }
+    const { beats } = rhythm(signal);
     await pause?.();
-    const gridBeats = regularizeBpm !== null ? regularizeBeats(rawBeats, regularizeBpm, duration) : rawBeats;
-    const gated = gateBeatsBySilence(gridBeats, channelData, sampleRate);
+    const channelData = energyMix(signal);
+    const confidence = beats.confidence ?? 0;
+    const times = beats.times;
+    const { strengths, peak } = beatStrengths(times, channelData, signal.sampleRate);
+    const bpm = tempoOf(times).value;
     return {
-        beatTimes: gated.times,
-        beatStrengths: gated.strengths,
+        beatTimes: times,
+        beatStrengths: strengths,
         bpm,
-        bpmConfidence: confidence,
+        bpmConfidence: bpm === null ? "uncertain" : confidence >= HIGH_CONFIDENCE ? "high" : "low",
         channelData,
-        sampleRate,
-        peak: gated.peak,
+        sampleRate: signal.sampleRate,
+        peak,
     };
 }
-export async function detectBeatsFromUrl(url) {
-    const audioContext = new AudioContext();
-    try {
-        const response = await fetch(url);
-        const arrayBuffer = await response.arrayBuffer();
-        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
-        return detectBeats(audioBuffer);
-    }
-    finally {
-        await audioContext.close();
-    }
+export function analyzeMusicFromBuffer(audioBuffer, options = {}) {
+    const channels = Array.from({ length: audioBuffer.numberOfChannels }, (_, c) => audioBuffer.getChannelData(c));
+    return analyzeMusicFromSignal({ sampleRate: audioBuffer.sampleRate, channels }, options);
 }
 export async function analyzeMusicFromUrl(url, options = {}) {
     const audioContext = new AudioContext();

package/dist/colorGrading.d.ts

@@ -1,7 +1,7 @@
-import type { HfColorCurvePoint, HfHueCurvePoint } from "./colorGradingCurves";
+import type { HfColorCurvePoint, HfHueCurvePoint } from "./colorGradingCurves.js";
 import { COLOR_GRADING_ADJUST_KEYS, COLOR_GRADING_CURVE_KEYS, COLOR_GRADING_DETAIL_KEYS, COLOR_GRADING_EFFECT_KEYS, COLOR_GRADING_HUE_CURVE_KEYS, COLOR_GRADING_WHEEL_KEYS } from "@hyperframes/parsers/color-grading-contract";
-export type { HfColorCurvePoint, HfHueCurvePoint } from "./colorGradingCurves";
-export { compileHfColorCurve, compileHfHueCurve, HF_COLOR_CURVE_MAX_POINTS, } from "./colorGradingCurves";
+export type { HfColorCurvePoint, HfHueCurvePoint } from "./colorGradingCurves.js";
+export { compileHfColorCurve, compileHfHueCurve, HF_COLOR_CURVE_MAX_POINTS, } from "./colorGradingCurves.js";
 export declare const HF_COLOR_GRADING_ATTR = "data-color-grading";
 /** Set on a graded source while its pixels render on the grading canvas. */
 export declare const COLOR_GRADING_SOURCE_HIDDEN_ATTR = "data-hf-color-grading-source-hidden";

package/dist/compiler/htmlBundler.d.ts

@@ -1,5 +1,5 @@
-export { FLATTENED_INNER_ROOT_STRIP_ATTRS } from "../runtime/flattenedRoot";
-import { type MediaDurationProber } from "./htmlCompiler";
+export { FLATTENED_INNER_ROOT_STRIP_ATTRS } from "../runtime/flattenedRoot.js";
+import { type MediaDurationProber } from "./htmlCompiler.js";
 export type BundledHostCompositionIdentity = {
     authoredCompositionId: string | null;
     runtimeCompositionId: string | null;

package/dist/compiler/index.d.ts

@@ -1,19 +1,19 @@
-export { resolveTimings, type WordTiming, type ElementAnchor, type AuthoredTiming, type ResolvedTiming, type ResolveTimingsInput, type ResolveTimingsResult, } from "./timingResolver";
-export { compileTimingAttrs, injectDurations, extractResolvedMedia, clampDurations, shouldClampMediaDuration, shouldClampResolvedMediaDuration, type UnresolvedElement, type ResolvedDuration, type ResolvedMediaElement, type CompilationResult, } from "./timingCompiler";
-export { compileHtml, type MediaDurationProber } from "./htmlCompiler";
-export { assignBundledRuntimeCompositionIds, type BundledHostCompositionIdentity, bundleToSingleHtml, type BundleOptions, type BundleScriptProvenance, prepareFlattenedInnerRoot, FLATTENED_INNER_ROOT_STRIP_ATTRS, emitRootCompositionVariableStyles, parsesAsScript, } from "./htmlBundler";
-export { readDeclaredDefaults, parseHostVariableValues } from "../runtime/getVariables";
-export { extractCompiledHtmlParityContract, type CompiledHtmlParityContract, type HtmlParityComposition, type HtmlParityResource, type HtmlParityTimedElement, } from "./htmlParityContract";
-export { RUNTIME_BOOTSTRAP_ATTR, injectScriptsAtHeadStart, injectTagsAtHeadStart, injectScriptsIntoHtml, insertBeforeCloseTag, insertRuntimeTag, isRuntimeFileUrl, parseHTMLContent, stripEmbeddedRuntimeScripts, } from "./htmlDocument";
-export { addScenePartsManifest } from "./scenePartsManifest";
-export { AFTER_FONTS_SCRIPT_TYPE, compositionStyle, cssStyleMergeKey, deferScriptsUntilFonts, headStyleRuns, inlineScriptRuns, styleElementsFor, type CompositionStyle, type InlineScriptRun, } from "./scriptRuns";
-export { isJavaScriptType } from "./compositionAssembly";
-export { validateHyperframeHtmlContract, type HyperframeStaticFailureReason, type HyperframeStaticGuardResult, } from "./staticGuard";
-export { buildVariablesByCompScript, scopeCssToComposition, wrapScopedCompositionScript, } from "./compositionScoping";
-export { ensureExternalLinkTag, inlineSubCompositions, type InlineSubCompositionsOptions, type InlineSubCompositionsResult, } from "./inlineSubCompositions";
-export { extractStandaloneEntryFromIndex, isTemplateEntry } from "./standaloneEntry";
-export { checkSubCompositionUsability, type ParsableDocumentLike, type SubCompositionValidity, type SubCompositionValidityReason, } from "./subCompositionValidity";
-export { CSS_URL_RE, PATH_ATTRS, isNonRelativeUrl, isPathInside } from "./assetPaths";
-export { AUDIO_GROUP_RENDER_ID_ATTR, MEDIA_RENDER_ID_ATTR, assignMediaRenderIds, } from "./mediaRenderIds";
-export { ensureExternalScriptTag } from "./externalScripts";
-export { emitMountedModuleScripts } from "./importMaps";
+export { resolveTimings, type WordTiming, type ElementAnchor, type AuthoredTiming, type ResolvedTiming, type ResolveTimingsInput, type ResolveTimingsResult, } from "./timingResolver.js";
+export { compileTimingAttrs, injectDurations, extractResolvedMedia, clampDurations, shouldClampMediaDuration, shouldClampResolvedMediaDuration, type UnresolvedElement, type ResolvedDuration, type ResolvedMediaElement, type CompilationResult, } from "./timingCompiler.js";
+export { compileHtml, type MediaDurationProber } from "./htmlCompiler.js";
+export { assignBundledRuntimeCompositionIds, type BundledHostCompositionIdentity, bundleToSingleHtml, type BundleOptions, type BundleScriptProvenance, prepareFlattenedInnerRoot, FLATTENED_INNER_ROOT_STRIP_ATTRS, emitRootCompositionVariableStyles, parsesAsScript, } from "./htmlBundler.js";
+export { readDeclaredDefaults, parseHostVariableValues } from "../runtime/getVariables.js";
+export { extractCompiledHtmlParityContract, type CompiledHtmlParityContract, type HtmlParityComposition, type HtmlParityResource, type HtmlParityTimedElement, } from "./htmlParityContract.js";
+export { RUNTIME_BOOTSTRAP_ATTR, injectScriptsAtHeadStart, injectTagsAtHeadStart, injectScriptsIntoHtml, insertBeforeCloseTag, insertRuntimeTag, isRuntimeFileUrl, parseHTMLContent, stripEmbeddedRuntimeScripts, } from "./htmlDocument.js";
+export { addScenePartsManifest } from "./scenePartsManifest.js";
+export { AFTER_FONTS_SCRIPT_TYPE, compositionStyle, cssStyleMergeKey, deferScriptsUntilFonts, headStyleRuns, inlineScriptRuns, styleElementsFor, type CompositionStyle, type InlineScriptRun, } from "./scriptRuns.js";
+export { isJavaScriptType } from "./compositionAssembly.js";
+export { validateHyperframeHtmlContract, type HyperframeStaticFailureReason, type HyperframeStaticGuardResult, } from "./staticGuard.js";
+export { buildVariablesByCompScript, scopeCssToComposition, wrapScopedCompositionScript, } from "./compositionScoping.js";
+export { ensureExternalLinkTag, inlineSubCompositions, type InlineSubCompositionsOptions, type InlineSubCompositionsResult, } from "./inlineSubCompositions.js";
+export { extractStandaloneEntryFromIndex, isTemplateEntry } from "./standaloneEntry.js";
+export { checkSubCompositionUsability, type ParsableDocumentLike, type SubCompositionValidity, type SubCompositionValidityReason, } from "./subCompositionValidity.js";
+export { CSS_URL_RE, PATH_ATTRS, isNonRelativeUrl, isPathInside } from "./assetPaths.js";
+export { AUDIO_GROUP_RENDER_ID_ATTR, MEDIA_RENDER_ID_ATTR, assignMediaRenderIds, } from "./mediaRenderIds.js";
+export { ensureExternalScriptTag } from "./externalScripts.js";
+export { emitMountedModuleScripts } from "./importMaps.js";

package/dist/compiler/inlineSubCompositions.d.ts

@@ -1,6 +1,6 @@
-import { type ExternalScriptAttributes } from "./externalScripts";
-import { type ImportMap } from "./importMaps";
-import { type CompositionStyle } from "./scriptRuns";
+import { type ExternalScriptAttributes } from "./externalScripts.js";
+import { type ImportMap } from "./importMaps.js";
+import { type CompositionStyle } from "./scriptRuns.js";
 /**
  * Shared sub-composition inlining logic.
  *
@@ -10,7 +10,7 @@ import { type CompositionStyle } from "./scriptRuns";
  * divergence that previously caused bugs (e.g. producer not setting
  * `data-composition-file`).
  */
-import { type AssetExists } from "./rewriteSubCompPaths";
+import { type AssetExists } from "./rewriteSubCompPaths.js";
 /** Marks each scene whose nodes a script outside it names by selector, id or class: a swap would strand it. */
 export declare function refuseSwapsReachedByRootScripts(document: Document, rootScripts: string[]): void;
 export interface InlineSubCompositionsOptions {

package/dist/compiler/svgIdNamespacing.d.ts

@@ -5,7 +5,7 @@
  * keeps the authored id (otherwise the first element does). Renamed elements retain
  * data-hf-authored-id for script lookup compatibility.
  */
-import { type SvgReferenceAlias } from "./svgSelectorAliases";
+import { type SvgReferenceAlias } from "./svgSelectorAliases.js";
 /** Reused from `compositionScoping.ts`'s `AUTHORED_ROOT_ID_ATTR` in spirit —
  *  same purpose (let a renamed id still resolve by its authored name), now
  *  generalized from "the composition root" to any renamed descendant. */

package/dist/fft.d.ts

@@ -0,0 +1,2 @@
+/** In-place iterative radix-2 FFT. */
+export declare function fft(re: Float64Array, im: Float64Array): void;

package/dist/fft.js

@@ -0,0 +1,36 @@
+/** In-place iterative radix-2 FFT. */
+export function fft(re, im) {
+    const n = re.length;
+    for (let i = 1, j = 0; i < n; i++) {
+        let bit = n >> 1;
+        for (; j & bit; bit >>= 1)
+            j ^= bit;
+        j ^= bit;
+        if (i < j) {
+            [re[i], re[j]] = [re[j], re[i]];
+            [im[i], im[j]] = [im[j], im[i]];
+        }
+    }
+    for (let len = 2; len <= n; len <<= 1) {
+        const ang = (-2 * Math.PI) / len;
+        const wr = Math.cos(ang);
+        const wi = Math.sin(ang);
+        for (let i = 0; i < n; i += len) {
+            let cr = 1;
+            let ci = 0;
+            for (let k = 0; k < len / 2; k++) {
+                const ur = re[i + k];
+                const ui = im[i + k];
+                const vr = re[i + k + len / 2] * cr - im[i + k + len / 2] * ci;
+                const vi = re[i + k + len / 2] * ci + im[i + k + len / 2] * cr;
+                re[i + k] = ur + vr;
+                im[i + k] = ui + vi;
+                re[i + k + len / 2] = ur - vr;
+                im[i + k + len / 2] = ui - vi;
+                const ncr = cr * wr - ci * wi;
+                ci = cr * wi + ci * wr;
+                cr = ncr;
+            }
+        }
+    }
+}

package/dist/figma/assetSnippet.d.ts

@@ -1,2 +1,2 @@
-import type { AssetSnippet, FigmaManifestRecord } from "./types";
+import type { AssetSnippet, FigmaManifestRecord } from "./types.js";
 export declare function buildAssetSnippet(record: FigmaManifestRecord): AssetSnippet;

package/dist/figma/client.d.ts

@@ -1,4 +1,4 @@
-import type { FigmaAssetFormat, FigmaRef } from "./types";
+import type { FigmaAssetFormat, FigmaRef } from "./types.js";
 /** Typed capability/transport failures per design spec §4.4. */
 export type FigmaClientErrorCode = "NO_TOKEN" | "BAD_TOKEN" | "FORBIDDEN" | "REQUIRES_ENTERPRISE" | "RATE_LIMITED" | "RENDER_FAILED" | "NODE_NOT_FOUND" | "HTTP_ERROR";
 export declare class FigmaClientError extends Error {

package/dist/figma/emitTimelineScript.d.ts

@@ -1,2 +1,2 @@
-import type { TimelineSpec } from "./types";
+import type { TimelineSpec } from "./types.js";
 export declare function emitTimelineScript(spec: TimelineSpec): string;