@anvpx/motion-build 0.0.0-stage → 0.1.1

package/dist/.out/demo-overlays/scenes/count/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountTimeline } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountTimeline(root, config, ctx, { baseDelay: 0.2, staggerFrames: 4, rise: 56 });
+}

package/dist/.out/demo-overlays/scenes/flow-progress/scene.js

@@ -0,0 +1,17 @@
+// @ts-check
+import { mountOverlay } from "../../runtime/mount.js";
+import { spanProgress } from "../../runtime/timeline.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    const track = /** @type {HTMLElement} */ (root.querySelector("[data-from]"));
+    const fill = /** @type {HTMLElement} */ (root.querySelector(".mk-fill"));
+    const from = Number(track.dataset.from);
+    const to = Number(track.dataset.to);
+    const duration = ctx.duration ?? Number(root.dataset.duration);
+    return mountOverlay(root, config, ctx, { baseDelay: 0, staggerFrames: 3, rise: 0 }, {
+        update: (t) => {
+            fill.style.transform = `scaleX(${spanProgress(t, duration, from, to)})`;
+        },
+        reset: () => fill.style.removeProperty("transform"),
+    });
+}

package/dist/.out/demo-overlays/scenes/intro/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountTimeline } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountTimeline(root, config, ctx, { baseDelay: 0.3, staggerFrames: 6, rise: 48 });
+}

package/dist/.out/demo-overlays/scenes/mark/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountOverlay } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountOverlay(root, config, ctx, { baseDelay: 0.1, staggerFrames: 4, rise: 0 });
+}

package/dist/.out/demo-overlays/scenes/outro/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountTimeline } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountTimeline(root, config, ctx, { baseDelay: 0.3, staggerFrames: 6, rise: 32 });
+}

package/dist/.out/demo-overlays/scenes/path/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountTimeline } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountTimeline(root, config, ctx, { baseDelay: 0.2, staggerFrames: 6, rise: 24 });
+}

package/dist/.out/demo-overlays/scenes/presenter/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountOverlay } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountOverlay(root, config, ctx, { baseDelay: 0.1, staggerFrames: 5, rise: 40 });
+}

package/dist/.out/demo-overlays/scenes/signals/scene.js

@@ -0,0 +1,6 @@
+// @ts-check
+import { mountTimeline } from "../../runtime/mount.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    return mountTimeline(root, config, ctx, { baseDelay: 0.2, staggerFrames: 5, rise: 32 });
+}

package/dist/.out/demo-overlays/scenes/tick/scene.js

@@ -0,0 +1,21 @@
+// @ts-check
+import { mountOverlay } from "../../runtime/mount.js";
+import { countdownState } from "../../runtime/timeline.js";
+/** @type {import("../../runtime/mount.js").CreateScene} */
+export function createScene(root, config, ctx) {
+    const number = /** @type {HTMLElement} */ (root.querySelector("[data-from]"));
+    const from = Number(number.dataset.from);
+    const to = Number(number.dataset.to);
+    const duration = ctx.duration ?? Number(root.dataset.duration);
+    return mountOverlay(root, config, ctx, { baseDelay: 0, staggerFrames: 3, rise: 0 }, {
+        update: (t) => {
+            const state = countdownState(t, duration, from, to);
+            number.textContent = String(state.value);
+            number.style.transform = `scale(${state.scale})`;
+        },
+        reset: () => {
+            number.textContent = String(from);
+            number.style.removeProperty("transform");
+        },
+    });
+}

package/dist/.out/demo-overlays/shared/format.js

