dsh-hyperframes 0.3.1 → 0.4.0

package/skills/media-use/scripts/lib/cutlist.test.mjs

@@ -1,148 +0,0 @@
-import { strict as assert } from "node:assert";
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { test } from "node:test";
-import { compileCutList } from "./cutlist.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SCRIPT = join(HERE, "..", "transcript-cut.mjs");
-
-test("explicit --remove ranges invert to kept segments", () => {
-  const transcript = [
-    word("w0", "alpha", 0, 1),
-    word("w1", "beta", 1.2, 2),
-    word("w2", "gamma", 2.2, 5),
-  ];
-
-  assert.deepEqual(compileCutList(transcript, { remove: "1-2.5" }), [
-    { start: 0, end: 1 },
-    { start: 2.5, end: 5 },
-  ]);
-});
-
-test("--remove-words resolves inclusive word-index ranges to time ranges", () => {
-  const transcript = [
-    word("w0", "zero", 0, 0.5),
-    word("w1", "one", 0.6, 1),
-    word("w2", "two", 1.1, 1.5),
-    word("w3", "three", 2, 3),
-  ];
-
-  assert.deepEqual(compileCutList(transcript, { removeWords: "1-2" }), [
-    { start: 0, end: 0.6 },
-    { start: 1.5, end: 3 },
-  ]);
-});
-
-test("--remove-fillers drops case-insensitive matching words", () => {
-  const transcript = [
-    word("w0", "Hello", 0, 0.5),
-    word("w1", "Um", 0.5, 0.7),
-    word("w2", "world", 0.8, 1.2),
-    word("w3", "LIKE", 1.3, 1.5),
-    word("w4", "done", 1.6, 2),
-  ];
-
-  assert.deepEqual(compileCutList(transcript, { removeFillers: "um,like" }), [
-    { start: 0, end: 0.5 },
-    { start: 0.7, end: 1.3 },
-    { start: 1.5, end: 2 },
-  ]);
-});
-
-test("--cut-silence removes only the center of long inter-word gaps", () => {
-  const transcript = [word("w0", "a", 0, 0.5), word("w1", "b", 2, 2.5), word("w2", "c", 2.7, 3)];
-
-  assert.deepEqual(compileCutList(transcript, { cutSilence: 0.8 }), [
-    { start: 0, end: 0.65 },
-    { start: 1.85, end: 3 },
-  ]);
-});
-
-test("overlapping removal sources merge before inversion", () => {
-  const transcript = [
-    word("w0", "start", 0, 0.5),
-    word("w1", "um", 0.9, 1.1),
-    word("w2", "middle", 2.5, 2.8),
-    word("w3", "more", 3.1, 3.4),
-    word("w4", "end", 5.5, 6),
-  ];
-
-  assert.deepEqual(
-    compileCutList(transcript, {
-      remove: "1-2.7",
-      removeWords: "2-3",
-      removeFillers: "um",
-    }),
-    [
-      { start: 0, end: 0.9 },
-      { start: 3.4, end: 6 },
-    ],
-  );
-});
-
-test("kept slivers shorter than 0.2s are dropped", () => {
-  const transcript = [word("w0", "start", 0, 0.5), word("w1", "end", 2.5, 3)];
-
-  assert.deepEqual(compileCutList(transcript, { remove: "0.1-2.95" }), []);
-});
-
-test("--keep is inverse mode and coalesces direct kept ranges", () => {
-  const transcript = [word("w0", "start", 0, 0.5), word("w1", "end", 4.5, 5)];
-
-  assert.deepEqual(compileCutList(transcript, { keep: "3-4,1-2,1.5-2.5,4.1-4.2" }), [
-    { start: 1, end: 2.5 },
-    { start: 3, end: 4 },
-  ]);
-});
-
-test("--plan on a fixture transcript prints the exact segment JSON", () => {
-  const dir = mkdtempSync(join(tmpdir(), "media-use-cutlist-"));
-  try {
-    const transcriptPath = join(dir, "fixture.json");
-    writeFileSync(
-      transcriptPath,
-      JSON.stringify([
-        word("w0", "hello", 0, 0.4),
-        word("w1", "um", 0.5, 0.65),
-        word("w2", "there", 0.7, 1),
-        word("w3", "pause", 2.2, 2.5),
-        word("w4", "end", 2.7, 3.2),
-      ]),
-    );
-
-    const out = execFileSync(
-      process.execPath,
-      [
-        SCRIPT,
-        "--input",
-        "ignored.mp4",
-        "--transcript",
-        transcriptPath,
-        "--remove",
-        "0.9-1.2",
-        "--remove-fillers",
-        "um",
-        "--cut-silence",
-        "0.8",
-        "--plan",
-      ],
-      { encoding: "utf8" },
-    );
-
-    assert.deepEqual(JSON.parse(out), [
-      { start: 0, end: 0.5 },
-      { start: 0.65, end: 0.9 },
-      { start: 2.05, end: 3.2 },
-    ]);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-function word(id, text, start, end) {
-  return { id, text, start, end };
-}

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

@@ -1,118 +0,0 @@
-import { strict as assert } from "node:assert";
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { test } from "node:test";
-import { duckKeyframes, speechSpans } from "./duck.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SCRIPT = join(HERE, "..", "audio-duck.mjs");
-
-test("speechSpans bridges gaps smaller than mergeGap", () => {
-  const meta = {
-    words: [word("w0", "one", 0, 0.5), word("w1", "two", 0.8, 1), word("w2", "three", 2, 2.2)],
-  };
-
-  assert.deepEqual(speechSpans(meta, { mergeGap: 0.4 }), [
-    { start: 0, end: 1 },
-    { start: 2, end: 2.2 },
-  ]);
-});
-
-test("speechSpans refuses multi-line meta without placement (file-relative times)", () => {
-  const meta = {
-    voices: [
-      { id: "a", words: [word("w0", "one", 0, 1)] },
-      { id: "b", words: [word("w1", "two", 0, 1)] },
-    ],
-  };
-  assert.throws(() => speechSpans(meta, { mergeGap: 0.2 }), /--sequential or --offsets/);
-});
-
-test("speechSpans sequential stacks lines by duration plus gap", () => {
-  const meta = {
-    voices: [
-      { id: "a", duration_s: 2, words: [word("w0", "one", 0.1, 1.9)] },
-      { id: "b", duration_s: 1, words: [word("w1", "two", 0.1, 0.9)] },
-    ],
-  };
-  assert.deepEqual(speechSpans(meta, { mergeGap: 0.2, sequential: true, gap: 0.5 }), [
-    { start: 0.1, end: 1.9 },
-    { start: 2.6, end: 3.4 },
-  ]);
-});
-
-test("speechSpans explicit offsets place each line at composition time", () => {
-  const meta = {
-    voices: [
-      { id: "a", words: [word("w0", "one", 0, 1)] },
-      { id: "b", words: [word("w1", "two", 0, 1)] },
-    ],
-  };
-  assert.deepEqual(speechSpans(meta, { mergeGap: 0.2, offsets: { a: 0, b: 4 } }), [
-    { start: 0, end: 1 },
-    { start: 4, end: 5 },
-  ]);
-  assert.throws(() => speechSpans(meta, { offsets: { a: 0 } }), /missing voice "b"/);
-});
-
-test("speechSpans returns empty spans for empty input", () => {
-  assert.deepEqual(speechSpans({ voices: [] }, { mergeGap: 0.6 }), []);
-});
-
-test("duckKeyframes shapes attack and release from base volume", () => {
-  assert.deepEqual(
-    duckKeyframes([{ start: 3, end: 5 }], {
-      duck: 0.25,
-      attack: 0.15,
-      release: 0.4,
-      baseVolume: 0.6,
-    }),
-    [
-      { time: 3, volume: 0.15, duration: 0.15 },
-      { time: 5, volume: 0.6, duration: 0.4 },
-    ],
-  );
-});
-
-test("--json spans match --merge-gap semantics exactly", () => {
-  const dir = mkdtempSync(join(tmpdir(), "media-use-duck-"));
-  try {
-    const metaPath = join(dir, "audio_meta.json");
-    writeFileSync(
-      metaPath,
-      JSON.stringify({
-        voices: [
-          {
-            id: "narration",
-            words: [
-              word("w0", "one", 0, 0.4),
-              word("w1", "two", 0.9, 1.2),
-              word("w2", "three", 1.8, 2.1),
-            ],
-          },
-        ],
-      }),
-    );
-
-    const out = execFileSync(
-      process.execPath,
-      [SCRIPT, "--meta", metaPath, "--target", "#bgm", "--merge-gap", "0.6", "--json"],
-      { encoding: "utf8" },
-    );
-
-    const parsed = JSON.parse(out);
-    assert.deepEqual(parsed.spans, [
-      { start: 0, end: 1.2 },
-      { start: 1.8, end: 2.1 },
-    ]);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-function word(id, text, start, end) {
-  return { id, text, start, end };
-}

package/skills/media-use/scripts/lib/error-diffusion.test.mjs

@@ -1,102 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { ERROR_DIFFUSION_ALGORITHMS, applyErrorDiffusionRgba } from "./error-diffusion.mjs";
-
-const EXPECTED_GRADIENTS = {
-  "floyd-steinberg": "00000101/00010101/00100101/00010111/01010101/01011011",
-  atkinson: "00000011/00001100/00010011/00010111/01001101/00111011",
-  "jarvis-judice-ninke": "00000011/00001011/00011001/00101111/00100111/01011011",
-  stucki: "00000011/00010101/00010110/00101011/00101101/01010111",
-  burkes: "00000101/00010011/00010110/00101011/01010111/00101011",
-  sierra: "00000011/00010101/00010110/00100111/00110111/00101101",
-  "sierra-lite": "00000101/00010101/00100101/00010110/01010111/01010101",
-  "two-row-sierra": "00000101/00010011/00010110/00101011/00101101/01011011",
-};
-
-test("exposes the eight article error-diffusion algorithms", () => {
-  assert.deepEqual(Object.keys(ERROR_DIFFUSION_ALGORITHMS), Object.keys(EXPECTED_GRADIENTS));
-});
-
-test("matches deterministic golden patterns for every diffusion kernel", () => {
-  const width = 8;
-  const height = 6;
-  const source = new Uint8ClampedArray(width * height * 4);
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const value = Math.round((255 * (x + y * 0.7)) / (width - 1 + (height - 1) * 0.7));
-      const offset = (y * width + x) * 4;
-      source[offset] = value;
-      source[offset + 1] = Math.round(value * 0.8);
-      source[offset + 2] = Math.round(value * 0.55);
-      source[offset + 3] = 17 + x + y;
-    }
-  }
-
-  for (const [algorithm, expected] of Object.entries(EXPECTED_GRADIENTS)) {
-    const output = source.slice();
-    applyErrorDiffusionRgba(output, width, height, {
-      algorithm,
-      brightness: 1,
-      contrast: 1,
-      detail: 1,
-      palette: ["#000000", "#ffffff"],
-      pointSize: 1,
-    });
-    const rows = [];
-    for (let y = 0; y < height; y++) {
-      let row = "";
-      for (let x = 0; x < width; x++) row += output[(y * width + x) * 4] ? "1" : "0";
-      rows.push(row);
-    }
-    assert.equal(rows.join("/"), expected, algorithm);
-    for (let i = 0; i < width * height; i++) assert.equal(output[i * 4 + 3], source[i * 4 + 3]);
-  }
-});
-
-test("fills point-size blocks from their center sample", () => {
-  const data = new Uint8ClampedArray([
-    0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 255, 255, 255, 6, 0, 0, 0, 7, 255,
-    255, 255, 8,
-  ]);
-  applyErrorDiffusionRgba(
-    data,
-    4,
-    2,
-    {
-      algorithm: "floyd-steinberg",
-      brightness: 1,
-      contrast: 1,
-      detail: 1,
-      palette: ["#000000", "#ffffff"],
-      pointSize: 2,
-    },
-    new Float32Array(6),
-  );
-  assert.deepEqual(
-    [...data],
-    [
-      255, 255, 255, 1, 255, 255, 255, 2, 255, 255, 255, 3, 255, 255, 255, 4, 255, 255, 255, 5, 255,
-      255, 255, 6, 255, 255, 255, 7, 255, 255, 255, 8,
-    ],
-  );
-});
-
-test("preserves authored palette order and validates the public contract", () => {
-  const reversed = new Uint8ClampedArray([0, 0, 0, 255]);
-  applyErrorDiffusionRgba(reversed, 1, 1, {
-    palette: ["#ffffff", "#000000"],
-  });
-  assert.deepEqual([...reversed], [255, 255, 255, 255]);
-
-  assert.throws(
-    () => applyErrorDiffusionRgba(new Uint8ClampedArray(4), 1, 1, { palette: ["#000000"] }),
-    /2 to 6 colors/,
-  );
-  assert.throws(
-    () =>
-      applyErrorDiffusionRgba(new Uint8ClampedArray(4), 1, 1, {
-        algorithm: "ordered-bayer",
-      }),
-    /unknown error-diffusion algorithm/,
-  );
-});

package/skills/media-use/scripts/lib/freeze.mjs

@@ -1,70 +0,0 @@
-import { writeFileSync, copyFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-
-// ponytail: bound the download so a hostile/runaway URL can't fill the disk.
-// 256MB covers any real media asset; raise if 4K video sources ever exceed it.
-const MAX_FREEZE_BYTES = 256 * 1024 * 1024;
-
-export async function freezeUrl(url, destPath) {
-  const where = String(url).slice(0, 80);
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`freeze failed: HTTP ${res.status} for ${where}`);
-
-  // Fail fast on an advertised oversize body before reading a single byte.
-  const declared = Number(res.headers.get("content-length"));
-  if (declared > MAX_FREEZE_BYTES)
-    throw new Error(
-      `freeze failed: ${declared} bytes exceeds ${MAX_FREEZE_BYTES} cap for ${where}`,
-    );
-
-  // Stream and abort once the cap is crossed, so a lying/chunked hostile URL
-  // can't buffer the whole payload into memory before the check (M1).
-  const chunks = [];
-  let total = 0;
-  for await (const chunk of res.body) {
-    total += chunk.length;
-    if (total > MAX_FREEZE_BYTES)
-      throw new Error(`freeze failed: stream exceeds ${MAX_FREEZE_BYTES} cap for ${where}`);
-    chunks.push(chunk);
-  }
-  if (total === 0) throw new Error(`freeze failed: empty response for ${where}`);
-
-  mkdirSync(dirname(destPath), { recursive: true });
-  writeFileSync(destPath, Buffer.concat(chunks, total));
-  return total;
-}
-
-export function freezeLocalFile(srcPath, destPath) {
-  mkdirSync(dirname(destPath), { recursive: true });
-  copyFileSync(srcPath, destPath);
-}
-
-// Ingest accepts a DIRECT public media URL only — not a platform page. yt-dlp is
-// deliberately out (cloud IPs get blocked, and it's brittle); the supported case
-// is "user points at their own file or a direct asset link". A direct URL is a
-// non-platform host whose path ends in a known media extension.
-const PLATFORM_HOSTS =
-  /(^|\.)(youtube\.com|youtu\.be|vimeo\.com|tiktok\.com|instagram\.com|twitter\.com|x\.com|facebook\.com|dailymotion\.com)$/i;
-const MEDIA_EXT = /\.(mp3|wav|m4a|aac|ogg|flac|mp4|mov|webm|mkv|png|jpe?g|webp|gif|svg|avif)$/i;
-
-// SSRF guard (m11): a user-supplied --from URL must not point at the local host
-// or a private network. Blocks loopback/localhost, RFC1918, link-local, and the
-// IPv6 equivalents on the literal hostname.
-// ponytail: literal-host check only; a DNS name that *resolves* to a private IP
-// (rebinding) still passes — add resolve-then-check if --from ever fetches from
-// untrusted hostnames at scale.
-const PRIVATE_HOST =
-  /^(localhost|.*\.local|.*\.internal|127\.|10\.|0\.|169\.254\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|\[?(::1|::ffff:127\.|f[cd][0-9a-f]{2}:|fe80:))/i;
-
-export function isDirectMediaUrl(u) {
-  let url;
-  try {
-    url = new URL(u);
-  } catch {
-    return false;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-  if (PLATFORM_HOSTS.test(url.hostname)) return false;
-  if (PRIVATE_HOST.test(url.hostname)) return false;
-  return MEDIA_EXT.test(url.pathname);
-}

package/skills/media-use/scripts/lib/freeze.test.mjs

@@ -1,46 +0,0 @@
-import { strict as assert } from "node:assert";
-import { test } from "node:test";
-import { isDirectMediaUrl } from "./freeze.mjs";
-
-test("accepts direct public media URLs", () => {
-  assert.equal(isDirectMediaUrl("https://cdn.example.com/clip.mp4"), true);
-  assert.equal(isDirectMediaUrl("https://example.com/a/b/track.mp3"), true);
-  assert.equal(isDirectMediaUrl("http://example.com/logo.svg"), true);
-});
-
-test("rejects platform pages (no yt-dlp)", () => {
-  assert.equal(isDirectMediaUrl("https://www.youtube.com/watch?v=abc"), false);
-  assert.equal(isDirectMediaUrl("https://youtu.be/abc"), false);
-  assert.equal(isDirectMediaUrl("https://vimeo.com/12345"), false);
-  assert.equal(isDirectMediaUrl("https://x.com/u/status/1"), false);
-});
-
-test("rejects non-direct / non-media URLs", () => {
-  assert.equal(isDirectMediaUrl("https://example.com/page"), false, "no media extension");
-  assert.equal(isDirectMediaUrl("ftp://example.com/a.mp4"), false, "non-http(s)");
-  assert.equal(isDirectMediaUrl("not a url"), false);
-});
-
-test("rejects local / private hosts (SSRF guard, m11)", () => {
-  for (const u of [
-    "http://localhost/a.mp4",
-    "http://127.0.0.1/a.mp4",
-    "http://127.1.2.3/a.mp4",
-    "http://0.0.0.0/a.mp4",
-    "http://10.0.0.5/a.mp4",
-    "http://192.168.1.1/a.mp4",
-    "http://172.16.0.1/a.mp4",
-    "http://172.31.255.255/a.mp4",
-    "http://169.254.169.254/a.mp4", // cloud metadata endpoint
-    "http://printer.local/a.mp4",
-    "http://svc.internal/a.mp4",
-    "http://[::1]/a.mp4",
-    "http://[fe80::1]/a.mp4",
-    "http://[fd00::1]/a.mp4",
-  ]) {
-    assert.equal(isDirectMediaUrl(u), false, `should block ${u}`);
-  }
-  // A public host that merely starts with similar digits is still allowed.
-  assert.equal(isDirectMediaUrl("https://172.40.0.1/a.mp4"), true, "172.40 is public");
-  assert.equal(isDirectMediaUrl("https://11.example.com/a.mp4"), true);
-});