tryharness 0.7.22 → 0.7.25

package/lib/trails.mjs

@@ -0,0 +1,401 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+
+// What a coding session actually did, read from the agent's own session file: the person's first request, every tool
+// call in order (the paths it named, the files it changed, commands with their exit codes) and the tokens each model
+// call used. This is the record the context engine learns from (what a run needed against what its brief carried) and
+// the evidence receipts check claims against. Read only; the parsers never decide anything about intent.
+
+const PATH_TOKEN =
+  /(?:\.{0,2}\/)?[\w@+-][\w@+.-]*(?:\/[\w@+.-]+)+|[\w@+-][\w@+-]*\.[A-Za-z][A-Za-z0-9]{0,7}\b/g;
+const PATCH_FILE = /\*\*\* (?:Update|Add|Delete) File: ([^\n"\\]+)/g;
+const REDIRECT_FILE =
+  /(?:^|[\s;&|])(?:>>?|tee(?:\s+-a)?)\s+(["']?)([^\s"'|;&<>]+)\1/g;
+const SED_INPLACE =
+  /\bsed\s+(?:-[a-zA-Z]*i[a-zA-Z]*(?:\s+''|\s+"")?|--in-place)\b[^|;&]*?\s(["']?)([^\s"'|;&]+)\1\s*(?:$|[|;&])/gm;
+// Test runners by their command, for receipts: a command's own exit code is the evidence, never the agent's words.
+const TEST_COMMAND =
+  /\b(?:npm(?:\s+run)?\s+(?:test|smoke|e2e|eval|lint|typecheck)|npx\s+(?:jest|vitest|tsx\s+tests\/|playwright\s+test)|jest|vitest|pytest|cargo\s+(?:test|check|clippy)|go\s+test|forge\s+test|bun\s+test|deno\s+test|swift\s+test|mvn\s+test|gradlew?\s+test|make\s+(?:test|check)|node\s+(?:--test\b|[\w./-]*\btests?\/)|tsc(?:\s|$))/;
+const EDIT_TOOLS = new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "edit",
+  "write",
+  "apply_patch",
+]);
+const BRIEF_SKIP =
+  /^<(?:command-|local-command|system-reminder|task-notification|user-prompt-submit-hook)|^Caveat:/;
+
+const parseJson = (line) => {
+  try {
+    const value = JSON.parse(line);
+    return value && typeof value === "object" ? value : null;
+  } catch {
+    return null;
+  }
+};
+const textOf = (content) =>
+  typeof content === "string"
+    ? content
+    : Array.isArray(content)
+      ? content
+          .map((part) => (typeof part?.text === "string" ? part.text : ""))
+          .filter(Boolean)
+          .join("\n")
+      : "";
+const ms = (value) => {
+  const at =
+    typeof value === "number"
+      ? value * (value < 1e12 ? 1000 : 1)
+      : Date.parse(value);
+  return Number.isFinite(at) ? at : null;
+};
+
+/** Path-like words in a tool call's input or output, as written (relative or absolute). */
+export function pathTokens(text) {
+  return [...new Set(String(text).match(PATH_TOKEN) || [])]
+    .map((token) => token.replace(/[.,:;)\]}'"`]+$/, ""))
+    .filter((token) => token.length > 2 && token.length < 300);
+}
+
+/** Files a tool call changed: edit tools' own paths, patch headers, sed -i, redirects and tee. */
+export function editedPaths(tool, input) {
+  const out = new Set();
+  if (EDIT_TOOLS.has(tool) && typeof input?.file_path === "string")
+    out.add(input.file_path);
+  if (EDIT_TOOLS.has(tool) && typeof input === "string") {
+    const found = input.match(/"(?:file_path|path)":"([^"]+)"/);
+    if (found && !found[1].endsWith("…")) out.add(found[1]);
+  }
+  if (EDIT_TOOLS.has(tool) && typeof input?.path === "string")
+    out.add(input.path);
+  if (tool === "NotebookEdit" && typeof input?.notebook_path === "string")
+    out.add(input.notebook_path);
+  const text =
+    typeof input === "string"
+      ? input
+      : JSON.stringify(input ?? "")
+          .replace(/\\n/g, "\n")
+          .replace(/\\"/g, '"');
+  for (const match of text.matchAll(PATCH_FILE)) out.add(match[1].trim());
+  for (const match of text.matchAll(SED_INPLACE)) out.add(match[2]);
+  for (const match of text.matchAll(REDIRECT_FILE))
+    if (!/^\/dev\/|^&\d$/.test(match[2])) out.add(match[2]);
+  return [...out];
+}
+
+export const isTestCommand = (command) => TEST_COMMAND.test(String(command));
+
+function exitCodeOf(text) {
+  const found = String(text).match(
+    /"?exit_code"?\s*[:=]\s*(-?\d+)|Exit code:?\s*(-?\d+)|Process exited with code (-?\d+)/i
+  );
+  return found ? Number(found[1] ?? found[2] ?? found[3]) : null;
+}
+
+/**
+ * A session's trail: { agent, sessionId, cwd, brief, startedAt, endedAt, calls, usage, turns }. A call is
+ * { at, tool, input (clipped text), named (path words), edited (paths), command, exitCode, error }; usage is one row
+ * per model call { at, input, cached, output }; turns are the person's messages and stops, { at, interrupted }. Claude Code and Codex are read in full; other agents fall back to none.
+ */
+export async function readTrail(agent, file) {
+  if (!["claude-code", "codex"].includes(agent) || !fs.existsSync(file))
+    return null;
+  const trail = {
+    agent,
+    sessionId: null,
+    cwd: null,
+    brief: null,
+    startedAt: null,
+    endedAt: null,
+    calls: [],
+    usage: [],
+    turns: [],
+  };
+  const byId = new Map();
+  const add = (at, tool, input, id) => {
+    const text =
+      typeof input === "string" ? input : JSON.stringify(input ?? {});
+    const command =
+      typeof input?.command === "string"
+        ? input.command
+        : Array.isArray(input?.command)
+          ? input.command.join(" ")
+          : typeof input?.cmd === "string"
+            ? input.cmd
+            : [...text.matchAll(/cmd\s*:\s*"((?:[^"\\]|\\.)*)"/g)]
+                .map((match) => match[1])
+                .join("\n") || null;
+    const call = {
+      at,
+      tool,
+      input: text.slice(0, 4_000),
+      named: pathTokens(text),
+      edited: editedPaths(tool, input),
+      command,
+      exitCode: null,
+      error: false,
+      output: "",
+    };
+    trail.calls.push(call);
+    if (id) byId.set(id, call);
+  };
+  const result = (id, text, error) => {
+    const call = byId.get(id);
+    if (!call) return;
+    call.output = String(text).slice(0, 4_000);
+    call.named = [
+      ...new Set([...call.named, ...pathTokens(String(text).slice(0, 20_000))]),
+    ];
+    call.exitCode = exitCodeOf(text);
+    call.error =
+      Boolean(error) || (call.exitCode !== null && call.exitCode !== 0);
+  };
+  const lines = readline.createInterface({
+    input: fs.createReadStream(file, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+  for await (const line of lines) {
+    const row = parseJson(line);
+    if (!row) continue;
+    const at = ms(row.timestamp ?? row.payload?.timestamp);
+    if (at) {
+      trail.startedAt ??= at;
+      trail.endedAt = at;
+    }
+    if (agent === "claude-code") {
+      trail.sessionId ??= row.sessionId ?? null;
+      trail.cwd ??= row.cwd ?? null;
+      const content = row.message?.content;
+      if (row.type === "user" && !row.isMeta) {
+        const words = (
+          typeof content === "string"
+            ? content
+            : Array.isArray(content) &&
+                !content.some((part) => part?.type === "tool_result")
+              ? textOf(content)
+              : ""
+        ).trim();
+        // The person's turns: each message starts one; Esc leaves "[Request interrupted by user...]" where it stopped one.
+        if (words.startsWith("[Request interrupted by user"))
+          trail.turns.push({ at, interrupted: true });
+        else if (words && !BRIEF_SKIP.test(words)) {
+          trail.turns.push({ at, interrupted: false });
+          trail.brief ??= words;
+        }
+      }
+      if (Array.isArray(content))
+        for (const part of content) {
+          if (part?.type === "tool_use")
+            add(at, part.name, part.input, part.id);
+          if (part?.type === "tool_result")
+            result(
+              part.tool_use_id,
+              textOf(part.content) || JSON.stringify(row.toolUseResult ?? ""),
+              part.is_error
+            );
+        }
+      const usage = row.type === "assistant" ? row.message?.usage : null;
+      if (usage)
+        trail.usage.push({
+          at,
+          input:
+            (usage.input_tokens || 0) +
+            (usage.cache_creation_input_tokens || 0) +
+            (usage.cache_read_input_tokens || 0),
+          cached: usage.cache_read_input_tokens || 0,
+          output: usage.output_tokens || 0,
+        });
+    } else {
+      const payload = row.payload ?? {};
+      if (row.type === "session_meta") {
+        trail.sessionId ??= payload.id ?? null;
+        trail.cwd ??= payload.cwd ?? null;
+      }
+      if (
+        row.type === "response_item" &&
+        payload.type === "message" &&
+        payload.role === "user"
+      ) {
+        const words = textOf(payload.content).trim();
+        if (
+          words &&
+          !/^<(?:environment_context|user_instructions|permissions|turn_aborted)/.test(
+            words
+          ) &&
+          !words.startsWith("# AGENTS.md")
+        ) {
+          trail.turns.push({ at, interrupted: false });
+          trail.brief ??= words;
+        }
+      }
+      if (
+        row.type === "event_msg" &&
+        payload.type === "turn_aborted" &&
+        payload.reason === "interrupted"
+      )
+        trail.turns.push({ at, interrupted: true });
+      if (
+        row.type === "response_item" &&
+        ["function_call", "custom_tool_call", "local_shell_call"].includes(
+          payload.type
+        )
+      ) {
+        const input =
+          payload.input ??
+          parseJson(payload.arguments) ??
+          payload.arguments ??
+          payload.action;
+        add(at, payload.name ?? payload.type, input, payload.call_id);
+      }
+      if (
+        row.type === "response_item" &&
+        ["function_call_output", "custom_tool_call_output"].includes(
+          payload.type
+        )
+      ) {
+        const text =
+          typeof payload.output === "string"
+            ? payload.output
+            : textOf(payload.output) || JSON.stringify(payload.output ?? "");
+        result(payload.call_id, text, false);
+      }
+      if (row.type === "token_usage_record" && payload.usage)
+        trail.usage.push({
+          at,
+          input: payload.usage.input_tokens || 0,
+          cached: payload.usage.cached_input_tokens || 0,
+          output: payload.usage.output_tokens || 0,
+        });
+    }
+  }
+  return trail;
+}
+
+const RESULT_EDIT =
+  /(?:The file (\S+) has been (?:updated|created)|File created successfully at: (\S+?)[\s)\]])/g;
+
+/**
+ * A trail rebuilt from the relay's own copy of a session (store.mjs keeps every message with tool calls clipped), for
+ * sessions whose source file the agent has since deleted. It has the brief, the calls with the paths they named and the
+ * files they changed (the edit tools' own confirmations carry the whole path), but no token counts or timestamps.
+ */
+export function trailFromTranscript(
+  agent,
+  transcript,
+  { cwd = null, startedAt = null } = {}
+) {
+  const trail = {
+    agent,
+    sessionId: null,
+    cwd,
+    brief: null,
+    startedAt,
+    endedAt: startedAt,
+    calls: [],
+    usage: [],
+  };
+  for (const block of String(transcript).split(/\n\n(?=(?:User|Agent): )/)) {
+    const user = block.startsWith("User: ");
+    const text = block.replace(/^(?:User|Agent): /, "");
+    if (
+      user &&
+      !trail.brief &&
+      !text.startsWith("[tool result") &&
+      !BRIEF_SKIP.test(text.trim()) &&
+      !text.includes("<local-command-caveat>")
+    )
+      trail.brief = text.trim();
+    for (const match of text.matchAll(/\[tool: (\S+) ([\s\S]*?)\](?=\n|$)/g)) {
+      trail.calls.push({
+        at: null,
+        tool: match[1],
+        input: match[2],
+        named: pathTokens(match[2]),
+        edited: editedPaths(match[1], match[2]).filter(
+          (file) => !file.endsWith("…")
+        ),
+        command: null,
+        exitCode: null,
+        error: false,
+        output: "",
+      });
+    }
+    if (user && text.startsWith("[tool result")) {
+      const last = trail.calls.at(-1);
+      if (!last) continue;
+      last.named = [...new Set([...last.named, ...pathTokens(text)])];
+      for (const match of text.matchAll(RESULT_EDIT))
+        last.edited = [...new Set([...last.edited, match[1] || match[2]])];
+    }
+  }
+  return trail;
+}
+
+/** A path as written in a call, made relative to root when it lies inside it; null when it points elsewhere. */
+export function insideRoot(token, root, cwd = root) {
+  const absolute = path.isAbsolute(token)
+    ? token
+    : path.resolve(cwd || root, token);
+  const rel = path.relative(root, absolute);
+  return rel && !rel.startsWith("..") && !path.isAbsolute(rel)
+    ? rel.split(path.sep).join("/")
+    : null;
+}
+
+/**
+ * What a trail shows a run needed, against the files that existed: { edited, read, firstEditAt, beforeFirstEdit }.
+ * `read` is every existing file the run named before its first edit (opened, listed, grepped into); `beforeFirstEdit`
+ * counts the calls and tokens spent before that edit, which is what a better brief can save.
+ */
+export function needs(trail, root, files) {
+  const known = (token) => {
+    const rel = insideRoot(token, root, trail.cwd);
+    return rel && files.has(rel) ? rel : null;
+  };
+  const edited = new Set();
+  const read = new Set();
+  let firstEditAt = null;
+  let editing = false;
+  let callsBefore = 0;
+  for (const call of trail.calls) {
+    const changed = call.edited.map(known).filter(Boolean);
+    if (changed.length && !editing) {
+      editing = true;
+      firstEditAt = call.at;
+    }
+    for (const file of changed) edited.add(file);
+    if (!editing) {
+      callsBefore += 1;
+      for (const token of call.named) {
+        const file = known(token);
+        if (file) read.add(file);
+      }
+    }
+  }
+  const before = trail.usage.filter(
+    (row) => !editing || firstEditAt === null || (row.at ?? 0) < firstEditAt
+  );
+  return {
+    edited: [...edited],
+    read: [...read],
+    firstEditAt,
+    beforeFirstEdit: {
+      calls: callsBefore,
+      modelCalls: before.length,
+      inputTokens: before.reduce((sum, row) => sum + row.input, 0),
+      uncachedInputTokens: before.reduce(
+        (sum, row) => sum + Math.max(0, row.input - row.cached),
+        0
+      ),
+      outputTokens: before.reduce((sum, row) => sum + row.output, 0),
+      ms:
+        firstEditAt !== null && trail.startedAt !== null
+          ? firstEditAt - trail.startedAt
+          : null,
+    },
+  };
+}

package/lib/ui.mjs

@@ -6,9 +6,17 @@ import pc from "picocolors";
 // menus, spinners while waiting. createUi draws it; scriptedUi answers from a list and keeps what a person would have
 // seen, for tests. Prompts return null when the person cancels (Ctrl-C), so setup can skip that part and go on.
 
-const unicode = process.platform !== "win32" || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode";
+const unicode =
+  process.platform !== "win32" ||
+  Boolean(process.env.WT_SESSION) ||
+  process.env.TERM_PROGRAM === "vscode";
 const glyph = (fancy, plain) => (unicode ? fancy : plain);
-const BAR = glyph("│", "|"), END = glyph("└", "—"), ACTIVE = glyph("◆", "*"), DONE = glyph("◇", "o"), STOP = glyph("■", "x"), WARN = glyph("▲", "!");
+const BAR = glyph("│", "|"),
+  END = glyph("└", "—"),
+  ACTIVE = glyph("◆", "*"),
+  DONE = glyph("◇", "o"),
+  STOP = glyph("■", "x"),
+  WARN = glyph("▲", "!");
 
 const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").length;
 
@@ -16,10 +24,15 @@ const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").length;
 export function wrap(text, width) {
   return text.split("\n").flatMap((line) => {
     if (!line.trim()) return [""];
-    const indent = " ".repeat(line.length - line.trimStart().length), room = Math.max(20, width - indent.length), rows = [];
+    const indent = " ".repeat(line.length - line.trimStart().length),
+      room = Math.max(20, width - indent.length),
+      rows = [];
     let row = "";
     for (const word of line.trim().split(" ")) {
-      if (row && visible(row) + 1 + visible(word) > room) { rows.push(row); row = word; } else row = row ? `${row} ${word}` : word;
+      if (row && visible(row) + 1 + visible(word) > room) {
+        rows.push(row);
+        row = word;
+      } else row = row ? `${row} ${word}` : word;
     }
     return [...rows, row].map((part) => `${indent}${part}`);
   });
@@ -33,16 +46,24 @@ export const columns = () => process.stdout.columns || 100;
 async function waitOrType({ message, placeholder, until }) {
   const stop = new AbortController();
   let done = null;
-  void until.then((result) => { done = result; stop.abort(); });
+  void until.then((result) => {
+    done = result;
+    stop.abort();
+  });
   const value = await new TextPrompt({
     placeholder,
     signal: stop.signal,
     render() {
       const head = (symbol) => `${pc.gray(BAR)}\n${symbol}  ${message}\n`;
-      if (this.state === "submit") return `${head(pc.green(DONE))}${pc.gray(BAR)}  ${pc.dim(this.value || "keep waiting")}`;
-      if (this.state === "cancel" && done) return `${pc.gray(BAR)}\n${done.ok ? pc.green(DONE) : pc.yellow(WARN)}  ${done.line}`;
-      if (this.state === "cancel") return `${head(pc.red(STOP))}${pc.gray(BAR)}  ${pc.dim("stopped")}`;
-      const shown = this.value ? this.valueWithCursor : `${pc.inverse(placeholder[0])}${pc.dim(placeholder.slice(1))}`;
+      if (this.state === "submit")
+        return `${head(pc.green(DONE))}${pc.gray(BAR)}  ${pc.dim(this.value || "keep waiting")}`;
+      if (this.state === "cancel" && done)
+        return `${pc.gray(BAR)}\n${done.ok ? pc.green(DONE) : pc.yellow(WARN)}  ${done.line}`;
+      if (this.state === "cancel")
+        return `${head(pc.red(STOP))}${pc.gray(BAR)}  ${pc.dim("stopped")}`;
+      const shown = this.value
+        ? this.valueWithCursor
+        : `${pc.inverse(placeholder[0])}${pc.dim(placeholder.slice(1))}`;
       return `${head(pc.cyan(ACTIVE))}${pc.cyan(BAR)}  ${shown}\n${pc.cyan(END)}\n`;
     },
   }).prompt();
@@ -51,7 +72,9 @@ async function waitOrType({ message, placeholder, until }) {
   return { value: String(value ?? "").trim() };
 }
 
-export function createUi({ interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
+export function createUi({
+  interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+} = {}) {
   const answer = (value) => (p.isCancel(value) ? null : value);
   // clack does not wrap; a long line would run back to the left edge, off the rail.
   const fit = (text) => wrap(text, columns() - 4).join("\n");
@@ -72,12 +95,24 @@ export function createUi({ interactive = Boolean(process.stdin.isTTY && process.
     // clack's spinner stops on Ctrl-C but keeps the process alive; setup ends there instead. Without a terminal (piped
     // or logged) it is two plain lines, not animation frames.
     spinner: () => {
-      if (!process.stdout.isTTY) return { start: (text) => p.log.message(fit(text)), message: () => {}, stop: (text, code) => (code ? p.log.warn : p.log.step)(fit(text)) };
-      const spin = p.spinner(), quit = () => process.exit(130);
+      if (!process.stdout.isTTY)
+        return {
+          start: (text) => p.log.message(fit(text)),
+          message: () => {},
+          stop: (text, code) => (code ? p.log.warn : p.log.step)(fit(text)),
+        };
+      const spin = p.spinner(),
+        quit = () => process.exit(130);
       return {
-        start: (text) => { spin.start(text); process.once("SIGINT", quit); },
+        start: (text) => {
+          spin.start(text);
+          process.once("SIGINT", quit);
+        },
         message: (text) => spin.message(text),
-        stop: (text, code) => { process.removeListener("SIGINT", quit); spin.stop(text, code); },
+        stop: (text, code) => {
+          process.removeListener("SIGINT", quit);
+          spin.stop(text, code);
+        },
       };
     },
     waitOrType,
@@ -86,19 +121,56 @@ export function createUi({ interactive = Boolean(process.stdin.isTTY && process.
 
 /** The same interface answered from `answers` in order (undefined takes the default); `lines` is what was shown. */
 export function scriptedUi(answers = [], lines = []) {
-  const say = (symbol) => (text) => { lines.push(...`${symbol} ${text}`.split("\n")); };
-  const next = (fallback) => { const value = answers.shift(); return value === undefined ? fallback : value; };
-  const ask = async (opts) => { lines.push(`? ${opts.message}`); const value = next(null); if (value !== null) lines.push(`  ${value}`); return value; };
+  const say = (symbol) => (text) => {
+    lines.push(...`${symbol} ${text}`.split("\n"));
+  };
+  const next = (fallback) => {
+    const value = answers.shift();
+    return value === undefined ? fallback : value;
+  };
+  const ask = async (opts) => {
+    lines.push(`? ${opts.message}`);
+    const value = next(null);
+    if (value !== null) lines.push(`  ${value}`);
+    return value;
+  };
   return {
     interactive: true,
     lines,
-    intro: say("┌"), outro: say("└"), step: say("◇"), success: say("◆"), info: say("●"), warn: say("▲"), message: say("│"),
-    note: (text, title) => { lines.push(`[${title}]`, ...text.split("\n")); },
-    select: async (opts) => { lines.push(`? ${opts.message}`, ...opts.options.map((option) => `  ${option.label}${option.hint ? ` (${option.hint})` : ""}`)); return next(opts.initialValue ?? opts.options[0].value); },
+    intro: say("┌"),
+    outro: say("└"),
+    step: say("◇"),
+    success: say("◆"),
+    info: say("●"),
+    warn: say("▲"),
+    message: say("│"),
+    note: (text, title) => {
+      lines.push(`[${title}]`, ...text.split("\n"));
+    },
+    select: async (opts) => {
+      lines.push(
+        `? ${opts.message}`,
+        ...opts.options.map(
+          (option) =>
+            `  ${option.label}${option.hint ? ` (${option.hint})` : ""}`
+        )
+      );
+      return next(opts.initialValue ?? opts.options[0].value);
+    },
     text: ask,
-    password: async (opts) => { lines.push(`? ${opts.message}`); return next(null); },
-    confirm: async (opts) => { lines.push(`? ${opts.message}`); return next(opts.initialValue ?? true); },
-    spinner: () => ({ start: say("◒"), message: () => {}, stop: (text, code = 0) => say(code ? "▲" : "◇")(text) }),
+    password: async (opts) => {
+      lines.push(`? ${opts.message}`);
+      return next(null);
+    },
+    confirm: async (opts) => {
+      lines.push(`? ${opts.message}`);
+      return next(opts.initialValue ?? true);
+    },
+    spinner: () => ({
+      start: say("◒"),
+      message: () => {},
+      stop: (text, code = 0) => say(code ? "▲" : "◇")(text),
+    }),
     waitOrType: async ({ message, until }) => {
       lines.push(`? ${message}`);
       const value = next("");

package/lib/vectors.mjs

@@ -3,7 +3,8 @@
 // entries, not millions, so a scan is the right index until one outgrows it.
 
 export function cosine(a, b) {
-  if (a.length !== b.length) throw new Error(`vector lengths differ: ${a.length} and ${b.length}`);
+  if (a.length !== b.length)
+    throw new Error(`vector lengths differ: ${a.length} and ${b.length}`);
   let dot = 0;
   let na = 0;
   let nb = 0;
@@ -36,7 +37,9 @@ export function toBlob(vector) {
 
 /** Buffer (or Uint8Array) from SQLite -> Float32Array (a copy). */
 export function fromBlob(blob) {
-  const bytes = Buffer.isBuffer(blob) ? blob : Buffer.from(blob.buffer, blob.byteOffset, blob.byteLength);
+  const bytes = Buffer.isBuffer(blob)
+    ? blob
+    : Buffer.from(blob.buffer, blob.byteOffset, blob.byteLength);
   const out = new Float32Array(bytes.length / 4);
   for (let i = 0; i < out.length; i += 1) out[i] = bytes.readFloatLE(i * 4);
   return out;