@@ -0,0 +1,59 @@
+// @ts-check
+// Locale-free, deterministic number formatting for tabular numerals (no Intl, no toLocaleString).
+const MINUS = "−";
+const TIERS = ["", "K", "M", "B", "T"];
+/**
+ * @typedef {object} FmtOpts
+ * @property {string} [unit] "$", "€", "£", "¥" prefix; anything else is appended ("%", " km")
+ * @property {number} [decimals] fixed decimals (default 0; 1 when compact above 1000)
+ * @property {boolean} [sign] show "+" for positive values
+ * @property {boolean} [compact] K / M / B / T suffix
+ */
+/** @param {string} digits */
+const group = (digits) => digits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+/**
+ * @param {number} abs
+ * @param {number} decimals
+ * @returns {string}
+ */
+const fixed = (abs, decimals) => {
+    const [int = "0", frac] = abs.toFixed(decimals).split(".");
+    return frac === undefined ? group(int) : `${group(int)}.${frac}`;
+};
+/**
+ * @param {number} abs
+ * @param {number | undefined} decimals
+ * @returns {string}
+ */
+const compactBody = (abs, decimals) => {
+    let tier = 0;
+    let scaled = abs;
+    while (scaled >= 1000 && tier < TIERS.length - 1) {
+        scaled /= 1000;
+        tier++;
+    }
+    const d = decimals ?? (tier === 0 ? 0 : 1);
+    // rounding can reach 1000 of this tier (999.95K -> 1000.0K): promote once
+    if (tier < TIERS.length - 1 && Number(scaled.toFixed(d)) >= 1000) {
+        scaled /= 1000;
+        tier++;
+    }
+    return `${fixed(scaled, d)}${TIERS[tier]}`;
+};
+/** @param {string} unit */
+const isPrefix = (unit) => /^[$€£¥]/.test(unit);
+/**
+ * @param {number} value
+ * @param {FmtOpts} [opts]
+ * @returns {string}
+ */
+export const fmt = (value, opts = {}) => {
+    if (!Number.isFinite(value))
+        throw new RangeError(`fmt: value must be finite, got ${value}`);
+    const { unit = "", decimals, sign = false, compact = false } = opts;
+    const abs = Math.abs(value);
+    const body = compact ? compactBody(abs, decimals) : fixed(abs, decimals ?? 0);
+    const zero = Number(body.replace(/[^0-9.]/g, "")) === 0;
+    const mark = zero ? "" : value < 0 ? MINUS : sign ? "+" : "";
+    return isPrefix(unit) ? `${mark}${unit}${body}` : `${mark}${body}${unit}`;
+};

package/dist/.out/demo-overlays/shared/motion.js

