muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/tool-args-hash.ts

@@ -1,221 +0,0 @@
-/**
- * src/orchestrator/tool-args-hash.ts
- *
- * Pure helpers for the tool-pattern loop guard (Fix #1). The guard tracks the
- * last N tool calls in a ring buffer and asks the user when M of them collapse
- * to the same hash — a near-certain signal the agent is fishing the same
- * tool with cosmetic-only argument variations (e.g. `bunx vitest | tail -5`
- * vs `bunx vitest | head -10`).
- *
- * The hash deliberately ignores parts of the arguments that don't change what
- * the tool actually does:
- *
- *   - For `bash`: drop everything after the first unquoted `|` / `>` / `2>`,
- *     strip leading `cd <dir> &&` prefix, collapse whitespace.
- *   - For other tools: stable JSON of sorted keys.
- *
- * Extracted from tool-loop-cap.ts so it can be unit-tested without standing up
- * the full streamText harness.
- */
-
-import { createHash } from "node:crypto";
-
-function sha1(text: string): string {
-  return createHash("sha1").update(text).digest("hex").slice(0, 12);
-}
-
-function stableJson(value: unknown): string {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  const keys = Object.keys(value as Record<string, unknown>).sort();
-  const pairs = keys.map((k) => `${JSON.stringify(k)}:${stableJson((value as Record<string, unknown>)[k])}`);
-  return `{${pairs.join(",")}}`;
-}
-
-/**
- * Tools whose primary work IS the pipe chain — for these the pipe is part of
- * the actual query, not a cosmetic view. `grep -n "foo" f | head -5` vs
- * `grep -n "foo" f | wc -l` ask different questions of the same data;
- * collapsing them was a false-positive in session c8840867dcab where 3
- * legitimately-different grep invocations on src/index.ts tripped the
- * pattern-loop detector (canonical cut after `|` made all 3 hash equal).
- *
- * For these leading tokens we keep the FULL command (still strip leading
- * `cd ... &&` and redirections to disk, just not pipe truncation).
- */
-const PIPE_NATIVE_TOOLS = new Set(["grep", "sed", "awk", "jq", "find", "rg", "xargs", "cut", "tr", "sort", "uniq"]);
-
-/**
- * Verification commands that the agent re-runs as part of a normal
- * edit-typecheck-fix iteration cycle. The pattern detector should NOT count
- * re-runs of these as a loop signal — they are PROGRESS markers, not wandering.
- * Same session c8840867dcab tripped on 3x `bunx tsc --noEmit` between edits.
- *
- * The list intentionally tracks command STARTS (first 1-3 tokens) — once the
- * canonical form starts with any of these, hashToolArgs returns a `verify:`
- * sentinel which the detector ignores.
- */
-const VERIFICATION_COMMAND_PREFIXES = [
-  // bun-family typecheckers & runners
-  "bunx tsc",
-  "bun x tsc",
-  "bun tsc",
-  "tsc --noEmit",
-  "tsc -p",
-  // bunx variants for tools
-  "bunx vitest",
-  "bunx jest",
-  "bunx eslint",
-  "bunx biome",
-  "bunx prettier",
-  "bun test",
-  "bun run test",
-  "bun run lint",
-  "bun run typecheck",
-  "bun run check",
-  "bun run build",
-  // npx variants — Phase 5 BUG-F2 (session c96105db6ab6): agent fell back
-  // to `npx tsc --noEmit` when `bunx tsc` was slow; the npx form was NOT
-  // whitelisted, so repeated runs would have tripped the pattern guard.
-  "npx tsc",
-  "npx vitest",
-  "npx jest",
-  "npx eslint",
-  "npx biome",
-  "npx prettier",
-  "npm test",
-  "npm run test",
-  "npm run lint",
-  "npm run typecheck",
-  "npm run build",
-  "pnpm test",
-  "pnpm lint",
-  "pnpm typecheck",
-  "pnpm build",
-  "pnpm exec tsc",
-  "pnpm exec vitest",
-  "yarn test",
-  "yarn lint",
-  "yarn typecheck",
-  "yarn build",
-  "vitest run",
-  "vitest",
-  "jest",
-  "pytest",
-  "cargo test",
-  "cargo check",
-  "cargo build",
-  "cargo clippy",
-  "go test",
-  "go build",
-  "go vet",
-  "dotnet test",
-  "dotnet build",
-  "mvn test",
-  "gradle test",
-  "biome check",
-  "biome ci",
-  "eslint",
-  "prettier --check",
-  "prettier -c",
-  "ruff check",
-  "mypy",
-  "phpunit",
-  "rspec",
-];
-
-export function isVerificationCommand(canonical: string): boolean {
-  const lower = canonical.toLowerCase().trim();
-  for (const prefix of VERIFICATION_COMMAND_PREFIXES) {
-    if (lower.startsWith(prefix)) return true;
-  }
-  return false;
-}
-
-/**
- * Strip the redirection / pipe suffix and leading `cd` prefix from a bash
- * command so cosmetic variants collapse to the same canonical form.
- *
- * `cd /foo && bunx vitest run | tail -20` → `bunx vitest run`
- * `cd /foo && bunx vitest run 2>&1 | grep FAIL` → `bunx vitest run`
- * `bunx vitest run > /tmp/x.log` → `bunx vitest run`
- *
- * Exception (Phase 5 BUG-F, session c8840867dcab): when the leading command is
- * one of PIPE_NATIVE_TOOLS (grep/sed/awk/...), the pipe IS the query — keep it.
- * Only file redirections (`>`, `>>`, `2>`, `&>`) get cut for those.
- */
-export function canonicalizeBashCommand(command: string): string {
-  let s = command.trim();
-  // Strip leading cd <dir> && prefix (chained directory hops are noise here).
-  // Match `cd <path-or-quoted> && rest` — keep `rest`.
-  const cdMatch = s.match(/^cd\s+(?:"[^"]+"|'[^']+'|\S+)\s*&&\s*([\s\S]+)$/);
-  if (cdMatch) s = cdMatch[1]!.trim();
-
-  // Inspect first token (after optional `time`/env-var prefix) to decide
-  // whether pipes are query-bearing.
-  const firstTokenMatch = s.match(/^(?:time\s+|[A-Z_]+=\S+\s+)*(\S+)/);
-  const firstToken = firstTokenMatch?.[1] ?? "";
-  const pipeNative = PIPE_NATIVE_TOOLS.has(firstToken);
-
-  if (pipeNative) {
-    // Only strip true file redirections (not pipes). Keep the whole pipeline.
-    const cutIdx = s.search(/\s+(?:>|2>|&>|>>)/);
-    if (cutIdx >= 0) s = s.slice(0, cutIdx);
-  } else {
-    // Cut at first unquoted redirection or pipe operator. We don't bother
-    // tracking quote state precisely — false-positive cuts inside quotes only
-    // produce a stricter (more conservative) hash, never a wrong-positive one.
-    const cutIdx = s.search(/\s+(?:\||>|2>|&>|>>)/);
-    if (cutIdx >= 0) s = s.slice(0, cutIdx);
-  }
-  // Collapse internal whitespace runs to a single space.
-  return s.replace(/\s+/g, " ").trim();
-}
-
-/**
- * Compute a short hash for a tool call so the pattern detector can compare
- * "is this the same call again?" without retaining full args in memory.
- *
- * Returns the prefix `<toolName>:` followed by a sha1[0..12) of the canonical
- * form. Same `toolName` with cosmetic-only arg changes hash identically.
- *
- * Special cases beyond the generic JSON hash:
- *
- *   - `bash`: canonical command form (strip pipes/redirects/cd prefix).
- *   - `edit_file` / `write_file`: hash by file_path only — fires when the
- *     agent re-edits the same file with different old_string/new_string
- *     pairs. Observed in session 39884b072b5f where the agent edited
- *     `src/ee/export-transcripts.ts` 7+ times fighting biome auto-format,
- *     each attempt with a different old_string. Generic JSON hash never
- *     collapsed them. Now collapses.
- */
-export function hashToolArgs(toolName: string, args: unknown): string {
-  if (toolName === "bash" && args && typeof args === "object") {
-    const cmd = (args as { command?: unknown }).command;
-    if (typeof cmd === "string") {
-      const canonical = canonicalizeBashCommand(cmd);
-      // Verification commands (typecheck/test/lint) are re-run as part of
-      // normal iteration — return a `verify:` sentinel hash that the detector
-      // recognizes as "skip from loop accounting". Each verify invocation gets
-      // a unique trailing nonce so even back-to-back runs never collide.
-      if (isVerificationCommand(canonical)) {
-        return `verify:${sha1(canonical)}:${Date.now()}:${Math.floor(Math.random() * 1e6)}`;
-      }
-      return `bash:${sha1(canonical)}`;
-    }
-  }
-  if ((toolName === "edit_file" || toolName === "write_file") && args && typeof args === "object") {
-    const filePath = (args as { file_path?: unknown }).file_path;
-    if (typeof filePath === "string") {
-      // Normalize path separators so D:\Personal\... and D:/Personal/... collapse.
-      const normalized = filePath.replace(/\\/g, "/");
-      // Phase 5 BUG-F+G: hash by file_path only — fires when the agent re-edits
-      // the same file with different old_string/new_string pairs. Observed in
-      // session 39884b072b5f where the agent edited the same file 7+ times
-      // fighting biome auto-format. Generic JSON hash kept them distinct;
-      // the dedicated file_path hash now collapses them.
-      return `${toolName}:${sha1(normalized)}`;
-    }
-  }
-  return `${toolName}:${sha1(stableJson(args ?? null))}`;
-}

package/src/orchestrator/tool-args-repair.test.ts

@@ -1,156 +0,0 @@
-/**
- * Regression for Qwen3-30B malformed tool-call args observed in sessions
- *   080fe2fcbf24 and 11bb9218f605 (2026-05-26).
- *
- * Each describe block locks one observed failure mode plus controls that
- * the repair must NOT corrupt valid JSON, ambiguous patterns outside open
- * strings, or unrelated malformations.
- */
-import { describe, expect, it } from "vitest";
-import { _internals, repairToolCallArgs } from "./tool-args-repair.js";
-
-describe("repairToolCallArgs — observed Qwen samples", () => {
-  it("repairs session 11bb9218f605: missing close-quote + trailing brace + </tool_call>", () => {
-    // Raw input as seen in interaction_logs.tool_call.argsPreview for the
-    // 3 consecutive grep failures.
-    const raw = '{"pattern": "catch\\\\s*\\\\{[^}]*\\\\}, "path": "src", "include": "*.ts"}}\n</tool_call>';
-    const result = repairToolCallArgs(raw);
-    if (!result.ok) throw new Error(`expected ok, got: ${JSON.stringify(result)}`);
-    expect(result.value).toEqual({
-      pattern: "catch\\s*\\{[^}]*\\}",
-      path: "src",
-      include: "*.ts",
-    });
-    // Confirm the repair pipeline applied the expected transforms.
-    expect(result.transforms).toContain("strip-native-tags");
-    expect(result.transforms).toContain("strip-trailing-braces");
-    expect(result.transforms).toContain("insert-missing-close-quote");
-  });
-
-  it("repairs session 080fe2fcbf24: missing close-quote + space-after-comma", () => {
-    const raw = '{"pattern": "catch\\\\s*\\\\{\\\\s*\\\\}, "path": ".", "include": "*.ts"}';
-    const result = repairToolCallArgs(raw);
-    if (!result.ok) throw new Error(`expected ok, got: ${JSON.stringify(result)}`);
-    expect(result.value).toEqual({
-      pattern: "catch\\s*\\{\\s*\\}",
-      path: ".",
-      include: "*.ts",
-    });
-    expect(result.transforms).toContain("insert-missing-close-quote");
-  });
-});
-
-describe("repairToolCallArgs — must NOT corrupt valid input", () => {
-  it("returns fast-path with no transforms on already-valid JSON", () => {
-    const valid = '{"pattern": "catch\\\\s*\\\\{[^}]*\\\\}", "path": "src"}';
-    const result = repairToolCallArgs(valid);
-    if (!result.ok) throw new Error("valid JSON must parse on fast path");
-    expect(result.value).toEqual({ pattern: "catch\\s*\\{[^}]*\\}", path: "src" });
-    expect(result.transforms).toEqual([]);
-  });
-
-  it("does not insert a quote when \\\\} appears outside an open string", () => {
-    // Object body contains `\\}` only inside a properly-closed string; the
-    // comma + key that follows is at the top level, not a malformed string.
-    // Note: the input below is intentionally NOT malformed — repair must be
-    // a no-op (initial parse succeeds).
-    const valid = '{"a": "x\\\\}", "b": "y"}';
-    const result = repairToolCallArgs(valid);
-    if (!result.ok) throw new Error("valid JSON must parse");
-    expect(result.transforms).toEqual([]);
-  });
-
-  it("refuses to repair when more than 5 extra trailing braces (input too damaged)", () => {
-    const raw = '{"a": 1}}}}}}}}';
-    const result = repairToolCallArgs(raw);
-    expect(result.ok).toBe(false);
-  });
-
-  it("refuses to repair empty / non-string inputs", () => {
-    expect(repairToolCallArgs("").ok).toBe(false);
-    // @ts-expect-error — runtime guard for non-string
-    expect(repairToolCallArgs(null).ok).toBe(false);
-    // @ts-expect-error — runtime guard for non-string
-    expect(repairToolCallArgs(undefined).ok).toBe(false);
-  });
-
-  it("refuses to repair inputs > 50KB (out-of-scope adversarial)", () => {
-    const big = `{"x": "${"y".repeat(60_000)}"}`;
-    const result = repairToolCallArgs(big);
-    expect(result.ok).toBe(false);
-  });
-
-  it("returns ok=false (not throw) on totally unrelated garbage", () => {
-    expect(repairToolCallArgs("this is not json at all").ok).toBe(false);
-    expect(repairToolCallArgs("<xml>foo</xml>").ok).toBe(false);
-  });
-});
-
-describe("stripNativeFormatLeak", () => {
-  const { stripNativeFormatLeak } = _internals;
-
-  it("strips trailing </tool_call>", () => {
-    expect(stripNativeFormatLeak('{"a": 1}\n</tool_call>')).toBe('{"a": 1}');
-  });
-
-  it("strips trailing </tool_calls> plural variant", () => {
-    expect(stripNativeFormatLeak('{"a": 1}</tool_calls>')).toBe('{"a": 1}');
-  });
-
-  it("strips trailing <|tool_call_end|> Qwen sentinel", () => {
-    expect(stripNativeFormatLeak('{"a": 1}<|tool_call_end|>')).toBe('{"a": 1}');
-  });
-
-  it("only strips at end — interior occurrences are preserved (data, not control)", () => {
-    expect(stripNativeFormatLeak('{"description": "see </tool_call> in docs"}')).toBe(
-      '{"description": "see </tool_call> in docs"}',
-    );
-  });
-
-  it("is case-insensitive on the tag", () => {
-    expect(stripNativeFormatLeak('{"a": 1}</TOOL_CALL>')).toBe('{"a": 1}');
-  });
-});
-
-describe("stripUnbalancedTrailingBraces", () => {
-  const { stripUnbalancedTrailingBraces } = _internals;
-
-  it("strips a single extra trailing brace", () => {
-    expect(stripUnbalancedTrailingBraces('{"a": 1}}')).toBe('{"a": 1}');
-  });
-
-  it("does not strip when braces are balanced", () => {
-    expect(stripUnbalancedTrailingBraces('{"a": {"b": 1}}')).toBe('{"a": {"b": 1}}');
-  });
-
-  it("does not count braces inside string values", () => {
-    // 2 `{` open, 1 `}` close, plus literal `{` in string — must NOT touch.
-    expect(stripUnbalancedTrailingBraces('{"x": "{{{"}')).toBe('{"x": "{{{"}');
-  });
-
-  it("respects escape sequences inside strings", () => {
-    // `\\}` inside a string is one regex character, not a brace.
-    expect(stripUnbalancedTrailingBraces('{"x": "a\\\\}b"}')).toBe('{"x": "a\\\\}b"}');
-  });
-});
-
-describe("insertMissingCloseQuote", () => {
-  const { insertMissingCloseQuote } = _internals;
-
-  it('inserts close-quote after \\\\} when followed by `, "key"`', () => {
-    const before = '{"a": "x\\\\}, "b": 1}';
-    const after = insertMissingCloseQuote(before);
-    expect(after).toBe('{"a": "x\\\\}", "b": 1}');
-  });
-
-  it("handles \\\\] terminator", () => {
-    const before = '{"a": "x\\\\], "b": 1}';
-    const after = insertMissingCloseQuote(before);
-    expect(after).toBe('{"a": "x\\\\]", "b": 1}');
-  });
-
-  it("returns input unchanged when no inside-string match", () => {
-    const balanced = '{"a": "x", "b": 1}';
-    expect(insertMissingCloseQuote(balanced)).toBe(balanced);
-  });
-});

package/src/orchestrator/tool-args-repair.ts

@@ -1,227 +0,0 @@
-/**
- * src/orchestrator/tool-args-repair.ts
- *
- * Conservative repair for malformed tool-call argument strings emitted by
- * models whose tokenization breaks structured JSON. Two distinct Qwen3-30B
- * defects observed in sessions 080fe2fcbf24 and 11bb9218f605 (2026-05-26):
- *
- *   1. Native-format leak — Qwen's `<tool_call>...</tool_call>` tags and
- *      extra trailing `}` leak into the OpenAI-compatible `arguments`
- *      string field:
- *         {"pattern": "..."}}
- *         </tool_call>
- *
- *   2. Missing close-quote — when a string value ends with an escape
- *      sequence like `\\}` (regex), the model drops the closing `"`:
- *         {"pattern": "catch\\s*\\{\\s*\\}, "path": "src", ...}
- *      Intended:
- *         {"pattern": "catch\\s*\\{\\s*\\}", "path": "src", ...}
- *
- * The repair function is intentionally narrow: it only modifies inputs that
- * FAIL JSON.parse, and only applies the two specific transforms above. If
- * the post-transform string still fails to parse, return null so the caller
- * (AI SDK's repairToolCall hook) falls through to InvalidToolInputError.
- *
- * Tests live in tool-args-repair.test.ts and pin both observed samples
- * plus a control "valid JSON is never modified" assertion.
- */
-
-const MAX_INPUT_LENGTH = 50_000;
-const MAX_TRAILING_BRACE_STRIPS = 5;
-
-/**
- * Try to recover a JSON object from a malformed tool-call argument string.
- *
- * Returns:
- *   - { ok: true, value, transforms } when JSON.parse succeeds after repair
- *     (or initially — same fast-path return so callers can be uniform).
- *   - { ok: false } when the string still fails to parse after all
- *     conservative transforms. Caller should report tool-error.
- */
-export type RepairResult = { ok: true; value: unknown; transforms: string[] } | { ok: false };
-
-export function repairToolCallArgs(raw: string): RepairResult {
-  if (typeof raw !== "string" || raw.length === 0) return { ok: false };
-  if (raw.length > MAX_INPUT_LENGTH) return { ok: false };
-
-  // Fast path: already valid JSON.
-  const initial = tryParse(raw);
-  if (initial.ok) return { ok: true, value: initial.value, transforms: [] };
-
-  let working = raw;
-  const transforms: string[] = [];
-
-  // (1) Strip Qwen native-format suffix garbage. Multiple leak shapes seen.
-  const stripped = stripNativeFormatLeak(working);
-  if (stripped !== working) {
-    working = stripped;
-    transforms.push("strip-native-tags");
-    const after = tryParse(working);
-    if (after.ok) return { ok: true, value: after.value, transforms };
-  }
-
-  // (2) Insert missing close-quote after escape-sequence end. The pattern
-  // we've seen is `\\}, "key":` — string ended with a `\\}` (escaped brace
-  // inside a regex) and the model dropped the closing `"`. Same logic
-  // applies to `\\]`, `\\)`, `\\>` and other escape-bracket-close sequences.
-  //
-  // Runs BEFORE strip-trailing-braces because the missing quote confuses the
-  // brace counter (it thinks the trailing `}}` is inside an open string).
-  const quoteFixed = insertMissingCloseQuote(working);
-  if (quoteFixed !== working) {
-    working = quoteFixed;
-    transforms.push("insert-missing-close-quote");
-    const after = tryParse(working);
-    if (after.ok) return { ok: true, value: after.value, transforms };
-  }
-
-  // (3) Balance trailing braces. Models often emit one extra closing `}`.
-  // Now safe to run because quote fixup put the string boundaries back so
-  // the brace counter walks the structure correctly.
-  const balanced = stripUnbalancedTrailingBraces(working);
-  if (balanced !== working) {
-    working = balanced;
-    transforms.push("strip-trailing-braces");
-    const after = tryParse(working);
-    if (after.ok) return { ok: true, value: after.value, transforms };
-  }
-
-  return { ok: false };
-}
-
-function tryParse(text: string): { ok: true; value: unknown } | { ok: false } {
-  try {
-    return { ok: true, value: JSON.parse(text) };
-  } catch {
-    return { ok: false };
-  }
-}
-
-/**
- * Strip Qwen native chat-format leakage that appears in OpenAI-compatible
- * `arguments` strings. Patterns observed:
- *   - trailing `</tool_call>` literal
- *   - trailing `</tool_calls>` literal (plural variant)
- *   - trailing `<|tool_call_end|>` sentinel
- *   - whitespace + extra newlines after either of the above
- * Strips ONLY at the trailing end. Body of the JSON is not touched, so
- * legitimate strings that happen to contain `<tool_call>` as data are safe.
- */
-function stripNativeFormatLeak(s: string): string {
-  return s.replace(/\s*(?:<\/tool_calls?>|<\|tool_call(?:_end)?\|>)\s*$/i, "");
-}
-
-/**
- * If the string has more closing `}` than opening `{`, strip trailing `}`
- * one at a time (skipping whitespace) until balanced — but only up to
- * MAX_TRAILING_BRACE_STRIPS so a wildly malformed string doesn't get
- * gutted. The check is naive (doesn't track string vs object braces) which
- * is OK because we only run this when the original parse already failed.
- */
-function stripUnbalancedTrailingBraces(s: string): string {
-  let open = 0;
-  let close = 0;
-  let inString = false;
-  let escaped = false;
-  for (const ch of s) {
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (ch === '"') {
-      inString = !inString;
-      continue;
-    }
-    if (inString) continue;
-    if (ch === "{") open++;
-    else if (ch === "}") close++;
-  }
-  let extra = close - open;
-  if (extra <= 0) return s;
-  if (extra > MAX_TRAILING_BRACE_STRIPS) return s; // too damaged, refuse
-  let out = s;
-  while (extra > 0) {
-    const trimmed = out.replace(/\s+$/, "");
-    if (!trimmed.endsWith("}")) break;
-    out = trimmed.slice(0, -1);
-    extra--;
-  }
-  return out;
-}
-
-/**
- * Insert a missing close-quote on the value of a JSON key=value pair where
- * the model emitted an escape sequence as the final visible characters
- * before the next key. Pattern:
- *   ...\\X,  "next-key":...
- * where X is `}`, `]`, `)`, `>` or another `\\` — i.e. characters that the
- * tokenizer treats as escape-sequence terminators. The fix inserts `"`
- * between the escape and the comma:
- *   ...\\X",  "next-key":...
- *
- * Refuses to fire when the input already contains a balanced quote count
- * preceding the comma — that means the failure is something other than a
- * missing close-quote and our naive insert would corrupt valid JSON.
- *
- * The regex is anchored to "comma + maybe-whitespace + ASCII-key-start"
- * which strongly suggests a JSON-object key boundary, not arbitrary text.
- */
-function insertMissingCloseQuote(s: string): string {
-  // Match: backslash-sequence (\\X), optional space, comma, optional space,
-  // quote, ASCII key letter. Captures the escape so we can re-emit it +
-  // an inserted close-quote.
-  // Char class members: `}`, `]` (escaped), `)`, `>`, `\` (escaped).
-  const pattern = /(\\\\[}\])>\\])(\s*,\s*)("[A-Za-z_])/g;
-  const out = s;
-  let lastIndex = 0;
-  let result = "";
-  let matched = false;
-  pattern.lastIndex = 0;
-  // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex.exec loop
-  let m: RegExpExecArray | null;
-  while ((m = pattern.exec(out)) !== null) {
-    // Safety: only fire when the prefix has ODD number of unescaped quotes
-    // (i.e. we're inside an open string). Otherwise valid JSON containing
-    // `\\}` followed by a comma would get corrupted.
-    const prefix = out.slice(0, m.index);
-    if (!isInsideOpenString(prefix)) continue;
-    result += out.slice(lastIndex, m.index) + m[1] + '"' + m[2] + m[3];
-    lastIndex = m.index + m[0].length;
-    matched = true;
-  }
-  if (!matched) return s;
-  result += out.slice(lastIndex);
-  return result;
-}
-
-/**
- * True iff `prefix` has an odd number of un-escaped `"` characters — i.e.
- * the next character would be inside an open JSON string.
- */
-function isInsideOpenString(prefix: string): boolean {
-  let count = 0;
-  let escaped = false;
-  for (const ch of prefix) {
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (ch === '"') count++;
-  }
-  return count % 2 === 1;
-}
-
-export const _internals = {
-  stripNativeFormatLeak,
-  stripUnbalancedTrailingBraces,
-  insertMissingCloseQuote,
-  isInsideOpenString,
-};