hyperframes 0.8.142 → 0.8.144

package/dist/sherpaWorker.js

@@ -11,10 +11,11 @@ import {
   droppedSpeechGaps,
   silenceCuts,
   spliceGap
-} from "./chunk-KDPYVTEU.js";
+} from "./chunk-KBB4RG6F.js";
 import {
   readWav
 } from "./chunk-UOFAE5RF.js";
+import "./chunk-IR35BCLK.js";
 import "./chunk-M2WBOQ2Q.js";
 
 // src/whisper/sherpaWorker.ts

package/dist/skills/hyperframes-cli/references/doctor-browser.md

@@ -28,7 +28,7 @@ Run `doctor` first when:
 
 Common issues:
 
-- **Missing FFmpeg** — install via `brew install ffmpeg` (macOS) or your package manager.
+- **Missing FFmpeg** — install via `brew install ffmpeg` (macOS) or your package manager, or [configure existing binaries](#configure-ffmpeg-without-a-package-manager).
 - **Missing bundled Chrome** — run `npx hyperframes browser ensure`.
 - **Low memory** — close other Chromes, reduce `--workers`, or use `--quality draft`.
 - **Chrome exits instantly inside an agent sandbox (macOS)** — seatbelt-style sandboxes
@@ -44,6 +44,29 @@ Common issues:
   blocker is identified, BEFORE any optional fallback work: a later session failure must
   not erase the report of work already done.
 
+### Configure FFmpeg without a package manager
+
+Get FFmpeg and FFprobe binaries for your operating system and architecture from the [FFmpeg download page](https://ffmpeg.org/download.html). Both must be executable. You can use them without Homebrew or a system-wide installation:
+
+```bash
+export HYPERFRAMES_FFMPEG_PATH="/absolute/path/to/ffmpeg"
+export HYPERFRAMES_FFPROBE_PATH="/absolute/path/to/ffprobe"
+npx hyperframes doctor --json
+```
+
+Set both variables in the environment that launches HyperFrames. On Windows, point them at `ffmpeg.exe` and `ffprobe.exe` using your shell's environment-variable syntax. A configured path takes precedence over automatic discovery; a missing configured file is reported as missing.
+
+Alternatively, put the binaries in `.hyperframes/bin/ffmpeg` and `.hyperframes/bin/ffprobe` (`.exe` on Windows), then run HyperFrames from that project's directory. Discovery checks `PATH` before this project-local directory, so use the environment variables when you need a particular build.
+
+Verify the **FFmpeg** and **FFprobe** entries in `doctor --json` report `ok: true` and the expected paths. To gate only these encoding dependencies with `jq`:
+
+```bash
+npx hyperframes doctor --json | jq -e \
+  '[.checks[] | select(.name == "FFmpeg" or .name == "FFprobe")] | length == 2 and all(.ok)'
+```
+
+The report's top-level `ok` also includes optional tools such as Docker and local voice providers; those failures do not require installing them for a local video render. Check Chrome separately with the browser commands below.
+
 ## browser
 
 ```bash

package/dist/skills/hyperframes-cli/references/lint-validate-inspect.md

@@ -50,7 +50,7 @@ One command, one Chrome boot. `check` runs the linter first and skips the browse
 
 Every finding carries a selector, the element's `data-*` identity, the composition source file, a bbox, and the sample time: jump straight from the JSON to the HTML you must edit and re-run.
 
-**Severity is persistence-aware.** A dynamic issue observed at a single grid sample (an entrance/exit transient) demotes to info and never gates. Issues held across samples gate the exit code, a held `content_overlap` is an error, and a held, partially-visible `canvas_overflow` breaching ≥5% of the canvas promotes to warning. Coordinate-frame findings (`escaped_container`, `panel_out_of_canvas`, `connector_detached`) flag geometry computed in one frame but rendered in another — an element far outside its offset parent, a painted panel stuck across the canvas edge, a connector line detached from every node. Text drawn into a `<canvas>` has no DOM box, so `canvas_overflow` cannot see it; `canvas_content_at_edge` warns when a canvas's pixels show sharp content (drawn text, hard shapes) along the frame edge — mark intentional full-bleed art (particles, photos) with `data-layout-allow-overflow`. If a 3s+ composition shows no visible change across every sample, `check` fails with `sweep_static`: a frozen timeline makes every green verdict unreliable, so it refuses to pass. When only audio advanced, it warns instead; a composition meant to be still takes `data-no-timeline` on its root. The fingerprint includes per-element opacity, so opacity-only reveals (code typing, staggered fades) count as motion — but only while they're still in flight at the sampled times. The classic trap is a reveal that completes early and then holds a static frame for the rest of the duration: every sample lands on the settled state and the run fails. Spread the reveal across the timeline or keep one continuously animated element alive (a blinking caret is idiomatic for code typing) — don't bolt on a slow position drift just to appease the check.
+**Severity is persistence-aware.** A dynamic issue observed at a single grid sample (an entrance/exit transient) demotes to info and never gates. Issues held across samples gate the exit code, a held `content_overlap` is an error, and a held, partially-visible `canvas_overflow` breaching ≥5% of the canvas promotes to warning. Coordinate-frame findings (`escaped_container`, `panel_out_of_canvas`, `connector_detached`) flag geometry computed in one frame but rendered in another — an element far outside its offset parent, a painted panel stuck across the canvas edge, a connector line detached from every node. Text drawn into a `<canvas>` has no DOM box, so `canvas_overflow` cannot see it; `canvas_content_at_edge` warns when a canvas's pixels show sharp content (drawn text, hard shapes) along the frame edge — mark intentional full-bleed art (particles, photos) with `data-layout-allow-overflow`. If a 3s+ composition shows no visible change across every sample, `check` fails with `sweep_static`: a frame that never changes while a GSAP timeline or tween, or a CSS or Web animation, holds the same time without ever finishing means the seek is not driving the page, so it refuses to pass. Any other frame that never changes (a still title card, an audio-only advance) is a warning that `--strict` fails; a composition meant to be still can take `data-no-timeline` on its root to skip it. The fingerprint includes per-element opacity, so opacity-only reveals (code typing, staggered fades) count as motion — but only while they're still in flight at the sampled times. The classic trap is a reveal that completes early and then holds a static frame for the rest of the duration: every sample lands on the settled state and check warns that nothing on screen moved (`--strict` fails it). Spread the reveal across the timeline or keep one continuously animated element alive (a blinking caret is idiomatic for code typing) — don't bolt on a slow position drift just to appease the check.
 
 **Escape hatches** (mark intent in the HTML, then re-run):
 

package/dist/skills/media-use/scripts/lib/cache.mjs

@@ -1,4 +1,11 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, copyFileSync } from "node:fs";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  copyFileSync,
+  statSync,
+} from "node:fs";
 import { join, basename } from "node:path";
 import { createHash } from "node:crypto";
 import { readManifest, appendRecord, normalizePrompt } from "./manifest.mjs";
@@ -45,9 +52,10 @@ export function findGlobalBySha(shaPrefix) {
     .toLowerCase()
     .trim();
   if (!p) return null;
-  const matches = readGlobalManifest().filter(
+  const matchingRecords = readGlobalManifest().filter(
     (r) => r.reusable && typeof r.sha === "string" && r.sha.startsWith(p),
   );
+  const matches = Array.from(new Map(matchingRecords.map((r) => [r.sha, r])).values());
   if (matches.length === 0) return null;
   if (matches.length > 1) {
     const exact = matches.find((r) => r.sha === p);
@@ -58,27 +66,36 @@ export function findGlobalBySha(shaPrefix) {
 }
 
 function validateCacheHit(match) {
-  if (!match?.sha) return null;
-  return isComplete(cacheEntryDir(globalMediaDir(), match.sha)) ? match : null;
+  if (!match?.sha || !match.cached_path) return null;
+  if (!isComplete(cacheEntryDir(globalMediaDir(), match.sha))) return null;
+  try {
+    const file = statSync(match.cached_path);
+    return file.isFile() && file.size > 0 ? match : null;
+  } catch {
+    return null;
+  }
 }
 
 export function cacheGet(prompt, type) {
   const key = normalizePrompt(prompt);
   if (!key) return null;
-  return validateCacheHit(
+  return (
     readGlobalManifest().find(
       (r) =>
         r.reusable &&
         normalizePrompt(r.provenance?.prompt) === key &&
-        (type == null || r.type === type),
-    ),
+        (type == null || r.type === type) &&
+        validateCacheHit(r),
+    ) ?? null
   );
 }
 
 export function cacheGetByEntity(entity) {
   const lower = entity.toLowerCase();
-  return validateCacheHit(
-    readGlobalManifest().find((r) => r.reusable && r.entity && r.entity.toLowerCase() === lower),
+  return (
+    readGlobalManifest().find(
+      (r) => r.reusable && r.entity && r.entity.toLowerCase() === lower && validateCacheHit(r),
+    ) ?? null
   );
 }
 
@@ -86,7 +103,7 @@ export function cachePut(filePath, record) {
   const sha = contentHash(filePath);
   // Idempotent: same content already promoted -> don't duplicate the global
   // record. ponytail: skips usage_count bump; add it when the metric is needed.
-  const existing = readGlobalManifest().find((r) => r.sha === sha);
+  const existing = readGlobalManifest().findLast((r) => r.sha === sha && validateCacheHit(r));
   if (existing) return { sha, cached_path: existing.cached_path, deduped: true };
 
   const dir = globalMediaDir();
@@ -108,12 +125,9 @@ export function cachePut(filePath, record) {
 }
 
 export function importFromCache(cacheRecord, projectDir, localId, localPath) {
+  if (!validateCacheHit(cacheRecord)) return null;
   const sha = cacheRecord.sha;
-  const entryDir = cacheEntryDir(globalMediaDir(), sha);
-  if (!isComplete(entryDir)) return null;
-
   const cachedFile = cacheRecord.cached_path;
-  if (!cachedFile || !existsSync(cachedFile)) return null;
 
   mkdirSync(join(projectDir, ".media"), { recursive: true });
   const fullDest = join(projectDir, localPath);

package/dist/skills/media-use/scripts/lib/cache.test.mjs

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { appendRecord } from "./manifest.mjs";
+import {
+  cacheGet,
+  cacheGetByEntity,
+  cachePut,
+  findGlobalBySha,
+  importFromCache,
+  readGlobalManifest,
+} from "./cache.mjs";
+
+function sandbox(t) {
+  const root = mkdtempSync(join(tmpdir(), "mu-cache-recovery-"));
+  const previous = process.env.HYPERFRAMES_MEDIA_HOME;
+  process.env.HYPERFRAMES_MEDIA_HOME = join(root, "library");
+  t.after(() => {
+    if (previous === undefined) delete process.env.HYPERFRAMES_MEDIA_HOME;
+    else process.env.HYPERFRAMES_MEDIA_HOME = previous;
+    rmSync(root, { recursive: true, force: true });
+  });
+  const source = join(root, "original.wav");
+  const bytes = "cache recovery fixture";
+  writeFileSync(source, bytes);
+  const record = {
+    id: "bgm_001",
+    type: "bgm",
+    entity: "Recovery",
+    provenance: { prompt: "cache recovery" },
+  };
+  return { root, source, bytes, record };
+}
+
+for (const invalid of [
+  "missing file",
+  "missing marker",
+  "missing directory",
+  "empty file",
+  "directory",
+]) {
+  test(`cachePut repairs a ${invalid} before deduplicating`, (t) => {
+    const { root, source, bytes, record } = sandbox(t);
+    const first = cachePut(source, record);
+    const entry = dirname(first.cached_path);
+    if (invalid === "missing marker") rmSync(join(entry, ".hf-complete"));
+    else if (invalid === "missing directory") rmSync(entry, { recursive: true });
+    else if (invalid === "empty file") writeFileSync(first.cached_path, "");
+    else {
+      rmSync(first.cached_path);
+      if (invalid === "directory") mkdirSync(first.cached_path);
+    }
+
+    const replacement = join(root, "replacement.wav");
+    writeFileSync(replacement, bytes);
+    const repaired = cachePut(replacement, record);
+
+    assert.equal(repaired.deduped, undefined);
+    assert.equal(repaired.sha, first.sha);
+    assert.equal(readFileSync(repaired.cached_path, "utf8"), bytes);
+    const cached = cacheGet("  Cache  Recovery ", "bgm");
+    assert.equal(cached?.sha, repaired.sha);
+    assert.equal(readFileSync(cached.cached_path, "utf8"), bytes);
+    assert.equal(cacheGetByEntity("recovery")?.sha, repaired.sha);
+    const imported = importFromCache(cached, join(root, "project"), "bgm_002", "restored.wav");
+    assert.equal(imported?.provenance.imported_from, first.sha);
+    assert.equal(readFileSync(join(root, "project", "restored.wav"), "utf8"), bytes);
+  });
+}
+
+test("an intact cache stays deduplicated without adding a manifest record", (t) => {
+  const { source, record } = sandbox(t);
+  const first = cachePut(source, record);
+  const second = cachePut(source, record);
+
+  assert.deepEqual(second, { ...first, deduped: true });
+  assert.equal(readGlobalManifest().length, 1);
+});
+
+test("prompt and entity lookups skip a stale entry for another complete match", (t) => {
+  const { root, source, record } = sandbox(t);
+  const first = cachePut(source, record);
+  rmSync(first.cached_path);
+  const secondSource = join(root, "second.wav");
+  writeFileSync(secondSource, "different reusable bytes");
+  const second = cachePut(secondSource, record);
+
+  assert.equal(cacheGet("cache recovery", "bgm")?.sha, second.sha);
+  assert.equal(cacheGetByEntity("RECOVERY")?.sha, second.sha);
+  assert.equal(cacheGet("cache recovery", "sfx"), null);
+});
+
+test("sha reuse counts distinct content and selects the repaired record", (t) => {
+  const { root, source, bytes, record } = sandbox(t);
+  const first = cachePut(source, record);
+  rmSync(first.cached_path);
+  const replacement = join(dirname(first.cached_path), "replacement.wav");
+  writeFileSync(replacement, bytes);
+  appendRecord(join(root, "library"), {
+    ...record,
+    sha: first.sha,
+    reusable: true,
+    cached_path: replacement,
+  });
+
+  assert.equal(findGlobalBySha(first.sha)?.cached_path, replacement);
+  assert.equal(findGlobalBySha(first.sha.slice(0, 16))?.cached_path, replacement);
+});

package/dist/skills/media-use/scripts/lib/duck.mjs

@@ -5,7 +5,7 @@ export function speechSpans(meta, { mergeGap = 0.6, offsets, sequential = false,
   const merge = Number(mergeGap);
   const lists = wordListsFromMediaMeta(meta);
   const voices = Array.isArray(meta?.voices) ? meta.voices : [];
-  if (lists.length > 1 && !offsets && !sequential) {
+  if (lists.filter((words) => words.length > 0).length > 1 && !offsets && !sequential) {
     throw new Error(
       "audio_meta has multiple voice lines with file-relative times; pass --sequential or --offsets so spans land at composition time",
     );
@@ -16,6 +16,7 @@ export function speechSpans(meta, { mergeGap = 0.6, offsets, sequential = false,
     const voice = voices[i];
     let offset = 0;
     if (offsets) {
+      if (lists[i].length === 0) continue;
       const id = voice?.id ?? String(i);
       if (!(id in offsets)) throw new Error(`--offsets is missing voice "${id}"`);
       offset = Number(offsets[id]) || 0;

package/dist/skills/media-use/scripts/lib/duck.test.mjs

@@ -75,6 +75,63 @@ test("speechSpans returns empty spans for empty input", () => {
   assert.deepEqual(speechSpans({ voices: [] }, { mergeGap: 0.6 }), []);
 });
 
+test("speechSpans offsets retain voice IDs across empty transcripts", () => {
+  const meta = {
+    voices: [
+      { id: "silent", duration_s: 2, words: [] },
+      { id: "narration", duration_s: 1, words: [word("w0", "hello", 0.1, 0.9)] },
+    ],
+  };
+  const expected = [{ start: 4.1, end: 4.9 }];
+  assert.deepEqual(speechSpans(meta, { offsets: { silent: 0, narration: 4 } }), expected);
+  assert.deepEqual(speechSpans(meta, { offsets: { narration: 4 } }), expected);
+  assert.throws(() => speechSpans(meta, { offsets: { silent: 0 } }), /missing voice "narration"/);
+});
+
+test("speechSpans sequential counts empty line durations and gaps", () => {
+  const meta = {
+    voices: [
+      { id: "intro", duration_s: 2, words: [] },
+      { id: "first", duration_s: 1, words: [word("w0", "hello", 0.1, 0.9)] },
+      { id: "pause", duration_s: 3, words: [] },
+      { id: "last", duration_s: 1, words: [word("w1", "goodbye", 0.1, 0.9)] },
+    ],
+  };
+  assert.deepEqual(speechSpans(meta, { sequential: true, gap: 0.5 }), [
+    { start: 2.6, end: 3.4 },
+    { start: 7.6, end: 8.4 },
+  ]);
+});
+
+test("speechSpans offsets without IDs retain original voice indices", () => {
+  const meta = {
+    voices: [{ duration_s: 2 }, { duration_s: 1, words: [word("w0", "hello", 0.1, 0.9)] }],
+  };
+  assert.deepEqual(speechSpans(meta, { offsets: { 1: 4 } }), [{ start: 4.1, end: 4.9 }]);
+});
+
+test("speechSpans keeps normalized-empty transcripts aligned with their voices", () => {
+  const meta = {
+    voices: [
+      { id: "untimed", duration_s: 2, words: [{ text: "hello" }] },
+      { id: "narration", duration_s: 1, words: [word("w0", "hello", 0.1, 0.9)] },
+    ],
+  };
+  assert.deepEqual(speechSpans(meta, { sequential: true }), [{ start: 2.1, end: 2.9 }]);
+});
+
+test("speechSpans does not require placement for transcripts without speech", () => {
+  const meta = {
+    voices: [
+      { id: "a", duration_s: 2, words: [] },
+      { id: "b", duration_s: 1 },
+    ],
+  };
+  assert.deepEqual(speechSpans(meta), []);
+  assert.deepEqual(speechSpans(meta, { offsets: {} }), []);
+  assert.deepEqual(speechSpans(meta, { sequential: true }), []);
+});
+
 test("duckKeyframes shapes attack and release from base volume", () => {
   assert.deepEqual(
     duckKeyframes([{ start: 3, end: 5 }], {
@@ -148,6 +205,36 @@ test("--json spans match --merge-gap semantics exactly", () => {
   }
 });
 
+for (const [placement, flags, expected] of [
+  ["sequential", ["--sequential", "--gap", "0.5"], [{ start: 2.6, end: 3.4 }]],
+  ["offsets", ["--offsets", "narration=4"], [{ start: 4.1, end: 4.9 }]],
+]) {
+  test(`audio-duck --json preserves empty voice placement with ${placement}`, (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "media-use-duck-empty-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    const metaPath = join(dir, "audio_meta.json");
+    writeFileSync(
+      metaPath,
+      JSON.stringify({
+        voices: [
+          { id: "silent", duration_s: 2, words: [] },
+          { id: "narration", duration_s: 1, words: [word("w0", "hello", 0.1, 0.9)] },
+        ],
+      }),
+    );
+    const result = JSON.parse(
+      execFileSync(
+        process.execPath,
+        [SCRIPT, "--meta", metaPath, "--target", "#bgm", ...flags, "--json"],
+        { encoding: "utf8" },
+      ),
+    );
+    assert.deepEqual(result.spans, expected);
+    assert.equal(result.keyframes[0].time, expected[0].start);
+    assert.equal(result.lane.lanes[0].points[1].t, expected[0].start);
+  });
+}
+
 function word(id, text, start, end) {
   return { id, text, start, end };
 }

package/dist/skills/media-use/scripts/lib/probe.mjs

@@ -3,6 +3,7 @@ import { extname } from "node:path";
 import { ffprobeBinary } from "./ff-binaries.mjs";
 
 const IMAGE_EXT = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico"]);
+const AUDIO_EXT = new Set([".mp3", ".wav", ".ogg", ".m4a", ".aac"]);
 
 export function probe(filePath) {
   const ext = extname(filePath).toLowerCase();
@@ -18,7 +19,11 @@ export function probe(filePath) {
       { encoding: "utf8", timeout: 5000 },
     );
     const info = JSON.parse(raw);
-    const stream = info.streams?.[0];
+    const streams = info.streams ?? [];
+    const wantedType = AUDIO_EXT.has(ext) ? "audio" : "video";
+    const stream =
+      streams.find((s) => s.codec_type === wantedType && s.disposition?.attached_pic !== 1) ??
+      streams[0];
     const format = info.format;
 
     const isImage = IMAGE_EXT.has(ext);

package/dist/skills/media-use/scripts/lib/probe.test.mjs

@@ -4,6 +4,79 @@ import { chmodSync, mkdtempSync, writeFileSync, existsSync, rmSync } from "node:
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { probe } from "./probe.mjs";
+import childProcess from "node:child_process";
+import { syncBuiltinESMExports } from "node:module";
+
+function mockProbe(t, streams, format = { duration: "2" }) {
+  t.mock.method(childProcess, "execFileSync", () => JSON.stringify({ streams, format }));
+  syncBuiltinESMExports();
+  t.after(() => {
+    t.mock.restoreAll();
+    syncBuiltinESMExports();
+  });
+}
+
+const AUDIO_STREAM = { codec_type: "audio", codec_name: "aac", duration: "3" };
+const VIDEO_STREAM = {
+  codec_type: "video",
+  codec_name: "h264",
+  width: 64,
+  height: 48,
+  duration: "4",
+};
+const COVER_STREAM = {
+  codec_type: "video",
+  codec_name: "mjpeg",
+  width: 100,
+  height: 100,
+  disposition: { attached_pic: 1 },
+};
+
+for (const [name, streams] of [
+  ["audio before video", [AUDIO_STREAM, VIDEO_STREAM]],
+  ["video before audio", [VIDEO_STREAM, AUDIO_STREAM]],
+  ["cover art before video", [COVER_STREAM, AUDIO_STREAM, VIDEO_STREAM]],
+]) {
+  test(`probe selects the video stream with ${name}`, (t) => {
+    mockProbe(t, streams);
+    assert.deepEqual(probe("clip.mp4"), {
+      duration: 2,
+      width: 64,
+      height: 48,
+      codec: "h264",
+    });
+  });
+}
+
+test("probe selects audio metadata for an audio file with cover art", (t) => {
+  mockProbe(t, [COVER_STREAM, AUDIO_STREAM]);
+  assert.deepEqual(probe("song.m4a"), { duration: 2, width: null, height: null, codec: "aac" });
+});
+
+test("probe uses the selected video's duration when the container has none", (t) => {
+  mockProbe(t, [AUDIO_STREAM, VIDEO_STREAM], {});
+  assert.equal(probe("clip.mp4").duration, 4);
+});
+
+test("probe selects image dimensions without reporting an image duration", (t) => {
+  mockProbe(t, [AUDIO_STREAM, VIDEO_STREAM]);
+  assert.deepEqual(probe("frame.png"), {
+    duration: null,
+    width: 64,
+    height: 48,
+    codec: "h264",
+  });
+});
+
+test("probe retains audio-only metadata and the empty-stream fallback", (t) => {
+  mockProbe(t, [AUDIO_STREAM]);
+  assert.deepEqual(probe("clip.mp4"), { duration: 2, width: null, height: null, codec: "aac" });
+});
+
+test("probe retains the container duration when no streams are reported", (t) => {
+  mockProbe(t, []);
+  assert.deepEqual(probe("clip.mp4"), { duration: 2, width: null, height: null, codec: null });
+});
 
 // Regression for the shell-injection fix: probe() must pass the path as a literal
 // argv entry, never through a shell. A filename containing shell metacharacters

package/dist/skills/media-use/scripts/lib/words.mjs

@@ -14,5 +14,5 @@ export function normalizeWords(input) {
 export function wordListsFromMediaMeta(input) {
   if (Array.isArray(input) || Array.isArray(input?.words)) return [normalizeWords(input)];
   if (!Array.isArray(input?.voices)) return [];
-  return input.voices.map((voice) => normalizeWords(voice)).filter((words) => words.length > 0);
+  return input.voices.map((voice) => normalizeWords(voice));
 }

package/dist/{skills-CZHVAD3J.js → skills-VENERS5X.js}

@@ -9,8 +9,8 @@ import {
 } from "./chunk-6BEFEWFB.js";
 import {
   trackSkillsInstallSkipped
-} from "./chunk-XGMNQQTJ.js";
-import "./chunk-LBKDQKWV.js";
+} from "./chunk-RG3QWWIE.js";
+import "./chunk-XU5GGV6R.js";
 import {
   diag
 } from "./chunk-VWG7OQKU.js";
@@ -39,15 +39,15 @@ import {
   isCoreSkill,
   presentSkills,
   pruneOrphanedLockEntries
-} from "./chunk-FZK35GT4.js";
+} from "./chunk-5HJ343GH.js";
 import {
   withMeta
-} from "./chunk-JLKMWY2T.js";
+} from "./chunk-P6WH6QTV.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-DZEVA7DI.js";
+import "./chunk-4OC7MQNB.js";
 import "./chunk-KNU5COPB.js";
 import {
   c
@@ -180,8 +180,8 @@ function pathsOverlap(left, right) {
 }
 function sameExistingNode(left, right) {
   try {
-    const leftStat = statSync(left);
-    const rightStat = statSync(right);
+    const leftStat = statSync(left, { bigint: true });
+    const rightStat = statSync(right, { bigint: true });
     return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
   } catch {
     return false;

package/dist/{skillsUpdateCheck-6WLLX53A.js → skillsUpdateCheck-UXFYTACG.js}

@@ -9,13 +9,13 @@ import {
   printSkillsUpdateNotice,
   refreshSkillsCache,
   skillsCheckDue
-} from "./chunk-FZK35GT4.js";
-import "./chunk-JLKMWY2T.js";
+} from "./chunk-5HJ343GH.js";
+import "./chunk-P6WH6QTV.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-DZEVA7DI.js";
+import "./chunk-4OC7MQNB.js";
 import "./chunk-KNU5COPB.js";
 import "./chunk-M2WBOQ2Q.js";
 export {

package/dist/{slideshow-EJ4IMY6P.js → slideshow-4OJEPWNZ.js}

@@ -12,7 +12,7 @@ import {
   parseSlideshowManifest,
   resolveSlideshow,
   slideshowIslandRegex
-} from "./chunk-PMRBLBUP.js";
+} from "./chunk-T42U2W2R.js";
 import "./chunk-M2WBOQ2Q.js";
 export {
   SLIDESHOW_ISLAND_TYPE,