@@ -0,0 +1,117 @@
+// @ts-check
+// Pure motion helpers shared by scenes. No DOM, no clock, no state: the same inputs always give
+// the same outputs. One implementation serves emit time (TS) and the browser seek runtime.
+import { clamp01, ease } from "../runtime/easing.js";
+/** Smallest / largest fraction of an item's duration shared with the next item in a stagger. */
+export const MIN_OVERLAP = 0.05;
+export const MAX_OVERLAP = 0.9;
+/**
+ * @param {number} v
+ * @param {number} lo
+ * @param {number} hi
+ * @returns {number}
+ */
+export const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} p
+ * @returns {number}
+ */
+export const lerp = (a, b, p) => a + (b - a) * p;
+/** Linear map of `v` from [inMin, inMax] to [outMin, outMax], clamped to the input range.
+ * @param {number} v
+ * @param {number} inMin
+ * @param {number} inMax
+ * @param {number} outMin
+ * @param {number} outMax
+ * @returns {number}
+ */
+export const scale = (v, inMin, inMax, outMin, outMax) => lerp(outMin, outMax, inMax === inMin ? (v >= inMax ? 1 : 0) : clamp01((v - inMin) / (inMax - inMin)));
+/** Monotone 0..1 progress of `t` through [start, end]; a zero-length window is a step.
+ * @param {number} t
+ * @param {number} start
+ * @param {number} end
+ * @returns {number}
+ */
+export const progress = (t, start, end) => end > start ? clamp01((t - start) / (end - start)) : t >= start ? 1 : 0;
+/**
+ * @param {number} n
+ * @param {number} span
+ * @returns {void}
+ */
+const assertStagger = (n, span) => {
+    if (!Number.isInteger(n) || n < 1)
+        throw new RangeError(`stagger: n must be an integer >= 1, got ${n}`);
+    if (!(span > 0) || !Number.isFinite(span))
+        throw new RangeError(`stagger: span must be > 0, got ${span}`);
+};
+/** @param {number} overlap */
+const overlapOf = (overlap) => clamp(Number.isFinite(overlap) ? overlap : 0, MIN_OVERLAP, MAX_OVERLAP);
+/**
+ * Duration of each item when `n` items share `span` seconds and overlap by `overlap` (a fraction of
+ * the item duration, clamped to [0.05, 0.9]). The last item ends exactly at `span`.
+ * @param {number} n
+ * @param {number} span
+ * @param {number} overlap
+ * @returns {number}
+ */
+export const staggerDuration = (n, span, overlap) => {
+    assertStagger(n, span);
+    return span / (1 + (n - 1) * (1 - overlapOf(overlap)));
+};
+/**
+ * Start time of item `i` (0-based). Offset between items is always smaller than an item's duration.
+ * @param {number} i
+ * @param {number} n
+ * @param {number} span
+ * @param {number} overlap
+ * @returns {number}
+ */
+export const staggerStart = (i, n, span, overlap) => i * staggerDuration(n, span, overlap) * (1 - overlapOf(overlap));
+/**
+ * Count from `from` (default 0) to `value`, easing out; exact at the end.
+ * @param {number} t
+ * @param {number} value
+ * @param {{ from?: number, start?: number, dur?: number }} [opts]
+ * @returns {number}
+ */
+export const countUp = (t, value, opts = {}) => {
+    const { from = 0, start = 0, dur = 1 } = opts;
+    const p = progress(t, start, start + dur);
+    return p >= 1 ? value : lerp(from, value, ease("out", p));
+};
+/** Stroke-dashoffset that draws a path of length `len` on as `p` goes 0..1.
+ * @param {number} len
+ * @param {number} p
+ * @returns {number}
+ */
+export const drawOn = (len, p) => len * (1 - clamp01(p));
+/** Left-to-right clip-path reveal; `p` 0..1.
+ * @param {number} p
+ * @returns {string}
+ */
+export const wipe = (p) => `inset(0 ${Math.round((1 - clamp01(p)) * 100000) / 1000}% 0 0)`;
+/**
+ * Word-by-word timings: `n` words spread over `span` seconds with `overlap` between neighbours.
+ * @param {number} n
+ * @param {number} span
+ * @param {number} [overlap]
+ * @returns {{ start: number, end: number }[]}
+ */
+export const revealTimings = (n, span, overlap = 0.5) => {
+    const dur = staggerDuration(n, span, overlap);
+    return Array.from({ length: n }, (_, i) => {
+        const start = staggerStart(i, n, span, overlap);
+        return { start, end: i === n - 1 ? span : start + dur };
+    });
+};
+/**
+ * Eased 0..1 progress of each of `n` words at time `t`.
+ * @param {number} n
+ * @param {number} t
+ * @param {number} span
+ * @param {number} [overlap]
+ * @returns {number[]}
+ */
+export const revealProgress = (n, t, span, overlap = 0.5) => revealTimings(n, span, overlap).map(({ start, end }) => ease("out", progress(t, start, end)));

package/dist/assets.d.ts

@@ -0,0 +1,36 @@
+import type { AssetLedger, AssetRow, ValidationError } from "@anvpx/motion-schema";
+export interface CopiedAsset {
+    /** Project-relative output path, e.g. `assets/logo.svg`. */
+    readonly path: string;
+    readonly bytes: Uint8Array;
+    readonly sha256: string;
+}
+export interface AssetCollector {
+    /** The `assetResolver` handed to scene plugins; throws on an invalid ref. */
+    readonly resolver: (ref: string) => string;
+    /** Distinct refs requested so far, in first-use order. */
+    readonly refs: () => string[];
+}
+export declare const sha256Of: (data: Uint8Array | string) => string;
+/**
+ * RA-01: snapshot bytes so that a source edit landing after the copy cannot
+ * change the media the HyperFrames project embeds. `copyOne` freezes every
+ * copied asset through here.
+ */
+export declare const freezeBytes: (data: Uint8Array) => Uint8Array;
+/** Normalises a ref to a forward-slash relative path or throws a fixable error. */
+export declare const normaliseRef: (ref: string) => string;
+export declare const createAssetCollector: (hasAssetsDir: boolean) => AssetCollector;
+/** Content hash of an asset, or a non-hex marker when it is absent or escapes the assets dir. */
+export declare const hashAsset: (assetsDir: string | undefined, ref: string) => string;
+export type CopyResult = {
+    readonly ok: true;
+    readonly assets: readonly CopiedAsset[];
+    /** One licence row per copied asset, keyed by its output path, sorted. */
+    readonly licences: readonly AssetRow[];
+} | {
+    readonly ok: false;
+    readonly errors: readonly ValidationError[];
+};
+/** Reads each ref from assetsDir, hashes it and requires a ledger row whose sha256 matches. */
+export declare const copyAssets: (refs: readonly string[], assetsDir: string | undefined, ledger: AssetLedger | undefined) => CopyResult;

