@xylabs/aries 0.1.1

package/dist/actions/hash/algorithms/tlsh.mjs

@@ -0,0 +1,66 @@
+// src/actions/hash/algorithms/tlsh.ts
+import tlsh from "tlsh";
+
+// src/actions/hash/lib/hamming.ts
+function popcount8(byte) {
+  let count = 0;
+  let value = byte & 255;
+  while (value !== 0) {
+    count += value & 1;
+    value >>>= 1;
+  }
+  return count;
+}
+function hammingHex(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Hash length mismatch: ${a.length} vs ${b.length}`);
+  }
+  if (a.length % 2 !== 0) {
+    throw new Error(`Hash hex length must be even, got ${a.length}`);
+  }
+  let dist = 0;
+  for (let i = 0; i < a.length; i += 2) {
+    const xa = Number.parseInt(a.slice(i, i + 2), 16);
+    const xb = Number.parseInt(b.slice(i, i + 2), 16);
+    if (Number.isNaN(xa) || Number.isNaN(xb)) {
+      throw new TypeError(`Invalid hex at position ${i}: '${a.slice(i, i + 2)}' / '${b.slice(i, i + 2)}'`);
+    }
+    dist += popcount8(xa ^ xb);
+  }
+  return dist;
+}
+
+// src/actions/hash/algorithms/tlsh.ts
+var tlshAlgorithm = {
+  name: "tlsh",
+  family: "fuzzy-byte",
+  inputType: "bytes",
+  async hash(input) {
+    if (input.bytes === void 0) {
+      throw new Error("tlsh requires loaded bytes.");
+    }
+    if (input.bytes.length < 50) {
+      throw new Error(`tlsh requires at least 50 bytes of input (got ${input.bytes.length}).`);
+    }
+    return tlsh(input.bytes.toString("binary"));
+  },
+  async compare(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`tlsh hash length mismatch: ${a.length} vs ${b.length}`);
+    }
+    const skip = a.length >= 8 ? 4 : 0;
+    const aBody = a.slice(skip);
+    const bBody = b.slice(skip);
+    const distance = hammingHex(aBody, bBody);
+    const bits = aBody.length / 2 * 8;
+    return {
+      distance,
+      similarity: 1 - distance / bits,
+      metric: "tlsh-bit-hamming"
+    };
+  }
+};
+export {
+  tlshAlgorithm
+};
+//# sourceMappingURL=tlsh.mjs.map

package/dist/actions/hash/algorithms/tlsh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/hash/algorithms/tlsh.ts","../../../../src/actions/hash/lib/hamming.ts"],"sourcesContent":["import tlsh from 'tlsh'\n\nimport { hammingHex } from '../lib/hamming.ts'\nimport type { Algorithm } from './types.ts'\n\n/**\n * The `tlsh` npm package exports a single function: `tlsh(data: string): string`.\n * It does NOT expose the canonical diff algorithm publicly. We use a Hamming-distance\n * proxy over the hash bytes for `compare`. This is a reasonable approximation, not the\n * canonical TLSH-diff score — the metric label `tlsh-bit-hamming` makes that explicit.\n */\n\nexport const tlshAlgorithm: Algorithm = {\n  name: 'tlsh',\n  family: 'fuzzy-byte',\n  inputType: 'bytes',\n  async hash(input) {\n    if (input.bytes === undefined) {\n      throw new Error('tlsh requires loaded bytes.')\n    }\n    if (input.bytes.length < 50) {\n      throw new Error(`tlsh requires at least 50 bytes of input (got ${input.bytes.length}).`)\n    }\n    return tlsh(input.bytes.toString('binary'))\n  },\n  async compare(a, b) {\n    if (a.length !== b.length) {\n      throw new Error(`tlsh hash length mismatch: ${a.length} vs ${b.length}`)\n    }\n    // TLSH hashes carry a leading version/type byte that's identical for hashes\n    // produced by the same library — skip 4 hex chars (version+checksum bytes)\n    // before measuring distance for slightly more meaningful comparison.\n    const skip = a.length >= 8 ? 4 : 0\n    const aBody = a.slice(skip)\n    const bBody = b.slice(skip)\n    const distance = hammingHex(aBody, bBody)\n    const bits = (aBody.length / 2) * 8\n    return {\n      distance,\n      similarity: 1 - distance / bits,\n      metric: 'tlsh-bit-hamming',\n    }\n  },\n}\n","/**\n * Population count for an 8-bit value (number of set bits).\n */\nfunction popcount8(byte: number): number {\n  let count = 0\n  let value = byte & 0xff\n  while (value !== 0) {\n    count += value & 1\n    value >>>= 1\n  }\n  return count\n}\n\n/**\n * Hamming distance between two equal-length lowercase-hex strings.\n * Throws when the lengths differ.\n */\nexport function hammingHex(a: string, b: string): number {\n  if (a.length !== b.length) {\n    throw new Error(`Hash length mismatch: ${a.length} vs ${b.length}`)\n  }\n  if (a.length % 2 !== 0) {\n    throw new Error(`Hash hex length must be even, got ${a.length}`)\n  }\n  let dist = 0\n  for (let i = 0; i < a.length; i += 2) {\n    const xa = Number.parseInt(a.slice(i, i + 2), 16)\n    const xb = Number.parseInt(b.slice(i, i + 2), 16)\n    if (Number.isNaN(xa) || Number.isNaN(xb)) {\n      throw new TypeError(`Invalid hex at position ${i}: '${a.slice(i, i + 2)}' / '${b.slice(i, i + 2)}'`)\n    }\n    dist += popcount8(xa ^ xb)\n  }\n  return dist\n}\n\n/**\n * Bit-length of an even-length hex string.\n */\nexport function bitLengthHex(hex: string): number {\n  return (hex.length / 2) * 8\n}\n\n/**\n * Population count for a 32-bit unsigned value (number of set bits).\n * Uses the parallel-prefix bit trick.\n */\nexport function popcount32(value: number): number {\n  let v = Math.trunc(value)\n  v = v - ((v >>> 1) & 0x55_55_55_55)\n  v = (v & 0x33_33_33_33) + ((v >>> 2) & 0x33_33_33_33)\n  v = (v + (v >>> 4)) & 0x0f_0f_0f_0f\n  return ((v * 0x01_01_01_01) >>> 24) & 0xff\n}\n"],"mappings":";AAAA,OAAO,UAAU;;;ACGjB,SAAS,UAAU,MAAsB;AACvC,MAAI,QAAQ;AACZ,MAAI,QAAQ,OAAO;AACnB,SAAO,UAAU,GAAG;AAClB,aAAS,QAAQ;AACjB,eAAW;AAAA,EACb;AACA,SAAO;AACT;AAMO,SAAS,WAAW,GAAW,GAAmB;AACvD,MAAI,EAAE,WAAW,EAAE,QAAQ;AACzB,UAAM,IAAI,MAAM,yBAAyB,EAAE,MAAM,OAAO,EAAE,MAAM,EAAE;AAAA,EACpE;AACA,MAAI,EAAE,SAAS,MAAM,GAAG;AACtB,UAAM,IAAI,MAAM,qCAAqC,EAAE,MAAM,EAAE;AAAA,EACjE;AACA,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,GAAG;AACpC,UAAM,KAAK,OAAO,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE;AAChD,UAAM,KAAK,OAAO,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE;AAChD,QAAI,OAAO,MAAM,EAAE,KAAK,OAAO,MAAM,EAAE,GAAG;AACxC,YAAM,IAAI,UAAU,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,GAAG;AAAA,IACrG;AACA,YAAQ,UAAU,KAAK,EAAE;AAAA,EAC3B;AACA,SAAO;AACT;;;ADtBO,IAAM,gBAA2B;AAAA,EACtC,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,MAAM,KAAK,OAAO;AAChB,QAAI,MAAM,UAAU,QAAW;AAC7B,YAAM,IAAI,MAAM,6BAA6B;AAAA,IAC/C;AACA,QAAI,MAAM,MAAM,SAAS,IAAI;AAC3B,YAAM,IAAI,MAAM,iDAAiD,MAAM,MAAM,MAAM,IAAI;AAAA,IACzF;AACA,WAAO,KAAK,MAAM,MAAM,SAAS,QAAQ,CAAC;AAAA,EAC5C;AAAA,EACA,MAAM,QAAQ,GAAG,GAAG;AAClB,QAAI,EAAE,WAAW,EAAE,QAAQ;AACzB,YAAM,IAAI,MAAM,8BAA8B,EAAE,MAAM,OAAO,EAAE,MAAM,EAAE;AAAA,IACzE;AAIA,UAAM,OAAO,EAAE,UAAU,IAAI,IAAI;AACjC,UAAM,QAAQ,EAAE,MAAM,IAAI;AAC1B,UAAM,QAAQ,EAAE,MAAM,IAAI;AAC1B,UAAM,WAAW,WAAW,OAAO,KAAK;AACxC,UAAM,OAAQ,MAAM,SAAS,IAAK;AAClC,WAAO;AAAA,MACL;AAAA,MACA,YAAY,IAAI,WAAW;AAAA,MAC3B,QAAQ;AAAA,IACV;AAAA,EACF;AACF;","names":[]}

package/dist/actions/hash/algorithms/types.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=types.mjs.map

package/dist/actions/hash/algorithms/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/actions/hash/algorithms/videoFrames.mjs

@@ -0,0 +1,404 @@
+// src/actions/hash/algorithms/videoFrames.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import {
+  mkdtemp,
+  readdir,
+  readFile,
+  rm as rm2
+} from "fs/promises";
+import OS2 from "os";
+import PATH2 from "path";
+
+// src/actions/hash/lib/hamming.ts
+function popcount8(byte) {
+  let count = 0;
+  let value = byte & 255;
+  while (value !== 0) {
+    count += value & 1;
+    value >>>= 1;
+  }
+  return count;
+}
+function hammingHex(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Hash length mismatch: ${a.length} vs ${b.length}`);
+  }
+  if (a.length % 2 !== 0) {
+    throw new Error(`Hash hex length must be even, got ${a.length}`);
+  }
+  let dist = 0;
+  for (let i = 0; i < a.length; i += 2) {
+    const xa = Number.parseInt(a.slice(i, i + 2), 16);
+    const xb = Number.parseInt(b.slice(i, i + 2), 16);
+    if (Number.isNaN(xa) || Number.isNaN(xb)) {
+      throw new TypeError(`Invalid hex at position ${i}: '${a.slice(i, i + 2)}' / '${b.slice(i, i + 2)}'`);
+    }
+    dist += popcount8(xa ^ xb);
+  }
+  return dist;
+}
+
+// src/actions/hash/lib/runBinary.ts
+import { spawn } from "child_process";
+async function runBinary(options) {
+  const maxBytes = options.maxBytes ?? 64 * 1024 * 1024;
+  return await new Promise((resolve, reject) => {
+    const child = spawn(options.binary, [...options.args ?? []], { stdio: ["pipe", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    let stdoutBytes = 0;
+    let stderr = "";
+    let killedForOverflow = false;
+    child.stdout.on("data", (chunk) => {
+      stdoutBytes += chunk.length;
+      if (stdoutBytes > maxBytes) {
+        if (!killedForOverflow) {
+          killedForOverflow = true;
+          child.kill("SIGKILL");
+        }
+        return;
+      }
+      stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (killedForOverflow) {
+        reject(new Error(`${options.binary} stdout exceeded ${maxBytes} bytes`));
+        return;
+      }
+      const exitCode = code ?? -1;
+      const stdout = Buffer.concat(stdoutChunks);
+      if (exitCode !== 0) {
+        const tail = stderr.trim().split(/\r?\n/).slice(-3).join("\n");
+        reject(new Error(`${options.binary} exited ${exitCode}${tail.length > 0 ? `: ${tail}` : ""}`));
+        return;
+      }
+      resolve({
+        stdout,
+        stderr,
+        exitCode
+      });
+    });
+    if (options.stdin === void 0) {
+      child.stdin.end();
+    } else {
+      child.stdin.end(options.stdin);
+    }
+  });
+}
+
+// src/actions/hash/lib/which.ts
+import { spawn as spawn2 } from "child_process";
+async function which(binary) {
+  return await new Promise((resolve) => {
+    const cmd = process.platform === "win32" ? "where" : "command";
+    const args = process.platform === "win32" ? [binary] : ["-v", binary];
+    const child = spawn2(cmd, args, { shell: process.platform !== "win32" });
+    let stdout = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => resolve(null));
+    child.on("close", (code) => {
+      if (code === 0) {
+        const path = stdout.split(/\r?\n/).find((line) => line.trim().length > 0)?.trim() ?? null;
+        resolve(path);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+async function requireBinary(req) {
+  const path = await which(req.binary);
+  if (path !== null) return path;
+  const lines = [`${req.binary} binary not found on PATH. Install with:`];
+  if (req.install.brew !== void 0) lines.push(`  macOS:   brew install ${req.install.brew}`);
+  if (req.install.apt !== void 0) lines.push(`  Debian:  apt install ${req.install.apt}`);
+  if (req.install.choco !== void 0) lines.push(`  Windows: choco install ${req.install.choco}`);
+  throw new Error(lines.join("\n"));
+}
+
+// src/actions/hash/lib/withTempfile.ts
+import { randomBytes } from "crypto";
+import { rm, writeFile } from "fs/promises";
+import OS from "os";
+import PATH from "path";
+async function withTempfile(bytes, extension, fn) {
+  const ext = extension !== void 0 && extension.length > 0 ? `.${extension}` : "";
+  const path = PATH.join(OS.tmpdir(), `aries-hash-${randomBytes(8).toString("hex")}${ext}`);
+  await writeFile(path, bytes);
+  try {
+    return await fn(path);
+  } finally {
+    await rm(path, { force: true });
+  }
+}
+
+// src/actions/hash/algorithms/pdq.ts
+import { createRequire } from "module";
+import sharp from "sharp";
+var require2 = createRequire(import.meta.url);
+var { PDQ } = require2("pdq-wasm");
+var initialized = false;
+async function ensureInit() {
+  if (initialized) return;
+  await PDQ.init();
+  initialized = true;
+}
+async function toRgbRaw(source) {
+  const { data, info } = await sharp(source).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  return {
+    data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+    width: info.width,
+    height: info.height
+  };
+}
+var pdqAlgorithm = {
+  name: "pdq",
+  family: "perceptual-image",
+  inputType: "image",
+  async hash(input) {
+    const source = input.path ?? input.bytes;
+    if (source === void 0) {
+      throw new Error("pdq requires bytes or a path.");
+    }
+    await ensureInit();
+    const rgb = await toRgbRaw(source);
+    const result = PDQ.hash({
+      data: rgb.data,
+      width: rgb.width,
+      height: rgb.height,
+      channels: 3
+    });
+    return PDQ.toHex(result.hash);
+  },
+  async compare(a, b) {
+    const dist = hammingHex(a, b);
+    const bits = a.length / 2 * 8;
+    return {
+      distance: dist,
+      similarity: 1 - dist / bits,
+      metric: `hamming-${bits}`
+    };
+  }
+};
+
+// src/actions/hash/algorithms/phash.ts
+import phashLib from "sharp-phash";
+var phash = phashLib;
+function binaryToHex(bin) {
+  if (!/^[01]+$/.test(bin)) {
+    throw new TypeError(`phash returned unexpected output: ${bin.slice(0, 20)}\u2026`);
+  }
+  const padded = bin.padStart(Math.ceil(bin.length / 4) * 4, "0");
+  let hex = "";
+  for (let i = 0; i < padded.length; i += 4) {
+    hex += Number.parseInt(padded.slice(i, i + 4), 2).toString(16);
+  }
+  return hex;
+}
+var phashAlgorithm = {
+  name: "phash",
+  family: "perceptual-image",
+  inputType: "image",
+  async hash(input) {
+    const source = input.path ?? input.bytes;
+    if (source === void 0) {
+      throw new Error("phash requires bytes or a path.");
+    }
+    const bin = await phash(source);
+    return binaryToHex(bin);
+  },
+  async compare(a, b) {
+    const dist = hammingHex(a, b);
+    const bits = a.length / 2 * 8;
+    return {
+      distance: dist,
+      similarity: 1 - dist / bits,
+      metric: `hamming-${bits}`
+    };
+  }
+};
+
+// src/actions/hash/algorithms/videoFrames.ts
+var FFMPEG_BIN = {
+  binary: "ffmpeg",
+  install: {
+    brew: "ffmpeg",
+    apt: "ffmpeg",
+    choco: "ffmpeg"
+  }
+};
+var SUPPORTED_FRAME_ALGORITHMS = ["phash", "pdq"];
+var DEFAULT_FPS = 1;
+var DEFAULT_FRAME_ALGORITHM = "phash";
+async function extractFrames(videoPath, fps) {
+  await requireBinary(FFMPEG_BIN);
+  const dir = await mkdtemp(PATH2.join(OS2.tmpdir(), `aries-vframes-${randomBytes2(6).toString("hex")}-`));
+  try {
+    await runBinary({
+      binary: "ffmpeg",
+      args: [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        videoPath,
+        "-vf",
+        `fps=${fps},scale=128:128:force_original_aspect_ratio=disable`,
+        "-q:v",
+        "5",
+        PATH2.join(dir, "frame-%05d.jpg")
+      ]
+    });
+    const entries = (await readdir(dir)).filter((name) => name.endsWith(".jpg")).toSorted();
+    const frames = await Promise.all(entries.map(async (name) => await readFile(PATH2.join(dir, name))));
+    return { frames };
+  } finally {
+    await rm2(dir, { recursive: true, force: true });
+  }
+}
+function frameHasher(name) {
+  switch (name) {
+    case "phash": {
+      return async (bytes) => await phashAlgorithm.hash({ bytes });
+    }
+    case "pdq": {
+      return async (bytes) => await pdqAlgorithm.hash({ bytes });
+    }
+  }
+}
+async function fingerprintVideo(videoPath, fps, frameAlgorithm) {
+  const { frames } = await extractFrames(videoPath, fps);
+  const hashFrame = frameHasher(frameAlgorithm);
+  const hashes = await Promise.all(frames.map(async (frame, idx) => ({
+    t: idx / fps,
+    hash: await hashFrame(frame)
+  })));
+  return {
+    algorithm: "video-frames",
+    fps,
+    frameAlgorithm,
+    duration: frames.length / fps,
+    frames: hashes
+  };
+}
+function parseVideoFramesHash(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("video-frames hash must be JSON produced by `aries hash --algorithm video-frames`.");
+  }
+  const obj = parsed;
+  if (obj.algorithm !== "video-frames" || typeof obj.fps !== "number" || typeof obj.duration !== "number" || !Array.isArray(obj.frames)) {
+    throw new Error("video-frames hash JSON missing required fields.");
+  }
+  if (obj.frameAlgorithm === void 0) {
+    return { ...obj, frameAlgorithm: "phash" };
+  }
+  return obj;
+}
+function compareFrameSequences(a, b) {
+  const fps = Math.min(a.fps, b.fps);
+  if (a.frames.length === 0 || b.frames.length === 0) {
+    return {
+      similarity: 0,
+      distance: Number.NaN,
+      bestOffsetSeconds: 0,
+      overlapSeconds: 0
+    };
+  }
+  const minLen = Math.min(a.frames.length, b.frames.length);
+  const maxOffset = Math.max(a.frames.length, b.frames.length) - 1;
+  let best = {
+    similarity: 0,
+    distance: Number.NaN,
+    bestOffsetSeconds: 0,
+    overlapSeconds: 0
+  };
+  const minOverlap = Math.max(2, Math.floor(minLen / 4));
+  for (let offset = -maxOffset; offset <= maxOffset; offset++) {
+    const aStart = Math.max(0, -offset);
+    const bStart = Math.max(0, offset);
+    const overlap = Math.min(a.frames.length - aStart, b.frames.length - bStart);
+    if (overlap < minOverlap) continue;
+    let totalBits = 0;
+    let bitWidth = 0;
+    for (let i = 0; i < overlap; i++) {
+      const ah = a.frames[aStart + i].hash;
+      const bh = b.frames[bStart + i].hash;
+      if (ah.length !== bh.length) continue;
+      totalBits += hammingHex(ah, bh);
+      bitWidth += ah.length / 2 * 8;
+    }
+    if (bitWidth === 0) continue;
+    const similarity = 1 - totalBits / bitWidth;
+    if (similarity > best.similarity) {
+      best = {
+        similarity,
+        distance: totalBits,
+        bestOffsetSeconds: offset / fps,
+        overlapSeconds: overlap / fps
+      };
+    }
+  }
+  return best;
+}
+function parseFps(options) {
+  const raw = options?.fps;
+  if (raw === void 0) return DEFAULT_FPS;
+  const value = typeof raw === "string" ? Number.parseFloat(raw) : Number(raw);
+  if (!Number.isFinite(value) || value <= 0 || value > 60) {
+    const display = typeof raw === "string" || typeof raw === "number" ? String(raw) : "<non-scalar>";
+    throw new RangeError(`Invalid --fps ${display}: expected a number in (0, 60].`);
+  }
+  return value;
+}
+function parseFrameAlgorithm(options) {
+  const raw = options?.frameAlgorithm;
+  if (raw === void 0) return DEFAULT_FRAME_ALGORITHM;
+  if (typeof raw !== "string" || !SUPPORTED_FRAME_ALGORITHMS.includes(raw)) {
+    const display = typeof raw === "string" ? raw : `<${typeof raw}>`;
+    throw new RangeError(`Invalid --frame-algorithm ${display}: expected one of ${SUPPORTED_FRAME_ALGORITHMS.join(", ")}.`);
+  }
+  return raw;
+}
+var videoFramesAlgorithm = {
+  name: "video-frames",
+  family: "video",
+  inputType: "video",
+  requires: [FFMPEG_BIN],
+  async hash(input) {
+    const fps = parseFps(input.options);
+    const frameAlgorithm = parseFrameAlgorithm(input.options);
+    const fp = input.path === void 0 ? input.bytes === void 0 ? null : await withTempfile(input.bytes, "video.bin", async (path) => await fingerprintVideo(path, fps, frameAlgorithm)) : await fingerprintVideo(input.path, fps, frameAlgorithm);
+    if (fp === null) {
+      throw new Error("video-frames requires bytes or a path.");
+    }
+    return JSON.stringify(fp);
+  },
+  async compare(a, b) {
+    const fpA = parseVideoFramesHash(a);
+    const fpB = parseVideoFramesHash(b);
+    if (fpA.frameAlgorithm !== fpB.frameAlgorithm) {
+      throw new Error(`Cannot compare video-frames hashes with different frame algorithms (${fpA.frameAlgorithm} vs ${fpB.frameAlgorithm}).`);
+    }
+    const result = compareFrameSequences(fpA, fpB);
+    return {
+      similarity: result.similarity,
+      distance: Number.isFinite(result.distance) ? result.distance : void 0,
+      metric: `frame-sequence-${fpA.frameAlgorithm}@${fpA.fps}fps`
+    };
+  }
+};
+export {
+  DEFAULT_FPS,
+  DEFAULT_FRAME_ALGORITHM,
+  SUPPORTED_FRAME_ALGORITHMS,
+  videoFramesAlgorithm
+};
+//# sourceMappingURL=videoFrames.mjs.map

package/dist/actions/hash/algorithms/videoFrames.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/hash/algorithms/videoFrames.ts","../../../../src/actions/hash/lib/hamming.ts","../../../../src/actions/hash/lib/runBinary.ts","../../../../src/actions/hash/lib/which.ts","../../../../src/actions/hash/lib/withTempfile.ts","../../../../src/actions/hash/algorithms/pdq.ts","../../../../src/actions/hash/algorithms/phash.ts"],"sourcesContent":["import { randomBytes } from 'node:crypto'\nimport {\n  mkdtemp, readdir, readFile, rm,\n} from 'node:fs/promises'\nimport OS from 'node:os'\nimport PATH from 'node:path'\n\nimport { hammingHex } from '../lib/hamming.ts'\nimport { runBinary } from '../lib/runBinary.ts'\nimport { requireBinary } from '../lib/which.ts'\nimport { withTempfile } from '../lib/withTempfile.ts'\nimport { pdqAlgorithm } from './pdq.ts'\nimport { phashAlgorithm } from './phash.ts'\nimport type { Algorithm, RequiredBinary } from './types.ts'\n\nconst FFMPEG_BIN: RequiredBinary = {\n  binary: 'ffmpeg',\n  install: {\n    brew: 'ffmpeg',\n    apt: 'ffmpeg',\n    choco: 'ffmpeg',\n  },\n}\n\nexport type FrameAlgorithmName = 'phash' | 'pdq'\nexport const SUPPORTED_FRAME_ALGORITHMS = ['phash', 'pdq'] as const\n\ninterface VideoFramesFingerprint {\n  algorithm: 'video-frames'\n  fps: number\n  frameAlgorithm: FrameAlgorithmName\n  duration: number\n  frames: { t: number; hash: string }[]\n}\n\nexport const DEFAULT_FPS = 1\nexport const DEFAULT_FRAME_ALGORITHM: FrameAlgorithmName = 'phash'\n\nasync function extractFrames(videoPath: string, fps: number): Promise<{ frames: Buffer[] }> {\n  await requireBinary(FFMPEG_BIN)\n  const dir = await mkdtemp(PATH.join(OS.tmpdir(), `aries-vframes-${randomBytes(6).toString('hex')}-`))\n  try {\n    await runBinary({\n      binary: 'ffmpeg',\n      args: [\n        '-hide_banner',\n        '-loglevel',\n        'error',\n        '-i',\n        videoPath,\n        '-vf',\n        `fps=${fps},scale=128:128:force_original_aspect_ratio=disable`,\n        '-q:v',\n        '5',\n        PATH.join(dir, 'frame-%05d.jpg'),\n      ],\n    })\n    const entries = (await readdir(dir)).filter(name => name.endsWith('.jpg')).toSorted()\n    const frames = await Promise.all(entries.map(async name => await readFile(PATH.join(dir, name))))\n    return { frames }\n  } finally {\n    await rm(dir, { recursive: true, force: true })\n  }\n}\n\nfunction frameHasher(name: FrameAlgorithmName): (bytes: Buffer) => Promise<string> {\n  switch (name) {\n    case 'phash': { return async bytes => await phashAlgorithm.hash({ bytes })\n    }\n    case 'pdq': { return async bytes => await pdqAlgorithm.hash({ bytes })\n    }\n  }\n}\n\nasync function fingerprintVideo(\n  videoPath: string,\n  fps: number,\n  frameAlgorithm: FrameAlgorithmName,\n): Promise<VideoFramesFingerprint> {\n  const { frames } = await extractFrames(videoPath, fps)\n  const hashFrame = frameHasher(frameAlgorithm)\n  const hashes = await Promise.all(frames.map(async (frame, idx) => ({\n    t: idx / fps,\n    hash: await hashFrame(frame),\n  })))\n  return {\n    algorithm: 'video-frames',\n    fps,\n    frameAlgorithm,\n    duration: frames.length / fps,\n    frames: hashes,\n  }\n}\n\nfunction parseVideoFramesHash(raw: string): VideoFramesFingerprint {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(raw)\n  } catch {\n    throw new Error('video-frames hash must be JSON produced by `aries hash --algorithm video-frames`.')\n  }\n  const obj = parsed as Partial<VideoFramesFingerprint>\n  if (\n    obj.algorithm !== 'video-frames'\n    || typeof obj.fps !== 'number'\n    || typeof obj.duration !== 'number'\n    || !Array.isArray(obj.frames)\n  ) {\n    throw new Error('video-frames hash JSON missing required fields.')\n  }\n  // frameAlgorithm was added in a later revision; default to phash when older hashes lack it.\n  if (obj.frameAlgorithm === undefined) {\n    return { ...obj, frameAlgorithm: 'phash' } as VideoFramesFingerprint\n  }\n  return obj as VideoFramesFingerprint\n}\n\ninterface VideoFramesCompareDetails {\n  similarity: number\n  distance: number\n  bestOffsetSeconds: number\n  overlapSeconds: number\n}\n\n/** Sliding-window Hamming distance over the two frame sequences. */\nfunction compareFrameSequences(\n  a: VideoFramesFingerprint,\n  b: VideoFramesFingerprint,\n): VideoFramesCompareDetails {\n  const fps = Math.min(a.fps, b.fps)\n  if (a.frames.length === 0 || b.frames.length === 0) {\n    return {\n      similarity: 0, distance: Number.NaN, bestOffsetSeconds: 0, overlapSeconds: 0,\n    }\n  }\n  const minLen = Math.min(a.frames.length, b.frames.length)\n  const maxOffset = Math.max(a.frames.length, b.frames.length) - 1\n  let best: VideoFramesCompareDetails = {\n    similarity: 0,\n    distance: Number.NaN,\n    bestOffsetSeconds: 0,\n    overlapSeconds: 0,\n  }\n  const minOverlap = Math.max(2, Math.floor(minLen / 4))\n  for (let offset = -maxOffset; offset <= maxOffset; offset++) {\n    const aStart = Math.max(0, -offset)\n    const bStart = Math.max(0, offset)\n    const overlap = Math.min(a.frames.length - aStart, b.frames.length - bStart)\n    if (overlap < minOverlap) continue\n    let totalBits = 0\n    let bitWidth = 0\n    for (let i = 0; i < overlap; i++) {\n      const ah = a.frames[aStart + i].hash\n      const bh = b.frames[bStart + i].hash\n      if (ah.length !== bh.length) continue\n      totalBits += hammingHex(ah, bh)\n      bitWidth += (ah.length / 2) * 8\n    }\n    if (bitWidth === 0) continue\n    const similarity = 1 - totalBits / bitWidth\n    if (similarity > best.similarity) {\n      best = {\n        similarity,\n        distance: totalBits,\n        bestOffsetSeconds: offset / fps,\n        overlapSeconds: overlap / fps,\n      }\n    }\n  }\n  return best\n}\n\nfunction parseFps(options: Record<string, unknown> | undefined): number {\n  const raw = options?.fps\n  if (raw === undefined) return DEFAULT_FPS\n  const value = typeof raw === 'string' ? Number.parseFloat(raw) : Number(raw)\n  if (!Number.isFinite(value) || value <= 0 || value > 60) {\n    const display = typeof raw === 'string' || typeof raw === 'number' ? String(raw) : '<non-scalar>'\n    throw new RangeError(`Invalid --fps ${display}: expected a number in (0, 60].`)\n  }\n  return value\n}\n\nfunction parseFrameAlgorithm(options: Record<string, unknown> | undefined): FrameAlgorithmName {\n  const raw = options?.frameAlgorithm\n  if (raw === undefined) return DEFAULT_FRAME_ALGORITHM\n  if (typeof raw !== 'string' || !(SUPPORTED_FRAME_ALGORITHMS as readonly string[]).includes(raw)) {\n    const display = typeof raw === 'string' ? raw : `<${typeof raw}>`\n    throw new RangeError(`Invalid --frame-algorithm ${display}: expected one of ${SUPPORTED_FRAME_ALGORITHMS.join(', ')}.`)\n  }\n  return raw as FrameAlgorithmName\n}\n\nexport const videoFramesAlgorithm: Algorithm = {\n  name: 'video-frames',\n  family: 'video',\n  inputType: 'video',\n  requires: [FFMPEG_BIN],\n  async hash(input) {\n    const fps = parseFps(input.options)\n    const frameAlgorithm = parseFrameAlgorithm(input.options)\n    const fp = input.path === undefined\n      ? input.bytes === undefined\n        ? null\n        : await withTempfile(input.bytes, 'video.bin', async path => await fingerprintVideo(path, fps, frameAlgorithm))\n      : await fingerprintVideo(input.path, fps, frameAlgorithm)\n    if (fp === null) {\n      throw new Error('video-frames requires bytes or a path.')\n    }\n    return JSON.stringify(fp)\n  },\n  async compare(a, b) {\n    const fpA = parseVideoFramesHash(a)\n    const fpB = parseVideoFramesHash(b)\n    if (fpA.frameAlgorithm !== fpB.frameAlgorithm) {\n      throw new Error(`Cannot compare video-frames hashes with different frame algorithms (${fpA.frameAlgorithm} vs ${fpB.frameAlgorithm}).`)\n    }\n    const result = compareFrameSequences(fpA, fpB)\n    return {\n      similarity: result.similarity,\n      distance: Number.isFinite(result.distance) ? result.distance : undefined,\n      metric: `frame-sequence-${fpA.frameAlgorithm}@${fpA.fps}fps`,\n    }\n  },\n}\n","/**\n * Population count for an 8-bit value (number of set bits).\n */\nfunction popcount8(byte: number): number {\n  let count = 0\n  let value = byte & 0xff\n  while (value !== 0) {\n    count += value & 1\n    value >>>= 1\n  }\n  return count\n}\n\n/**\n * Hamming distance between two equal-length lowercase-hex strings.\n * Throws when the lengths differ.\n */\nexport function hammingHex(a: string, b: string): number {\n  if (a.length !== b.length) {\n    throw new Error(`Hash length mismatch: ${a.length} vs ${b.length}`)\n  }\n  if (a.length % 2 !== 0) {\n    throw new Error(`Hash hex length must be even, got ${a.length}`)\n  }\n  let dist = 0\n  for (let i = 0; i < a.length; i += 2) {\n    const xa = Number.parseInt(a.slice(i, i + 2), 16)\n    const xb = Number.parseInt(b.slice(i, i + 2), 16)\n    if (Number.isNaN(xa) || Number.isNaN(xb)) {\n      throw new TypeError(`Invalid hex at position ${i}: '${a.slice(i, i + 2)}' / '${b.slice(i, i + 2)}'`)\n    }\n    dist += popcount8(xa ^ xb)\n  }\n  return dist\n}\n\n/**\n * Bit-length of an even-length hex string.\n */\nexport function bitLengthHex(hex: string): number {\n  return (hex.length / 2) * 8\n}\n\n/**\n * Population count for a 32-bit unsigned value (number of set bits).\n * Uses the parallel-prefix bit trick.\n */\nexport function popcount32(value: number): number {\n  let v = Math.trunc(value)\n  v = v - ((v >>> 1) & 0x55_55_55_55)\n  v = (v & 0x33_33_33_33) + ((v >>> 2) & 0x33_33_33_33)\n  v = (v + (v >>> 4)) & 0x0f_0f_0f_0f\n  return ((v * 0x01_01_01_01) >>> 24) & 0xff\n}\n","import { spawn } from 'node:child_process'\n\nexport interface RunBinaryOptions {\n  binary: string\n  args?: readonly string[]\n  /** When provided, written to the child's stdin and stdin is closed. */\n  stdin?: Buffer\n  /** When true, the child's stdout is captured as a Buffer. Otherwise as utf8. */\n  binaryOutput?: boolean\n  /** Cap stdout capture at this many bytes. Default 64 MiB. */\n  maxBytes?: number\n}\n\nexport interface RunBinaryResult {\n  stdout: Buffer\n  stderr: string\n  exitCode: number\n}\n\n/**\n * Spawn a binary, optionally write to its stdin, and capture stdout/stderr.\n * Throws if the child exits non-zero.\n */\nexport async function runBinary(options: RunBinaryOptions): Promise<RunBinaryResult> {\n  const maxBytes = options.maxBytes ?? 64 * 1024 * 1024\n  return await new Promise((resolve, reject) => {\n    const child = spawn(options.binary, [...(options.args ?? [])], { stdio: ['pipe', 'pipe', 'pipe'] })\n\n    const stdoutChunks: Buffer[] = []\n    let stdoutBytes = 0\n    let stderr = ''\n    let killedForOverflow = false\n\n    child.stdout.on('data', (chunk: Buffer) => {\n      stdoutBytes += chunk.length\n      if (stdoutBytes > maxBytes) {\n        if (!killedForOverflow) {\n          killedForOverflow = true\n          child.kill('SIGKILL')\n        }\n        return\n      }\n      stdoutChunks.push(chunk)\n    })\n    child.stderr.on('data', (chunk: Buffer) => {\n      stderr += chunk.toString('utf8')\n    })\n\n    child.on('error', err => reject(err))\n    child.on('close', (code) => {\n      if (killedForOverflow) {\n        reject(new Error(`${options.binary} stdout exceeded ${maxBytes} bytes`))\n        return\n      }\n      const exitCode = code ?? -1\n      const stdout = Buffer.concat(stdoutChunks)\n      if (exitCode !== 0) {\n        const tail = stderr.trim().split(/\\r?\\n/).slice(-3).join('\\n')\n        reject(new Error(`${options.binary} exited ${exitCode}${tail.length > 0 ? `: ${tail}` : ''}`))\n        return\n      }\n      resolve({\n        stdout, stderr, exitCode,\n      })\n    })\n\n    if (options.stdin === undefined) {\n      child.stdin.end()\n    } else {\n      child.stdin.end(options.stdin)\n    }\n  })\n}\n","import { spawn } from 'node:child_process'\n\nimport type { RequiredBinary } from '../algorithms/types.ts'\n\n/**\n * Resolve a binary name to its absolute path on the user's PATH.\n * Returns null if not found.\n */\nexport async function which(binary: string): Promise<string | null> {\n  return await new Promise((resolve) => {\n    const cmd = process.platform === 'win32' ? 'where' : 'command'\n    const args = process.platform === 'win32' ? [binary] : ['-v', binary]\n    const child = spawn(cmd, args, { shell: process.platform !== 'win32' })\n\n    let stdout = ''\n    child.stdout.on('data', (chunk: Buffer) => {\n      stdout += chunk.toString('utf8')\n    })\n    child.on('error', () => resolve(null))\n    child.on('close', (code) => {\n      if (code === 0) {\n        const path = stdout.split(/\\r?\\n/).find(line => line.trim().length > 0)?.trim() ?? null\n        resolve(path)\n      } else {\n        resolve(null)\n      }\n    })\n  })\n}\n\n/**\n * Throw a clearly-actionable error when a required binary is missing.\n */\nexport async function requireBinary(req: RequiredBinary): Promise<string> {\n  const path = await which(req.binary)\n  if (path !== null) return path\n  const lines = [`${req.binary} binary not found on PATH. Install with:`]\n  if (req.install.brew !== undefined) lines.push(`  macOS:   brew install ${req.install.brew}`)\n  if (req.install.apt !== undefined) lines.push(`  Debian:  apt install ${req.install.apt}`)\n  if (req.install.choco !== undefined) lines.push(`  Windows: choco install ${req.install.choco}`)\n  throw new Error(lines.join('\\n'))\n}\n","import { randomBytes } from 'node:crypto'\nimport { rm, writeFile } from 'node:fs/promises'\nimport OS from 'node:os'\nimport PATH from 'node:path'\n\n/**\n * Write a buffer to a tempfile, run `fn` with its path, and unlink afterwards.\n * `extension` is included in the filename when provided (no leading dot).\n */\nexport async function withTempfile<T>(\n  bytes: Buffer,\n  extension: string | undefined,\n  fn: (path: string) => Promise<T>,\n): Promise<T> {\n  const ext = extension !== undefined && extension.length > 0 ? `.${extension}` : ''\n  const path = PATH.join(OS.tmpdir(), `aries-hash-${randomBytes(8).toString('hex')}${ext}`)\n  await writeFile(path, bytes)\n  try {\n    return await fn(path)\n  } finally {\n    await rm(path, { force: true })\n  }\n}\n","import { createRequire } from 'node:module'\n\nimport sharp from 'sharp'\n\nimport { hammingHex } from '../lib/hamming.ts'\nimport type { Algorithm } from './types.ts'\n\n/**\n * pdq-wasm ships a CommonJS entry that uses `require` to load its bundled WASM file.\n * Aries is ESM, so we use `createRequire` to bridge — this picks the CJS dist via the\n * package's `exports.require` condition, which can resolve the relative WASM path.\n */\nconst require = createRequire(import.meta.url)\ninterface PDQHashResult { hash: Uint8Array; quality: number }\ninterface PDQModule {\n  init(): Promise<void>\n  hash(input: { data: Uint8Array; width: number; height: number; channels: 1 | 3 }): PDQHashResult\n  toHex(hash: Uint8Array): string\n}\nconst { PDQ } = require('pdq-wasm') as { PDQ: PDQModule }\n\nlet initialized = false\nasync function ensureInit(): Promise<void> {\n  if (initialized) return\n  await PDQ.init()\n  initialized = true\n}\n\n/**\n * Decode the input image to RGB raw bytes that pdq-wasm can consume directly.\n * sharp handles JPEG/PNG/WebP/AVIF/etc. transparently.\n */\nasync function toRgbRaw(source: Buffer | string): Promise<{ data: Uint8Array; width: number; height: number }> {\n  const { data, info } = await sharp(source).removeAlpha().raw().toBuffer({ resolveWithObject: true })\n  return {\n    data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),\n    width: info.width,\n    height: info.height,\n  }\n}\n\nexport const pdqAlgorithm: Algorithm = {\n  name: 'pdq',\n  family: 'perceptual-image',\n  inputType: 'image',\n  async hash(input) {\n    const source = input.path ?? input.bytes\n    if (source === undefined) {\n      throw new Error('pdq requires bytes or a path.')\n    }\n    await ensureInit()\n    const rgb = await toRgbRaw(source)\n    const result = PDQ.hash({\n      data: rgb.data, width: rgb.width, height: rgb.height, channels: 3,\n    })\n    return PDQ.toHex(result.hash)\n  },\n  async compare(a, b) {\n    const dist = hammingHex(a, b)\n    const bits = (a.length / 2) * 8\n    return {\n      distance: dist, similarity: 1 - dist / bits, metric: `hamming-${bits}`,\n    }\n  },\n}\n","import phashLib from 'sharp-phash'\n\nimport { hammingHex } from '../lib/hamming.ts'\nimport type { Algorithm } from './types.ts'\n\nconst phash = phashLib as unknown as (image: Buffer | string) => Promise<string>\n\n/**\n * sharp-phash returns a 64-character '01' binary string. We pack it into 16-char hex\n * for parity with the other perceptual image algorithms.\n */\nfunction binaryToHex(bin: string): string {\n  if (!/^[01]+$/.test(bin)) {\n    throw new TypeError(`phash returned unexpected output: ${bin.slice(0, 20)}…`)\n  }\n  const padded = bin.padStart(Math.ceil(bin.length / 4) * 4, '0')\n  let hex = ''\n  for (let i = 0; i < padded.length; i += 4) {\n    hex += Number.parseInt(padded.slice(i, i + 4), 2).toString(16)\n  }\n  return hex\n}\n\nexport const phashAlgorithm: Algorithm = {\n  name: 'phash',\n  family: 'perceptual-image',\n  inputType: 'image',\n  async hash(input) {\n    const source = input.path ?? input.bytes\n    if (source === undefined) {\n      throw new Error('phash requires bytes or a path.')\n    }\n    const bin = await phash(source)\n    return binaryToHex(bin)\n  },\n  async compare(a, b) {\n    const dist = hammingHex(a, b)\n    const bits = (a.length / 2) * 8\n    return {\n      distance: dist, similarity: 1 - dist / bits, metric: `hamming-${bits}`,\n    }\n  },\n}\n"],"mappings":"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","names":["randomBytes","rm","OS","PATH","spawn","require","PATH","OS","randomBytes","rm"]}

package/dist/actions/hash/algorithms/xyo.mjs

@@ -0,0 +1,30 @@
+// src/actions/hash/algorithms/xyo.ts
+import { ObjectHasher } from "@xyo-network/hash";
+var xyoAlgorithm = {
+  name: "xyo",
+  family: "strict",
+  inputType: "bytes",
+  async hash(input) {
+    if (input.bytes === void 0) {
+      throw new Error("xyo requires loaded bytes.");
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(input.bytes.toString("utf8"));
+    } catch {
+      throw new Error("xyo requires valid JSON input.");
+    }
+    return await ObjectHasher.hash(parsed);
+  },
+  async compare(a, b) {
+    return {
+      similarity: a === b ? 1 : 0,
+      distance: a === b ? 0 : 1,
+      metric: "exact-match"
+    };
+  }
+};
+export {
+  xyoAlgorithm
+};
+//# sourceMappingURL=xyo.mjs.map

package/dist/actions/hash/algorithms/xyo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/hash/algorithms/xyo.ts"],"sourcesContent":["import { ObjectHasher } from '@xyo-network/hash'\n\nimport type { Algorithm } from './types.ts'\n\nexport const xyoAlgorithm: Algorithm = {\n  name: 'xyo',\n  family: 'strict',\n  inputType: 'bytes',\n  async hash(input) {\n    if (input.bytes === undefined) {\n      throw new Error('xyo requires loaded bytes.')\n    }\n    let parsed: unknown\n    try {\n      parsed = JSON.parse(input.bytes.toString('utf8'))\n    } catch {\n      throw new Error('xyo requires valid JSON input.')\n    }\n    return await ObjectHasher.hash(parsed as Record<string, unknown>)\n  },\n  async compare(a, b) {\n    return {\n      similarity: a === b ? 1 : 0,\n      distance: a === b ? 0 : 1,\n      metric: 'exact-match',\n    }\n  },\n}\n"],"mappings":";AAAA,SAAS,oBAAoB;AAItB,IAAM,eAA0B;AAAA,EACrC,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,MAAM,KAAK,OAAO;AAChB,QAAI,MAAM,UAAU,QAAW;AAC7B,YAAM,IAAI,MAAM,4BAA4B;AAAA,IAC9C;AACA,QAAI;AACJ,QAAI;AACF,eAAS,KAAK,MAAM,MAAM,MAAM,SAAS,MAAM,CAAC;AAAA,IAClD,QAAQ;AACN,YAAM,IAAI,MAAM,gCAAgC;AAAA,IAClD;AACA,WAAO,MAAM,aAAa,KAAK,MAAiC;AAAA,EAClE;AAAA,EACA,MAAM,QAAQ,GAAG,GAAG;AAClB,WAAO;AAAA,MACL,YAAY,MAAM,IAAI,IAAI;AAAA,MAC1B,UAAU,MAAM,IAAI,IAAI;AAAA,MACxB,QAAQ;AAAA,IACV;AAAA,EACF;AACF;","names":[]}