package/dist/assets.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+const BAD_REF = /^(?:[a-zA-Z]:|\\|\/|[a-zA-Z][a-zA-Z0-9+.-]*:)/;
+export const sha256Of = (data) => createHash("sha256").update(data).digest("hex");
+/**
+ * RA-01: snapshot bytes so that a source edit landing after the copy cannot
+ * change the media the HyperFrames project embeds. `copyOne` freezes every
+ * copied asset through here.
+ */
+export const freezeBytes = (data) => data.slice();
+/** Normalises a ref to a forward-slash relative path or throws a fixable error. */
+export const normaliseRef = (ref) => {
+    if (BAD_REF.test(ref) || isAbsolute(ref)) {
+        throw new Error(`asset "${ref}" must be a relative path inside the assets dir`);
+    }
+    const parts = ref.replaceAll("\\", "/").split("/");
+    if (parts.some((part) => part === ".." || part === "")) {
+        throw new Error(`asset "${ref}" must not contain ".." or empty segments`);
+    }
+    return parts.filter((part) => part !== ".").join("/");
+};
+export const createAssetCollector = (hasAssetsDir) => {
+    const seen = [];
+    const resolver = (ref) => {
+        if (!hasAssetsDir)
+            throw new Error(`asset "${ref}" requested but no assetsDir was given`);
+        const clean = normaliseRef(ref);
+        if (!seen.includes(clean))
+            seen.push(clean);
+        return `assets/${clean}`;
+    };
+    return { resolver, refs: () => [...seen] };
+};
+const insideDir = (root, target) => {
+    const rel = relative(root, target);
+    return rel !== "" && rel.split(sep)[0] !== ".." && !isAbsolute(rel);
+};
+const failure = (ref, message, suggestion) => ({
+    path: `/assets/${ref}`,
+    message,
+    ...(suggestion === undefined ? {} : { suggestion }),
+});
+const readInside = (assetsDir, ref) => {
+    try {
+        const real = realpathSync(resolve(assetsDir, ref));
+        if (!insideDir(realpathSync(assetsDir), real)) {
+            return failure(ref, "resolves outside the assets dir", "keep assets inside assetsDir");
+        }
+        return readFileSync(real);
+    }
+    catch {
+        return failure(ref, "file not found", `add ${ref} under the assets dir`);
+    }
+};
+/** Content hash of an asset, or a non-hex marker when it is absent or escapes the assets dir. */
+export const hashAsset = (assetsDir, ref) => {
+    const read = assetsDir === undefined ? undefined : readInside(assetsDir, ref);
+    return read instanceof Uint8Array ? sha256Of(read) : "missing";
+};
+const NO_ROW_HINT = (ref) => `add a row for "${ref}" (licence, sourceUrl, sha256; attribution when the licence needs it) to the asset ledger: pass it with --ledger <assets.json> or add it to the storyboard's assets ledger`;
+/** The ledger row for a copied asset, or why there is none; every asset needs one. */
+const ledgerRow = (ref, sha256, ledger) => {
+    const row = ledger?.find((candidate) => candidate.path === ref);
+    if (!row)
+        return failure(ref, "no ledger row", NO_ROW_HINT(ref));
+    return row.sha256 === sha256
+        ? row
+        : failure(ref, "sha256 differs from the ledger row", "update the ledger or restore the file");
+};
+const copyOne = (ref, assetsDir, ledger) => {
+    const read = assetsDir === undefined ? failure(ref, "no assetsDir given") : readInside(assetsDir, ref);
+    if (!(read instanceof Uint8Array))
+        return read;
+    const sha256 = sha256Of(read);
+    const row = ledgerRow(ref, sha256, ledger);
+    if (!("sourceUrl" in row))
+        return row;
+    const path = `assets/${ref}`;
+    return { asset: { path, bytes: freezeBytes(read), sha256 }, licence: { ...row, path } };
+};
+const isCopied = (result) => "asset" in result;
+/** Reads each ref from assetsDir, hashes it and requires a ledger row whose sha256 matches. */
+export const copyAssets = (refs, assetsDir, ledger) => {
+    const results = refs.map((ref) => copyOne(ref, assetsDir, ledger));
+    const errors = results.filter((result) => !isCopied(result));
+    if (errors.length > 0)
+        return { ok: false, errors };
+    const copied = results.filter(isCopied);
+    return {
+        ok: true,
+        assets: copied.map(({ asset }) => asset),
+        licences: copied.map(({ licence }) => licence).sort((a, b) => (a.path < b.path ? -1 : 1)),
+    };
+};

package/dist/audio/approval.d.ts

@@ -0,0 +1,45 @@
+import { type MusicIdentity } from "./music.ts";
+/**
+ * T-AU-01b approval authority (current-only, pure).
+ *
+ * The frozen copied bed is the single authority preview and render consume:
+ * after the entry gate the CLI copies every narration wav plus the bed wav
+ * into one frozen directory and mixes only from those copies (ABA-proof).
+ * These helpers decide whether that frozen state still matches the approved
+ * identity. Any mismatch means re-preview + re-approve (fail closed, never
+ * a silent mix). No timestamps or machine paths enter the identity.
+ */
+/** Diff a previewed identity against the current one; non-empty means reapproval. */
+export declare const needsReapproval: (approved: MusicIdentity, current: MusicIdentity) => string[];
+/**
+ * Verify frozen bytes against the pinned identity. Non-empty means refuse to
+ * mix (fail closed): a mutated bed sha — including an ABA restore of the
+ * mutable source after the freeze — still fails unless the frozen copy
+ * consumed by ffmpeg matches the identity. Silent (EMPTY_SHA256) and
+ * missing (undefined) frozen beds are never audible proof. Machine identity
+ * in paths (absolute/traversal/non-wav) is rejected via the identity check.
+ */
+export declare const verifyFrozenApproval: (identity: MusicIdentity, frozenBedSha256: string | undefined, frozenLicenceSha256: string | null | undefined) => string[];
+/** Throw on any frozen-approval problem (mutation/silent/missing/path → fail). */
+export declare const assertFrozenApproval: (identity: MusicIdentity, frozenBedSha256: string | undefined, frozenLicenceSha256: string | null | undefined) => void;
+/** True only when the current identity matches the approval and frozen bytes match. */
+export declare const isApprovalCurrent: (approved: MusicIdentity, current: MusicIdentity, frozenBedSha256: string | undefined, frozenLicenceSha256: string | null | undefined) => boolean;
+/**
+ * One frozen copy after the CLI wrote it: what actually landed on disk, and -
+ * for a gated run - the digest the approval certified. `expectedSha256` is
+ * absent on the ungated path, where there is no approval to compare against.
+ */
+export interface FrozenCopyCheck {
+    readonly label: string;
+    readonly actualSha256: string | undefined;
+    readonly expectedSha256?: string | undefined;
+}
+/**
+ * ADR-0008 D2: the bytes ffmpeg consumes must be the bytes a person approved.
+ * Hashing the mutable source after the mix cannot prove that (an ABA edit is
+ * restored before the recheck), so the copied file is hashed and compared with
+ * the approved digest captured before it was copied. Non-empty means refuse
+ * before any external tool runs: missing, silent or mismatched copies are never
+ * an approved mix.
+ */
+export declare const frozenCopyProblems: (checks: readonly FrozenCopyCheck[]) => string[];

package/dist/audio/approval.js

@@ -0,0 +1,82 @@
+import { verifyFrozenMusic } from "./mix.js";
+import { EMPTY_SHA256, verifyMusicIdentity } from "./music.js";
+/**
+ * T-AU-01b approval authority (current-only, pure).
+ *
+ * The frozen copied bed is the single authority preview and render consume:
+ * after the entry gate the CLI copies every narration wav plus the bed wav
+ * into one frozen directory and mixes only from those copies (ABA-proof).
+ * These helpers decide whether that frozen state still matches the approved
+ * identity. Any mismatch means re-preview + re-approve (fail closed, never
+ * a silent mix). No timestamps or machine paths enter the identity.
+ */
+/** Diff a previewed identity against the current one; non-empty means reapproval. */
+export const needsReapproval = (approved, current) => {
+    const problems = [];
+    if (current.relativePath !== approved.relativePath) {
+        problems.push(`music bed path changed: was "${approved.relativePath}", now "${current.relativePath}"`);
+    }
+    if (current.sha256 !== approved.sha256) {
+        problems.push(`music bed sha256 differs for "${current.relativePath}"`);
+    }
+    if (current.volume !== approved.volume) {
+        problems.push(`music bed volume changed for "${current.relativePath}": was ${approved.volume}, now ${current.volume}`);
+    }
+    if (current.licenceEvidenceSha256 !== approved.licenceEvidenceSha256) {
+        problems.push(`music licence evidence sha256 differs for "${current.relativePath}"`);
+    }
+    return problems;
+};
+/**
+ * Verify frozen bytes against the pinned identity. Non-empty means refuse to
+ * mix (fail closed): a mutated bed sha — including an ABA restore of the
+ * mutable source after the freeze — still fails unless the frozen copy
+ * consumed by ffmpeg matches the identity. Silent (EMPTY_SHA256) and
+ * missing (undefined) frozen beds are never audible proof. Machine identity
+ * in paths (absolute/traversal/non-wav) is rejected via the identity check.
+ */
+export const verifyFrozenApproval = (identity, frozenBedSha256, frozenLicenceSha256) => {
+    if (frozenBedSha256 === undefined) {
+        return [`music bed wav unreadable: ${identity.relativePath}`];
+    }
+    if (frozenBedSha256 === EMPTY_SHA256) {
+        return [`music bed wav is silent/empty: ${identity.relativePath}`];
+    }
+    return verifyFrozenMusic(identity, frozenBedSha256, frozenLicenceSha256);
+};
+/** Throw on any frozen-approval problem (mutation/silent/missing/path → fail). */
+export const assertFrozenApproval = (identity, frozenBedSha256, frozenLicenceSha256) => {
+    const problems = verifyFrozenApproval(identity, frozenBedSha256, frozenLicenceSha256);
+    if (problems.length > 0) {
+        throw new Error(`unapproved music bed: ${problems.join("; ")}`);
+    }
+    // Belt-and-braces: the identity shape itself must be project-local.
+    const shape = verifyMusicIdentity(identity, identity.sha256, identity.licenceEvidenceSha256);
+    const bad = shape.filter((problem) => !problem.includes("unreadable"));
+    if (bad.length > 0) {
+        throw new Error(`invalid music identity: ${bad.join("; ")}`);
+    }
+};
+/** True only when the current identity matches the approval and frozen bytes match. */
+export const isApprovalCurrent = (approved, current, frozenBedSha256, frozenLicenceSha256) => needsReapproval(approved, current).length === 0 &&
+    verifyFrozenApproval(current, frozenBedSha256, frozenLicenceSha256).length === 0;
+/**
+ * ADR-0008 D2: the bytes ffmpeg consumes must be the bytes a person approved.
+ * Hashing the mutable source after the mix cannot prove that (an ABA edit is
+ * restored before the recheck), so the copied file is hashed and compared with
+ * the approved digest captured before it was copied. Non-empty means refuse
+ * before any external tool runs: missing, silent or mismatched copies are never
+ * an approved mix.
+ */
+export const frozenCopyProblems = (checks) => checks.flatMap((check) => {
+    if (check.actualSha256 === undefined) {
+        return [`${check.label}: frozen copy missing or unreadable`];
+    }
+    if (check.actualSha256 === EMPTY_SHA256) {
+        return [`${check.label}: frozen copy is silent/empty`];
+    }
+    if (check.expectedSha256 !== undefined && check.actualSha256 !== check.expectedSha256) {
+        return [`${check.label}: frozen copy differs from the approved bytes`];
+    }
+    return [];
+});