@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-J3PCRUVY.js

@@ -1,1223 +0,0 @@
-import {
-  test_red
-} from "./chunk-RWYSVFIA.js";
-import {
-  related_heavy_tests
-} from "./chunk-MNLHYAJO.js";
-import {
-  direct_importers
-} from "./chunk-N4EMFHQ6.js";
-import {
-  test_pinned_logic,
-  test_pinned_stage
-} from "./chunk-RAQ3E6OT.js";
-import {
-  test_pinned_cache_logic,
-  test_pinned_reach
-} from "./chunk-6FN37DER.js";
-import {
-  related_scope
-} from "./chunk-KJPZPTS4.js";
-import {
-  review_code_tree
-} from "./chunk-FDASVHZD.js";
-import {
-  test_unit_guard
-} from "./chunk-KWLNK2NJ.js";
-import {
-  gate_log
-} from "./chunk-VCWNMRH7.js";
-import {
-  run_record_path
-} from "./chunk-WL5JHB3I.js";
-import {
-  config_fingerprint,
-  test_runner_config
-} from "./chunk-EHPTXSAT.js";
-import {
-  import_graph
-} from "./chunk-4IDINPBE.js";
-import {
-  input_fingerprint
-} from "./chunk-GA2YSPFH.js";
-import {
-  base_tree
-} from "./chunk-NTIVNQKF.js";
-import {
-  lane_ledger_pinned_origin
-} from "./chunk-Y2RNUX4W.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  unit_worker_share
-} from "./chunk-B73IIRMS.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-import {
-  lane_paths
-} from "./chunk-G75GWNNY.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  atomic_write
-} from "./chunk-KSR23NYN.js";
-import {
-  changed_paths
-} from "./chunk-U5EO4QEV.js";
-import {
-  change_base
-} from "./chunk-LBVYFW3I.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/test/test-pinned-snapshot.ts
-import { existsSync } from "node:fs";
-import { rm } from "node:fs/promises";
-import path from "node:path";
-var PREFIX = "josh-pinned-snapshot-";
-var CACHE_NAME = "josh-test-pinned-verdicts.json";
-var IDENTITY = ["-c", "user.name=Snapshot", "-c", "user.email=snapshot@localhost"];
-function read(args, options) {
-  const result = git_spawn_sync.run(args, options);
-  if (result.exit_code !== 0) throw new Error(`Snapshot git failed: ${result.stderr}`);
-  return result.stdout.trimEnd();
-}
-function identity(root, head, index) {
-  const tracked = read(["diff", "--name-only", "-z", head, "--"], { cwd: root });
-  const untracked = read(["ls-files", "--others", "--exclude-standard", "-z"], { cwd: root });
-  const paths = `${tracked}\0${untracked}`.split("\0").filter((file) => file !== "");
-  const contents = input_fingerprint.of_files(root, paths);
-  return input_fingerprint.of_entries([head, index, JSON.stringify(contents)]);
-}
-function current_hash(root) {
-  try {
-    return identity(
-      root,
-      read(["rev-parse", "HEAD"], { cwd: root }),
-      read(["ls-files", "--stage", "-z"], { cwd: root })
-    );
-  } catch {
-    return void 0;
-  }
-}
-async function in_tree(tree, action) {
-  const original = process.cwd();
-  process.chdir(tree);
-  try {
-    return await action();
-  } finally {
-    process.chdir(original);
-  }
-}
-async function copy_changes(tree, head) {
-  const paths = await changed_paths.read_changed_since(head);
-  const present = paths.filter((file) => existsSync(file));
-  const deleted = paths.filter((file) => !existsSync(file));
-  await base_tree.copy_in(tree, present);
-  await Promise.all(
-    deleted.map(async (file) => {
-      await rm(path.join(tree, file), { force: true });
-    })
-  );
-  if (present.length > 0) read(["add", "--force", "--", ...present], { cwd: tree });
-}
-function seal(root, head, index, cache_file) {
-  const tree_hash = identity(root, head, index);
-  read(["add", "--all"], { cwd: root });
-  const tree = read(["write-tree"], { cwd: root });
-  const commit = read([...IDENTITY, "commit-tree", tree, "-p", head, "-m", "Pinned snapshot"], {
-    cwd: root
-  });
-  read(["update-ref", "HEAD", commit], { cwd: root });
-  return { head, tree, tree_hash, cache_file };
-}
-async function with_snapshot(action) {
-  const root = process.cwd();
-  const head = read(["rev-parse", "HEAD"], { cwd: root });
-  const index = read(["ls-files", "--stage", "-z"], { cwd: root });
-  const cache_file = path.resolve(
-    root,
-    read(["rev-parse", "--git-path", CACHE_NAME], { cwd: root })
-  );
-  return await base_tree.with_tree(PREFIX, head, async (tree) => {
-    await copy_changes(tree.tree, head);
-    const snapshot = seal(tree.tree, head, index, cache_file);
-    return await in_tree(tree.tree, async () => await action(snapshot));
-  });
-}
-var test_pinned_snapshot = { current_hash, with_snapshot };
-
-// scripts/test/test-pinned-record.ts
-var RECORD_PREFIX = "josh-test-pinned-record-";
-var TOKEN_KEY_LENGTH = 16;
-var SITE_KEY_LENGTH = 16;
-var NOT_RUN_NOTE = "`josh test:pinned` could not run, so nothing was checked: ";
-var FIRST_UNPINNED_FLAG = "--first-unpinned";
-var LIST_PREFIX = "josh-test-pinned-list-";
-var LIST_SUFFIX = ".log";
-var LIST_HEADER = "josh test:pinned \u2014 every unpinned and unchecked place";
-var UNCHECKED_NOTE = "Unchecked places are not verified: map each listed place to its related regression test before ship; reuse the pending probe or cached verdicts, and fix unresolved places with the round-1 findings.\n";
-function site_of(hunk) {
-  if (hunk.parts !== void 0) {
-    return stamp_file.digest(
-      JSON.stringify(hunk.parts.map((part) => site_of({ ...part, is_green: hunk.is_green })))
-    );
-  }
-  const body = JSON.stringify([hunk.new_count, hunk.old_lines, hunk.new_lines ?? []]);
-  const key = stamp_file.digest(body).slice(0, SITE_KEY_LENGTH);
-  const place = hunk.function_name === void 0 ? hunk.file : `${hunk.file} ${hunk.function_name}`;
-  return `${place} ${key}`;
-}
-function kept_log(report2, root) {
-  if (!test_pinned_logic.has_unchecked(report2)) return void 0;
-  const output = test_pinned_logic.format(report2);
-  const target = stamp_file.stamp_path(LIST_PREFIX, root, LIST_SUFFIX);
-  return { path: gate_log.write_gate_log([{ header: LIST_HEADER, output }], target) };
-}
-function summary_with(report2, log) {
-  const summary = {
-    ...test_pinned_logic.report_parts(report2),
-    ...test_pinned_logic.has_unchecked(report2) && { is_unchecked: true },
-    log,
-    unpinned: test_pinned_cache_logic.distinct(report2.unpinned.map((hunk) => site_of(hunk)))
-  };
-  return report2.cut === void 0 ? summary : { ...summary, is_cut: true, remaining: report2.cut.length };
-}
-function summary_of(report2, root = PROJECT_ROOT) {
-  return summary_with(report2, kept_log(report2, root));
-}
-function partial_summary(report2, note) {
-  const summary = summary_with(report2, void 0);
-  const places = test_pinned_logic.format(report2);
-  const next = summary.is_unchecked === true ? UNCHECKED_NOTE : "";
-  return { ...summary, text: `${note}
-${places}
-${next}`, is_partial: true };
-}
-function not_run_summary(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return { text: `${NOT_RUN_NOTE}${message}
-`, unpinned: [], is_unchecked: true };
-}
-function record_path(token, root = PROJECT_ROOT) {
-  const key = stamp_file.digest(token).slice(0, TOKEN_KEY_LENGTH);
-  return stamp_file.stamp_path(`${RECORD_PREFIX}${key}-`, root);
-}
-function write(token, summary, root = PROJECT_ROOT) {
-  stamp_file.write_stamp(record_path(token, root), { token, ...summary });
-}
-function is_text_list(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function log_of(value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  const kept = value;
-  return { path: typeof kept["path"] === "string" ? kept["path"] : void 0 };
-}
-function tail_of(record3) {
-  const { counts, log } = record3;
-  return typeof counts === "string" ? { counts, log: log_of(log) } : {};
-}
-function remaining_of(record3) {
-  const { remaining } = record3;
-  return typeof remaining === "number" ? { remaining } : {};
-}
-function snapshot_of(record3) {
-  return typeof record3["tree_hash"] === "string" ? { tree_hash: record3["tree_hash"] } : {};
-}
-function to_summary(record3) {
-  const { text, unpinned, is_cut } = record3;
-  if (typeof text !== "string" || !is_text_list(unpinned)) return void 0;
-  const unchecked = record3["is_unchecked"] === true ? { is_unchecked: true } : {};
-  const summary = { text, unpinned, ...tail_of(record3), ...unchecked, ...snapshot_of(record3) };
-  return is_cut === true ? { ...summary, is_cut, ...remaining_of(record3) } : summary;
-}
-function parsed(raw) {
-  try {
-    const value = JSON.parse(raw);
-    return typeof value === "object" && value !== null ? value : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function read_summary(token, root) {
-  const raw = stamp_file.read_stamp_text(record_path(token, root));
-  const record3 = raw === void 0 ? void 0 : parsed(raw);
-  if (record3?.["token"] !== token) return void 0;
-  return to_summary(record3);
-}
-function fresh_summary(summary, root) {
-  if (summary.tree_hash === void 0) return summary;
-  return { ...summary, is_stale: test_pinned_snapshot.current_hash(root) !== summary.tree_hash };
-}
-function read2(token, root = PROJECT_ROOT) {
-  const summary = read_summary(token, root);
-  return summary === void 0 ? void 0 : fresh_summary(summary, root);
-}
-function clear(token, root = PROJECT_ROOT) {
-  stamp_file.remove_stamp(record_path(token, root));
-}
-function launch_argv(token, reason, origin, is_whole = false) {
-  const cut = reason === void 0 && !is_whole ? [FIRST_UNPINNED_FLAG] : [];
-  return ["test:pinned", ...cut, "--origin", origin, "--record", token];
-}
-var test_pinned_record = {
-  UNCHECKED_NOTE,
-  clear,
-  launch_argv,
-  is_text_list,
-  not_run_summary,
-  parsed,
-  partial_summary,
-  read: read2,
-  record_path,
-  summary_of,
-  write
-};
-
-// scripts/test/test-pinned-ledger.ts
-function time_of(hunk, verdict, elapsed_ms) {
-  const time = { file: hunk.file, tests: verdict.ran, elapsed_ms };
-  return verdict.pinned_by === void 0 ? time : { ...time, pinned_by: verdict.pinned_by };
-}
-var MANUAL_ORIGIN = "manual";
-var BACKGROUND_ORIGIN = "run-review";
-function origin_of(raw) {
-  if (raw === void 0) return MANUAL_ORIGIN;
-  const parsed2 = lane_ledger_pinned_origin.pinned_origin_schema.safeParse(raw);
-  return parsed2.success ? parsed2.data : void 0;
-}
-async function record(skipped, probes, elapsed_ms) {
-  await lane_ledger_write.record_test_pinned({
-    issue: lane_paths.issue_here(PROJECT_ROOT),
-    held: skipped.held,
-    rewired: skipped.rewired,
-    over_cap: skipped.over_cap ?? 0,
-    probes: [...probes],
-    elapsed_ms,
-    origin: skipped.origin ?? MANUAL_ORIGIN
-  });
-}
-async function record_discarded(elapsed_ms, origin = BACKGROUND_ORIGIN) {
-  await lane_ledger_write.record_test_pinned({
-    issue: lane_paths.issue_here(PROJECT_ROOT),
-    held: 0,
-    probes: [],
-    elapsed_ms,
-    origin,
-    discarded: true
-  });
-}
-var test_pinned_ledger = { BACKGROUND_ORIGIN, origin_of, record, record_discarded, time_of };
-
-// scripts/test/test-pinned.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile4 } from "node:fs/promises";
-
-// scripts/test/test-pinned-cache.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { readFile } from "node:fs/promises";
-import path2 from "node:path";
-
-// scripts/test/test-pinned-prune-logic.ts
-function is_line_hunk(hunk) {
-  return hunk.function_name === void 0 && hunk.parts === void 0;
-}
-function greens_reached(hunks, verdicts) {
-  return hunks.filter((hunk, index) => verdicts[index] === "green" && is_line_hunk(hunk));
-}
-function record_of(hunk) {
-  return { file: hunk.file, old_lines: hunk.old_lines, new_lines: hunk.new_lines ?? [] };
-}
-function is_subsequence(part, whole) {
-  const remaining = [...whole];
-  return part.every((line) => remaining.splice(0, remaining.indexOf(line) + 1).at(-1) === line);
-}
-function is_same_lines(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-function is_remnant(hunk, green) {
-  if (!is_line_hunk(hunk) || hunk.file !== green.file) return false;
-  return is_same_lines(hunk.old_lines, green.old_lines) && is_subsequence(hunk.new_lines ?? [], green.new_lines);
-}
-function reverted(content, hunks) {
-  const order = hunks.toSorted((left, right) => right.new_start - left.new_start);
-  let text = content;
-  for (const hunk of order) {
-    text = test_pinned_logic.revert(text, hunk);
-  }
-  return text;
-}
-function remnants_of(hunks, greens) {
-  return hunks.filter((hunk) => greens.some((green) => is_remnant(hunk, green)));
-}
-function pruned_digests(contents, reverts, greens) {
-  const files = [...new Set(greens.map((green) => green.file))];
-  const pairs = files.flatMap((file) => {
-    const content = contents.get(file);
-    if (content === void 0) return [];
-    const own = reverts.filter((hunk) => hunk.file === file);
-    return [[file, test_pinned_cache_logic.digest_of(reverted(content, own))]];
-  });
-  return new Map(pairs);
-}
-function pruned_of(code, contents, reverts, greens) {
-  const pruned = pruned_digests(contents, reverts, greens);
-  const digests = new Map([...code.digests, ...pruned]);
-  const paths = [.../* @__PURE__ */ new Set([...code.code, ...pruned.keys()])];
-  return test_pinned_cache_logic.change_of(code.commit, paths, digests);
-}
-var test_pinned_prune_logic = { greens_reached, record_of, is_remnant, remnants_of, pruned_of };
-
-// scripts/test/test-pinned-cache.ts
-var CACHE_NAME2 = "josh-test-pinned-verdicts.json";
-var LINE_BREAK = "\n";
-var AS_COMMIT = "^{commit}";
-async function read_text(file) {
-  return existsSync2(file) ? await readFile(file, "utf8") : "";
-}
-async function contents_of(files) {
-  const existing = [...new Set(files)].filter((file) => existsSync2(file));
-  const texts = await Promise.all(existing.map(async (file) => await readFile(file, "utf8")));
-  return new Map(existing.map((file, index) => [file, texts[index] ?? ""]));
-}
-async function work_tree_files(is_kept) {
-  const listed = await test_pinned_reach.work_tree_files();
-  return listed.filter((file) => is_kept(file));
-}
-async function digests_of(files) {
-  const contents = await contents_of(files);
-  return new Map(
-    [...contents].map(([file, text]) => [file, test_pinned_cache_logic.digest_of(text)])
-  );
-}
-async function kept_digests_of(is_kept) {
-  return await digests_of(await work_tree_files(is_kept));
-}
-async function config_digests_of() {
-  const configs = await work_tree_files((file) => test_runner_config.is_config(file));
-  const reached = config_fingerprint.list_reachable_modules(
-    configs.map((file) => path2.resolve(file))
-  );
-  return await digests_of([...reached].map((file) => path2.relative(process.cwd(), file)));
-}
-function contents_digest(digests) {
-  return test_pinned_cache_logic.test_set_of(
-    [...digests].map(([file, digest]) => `${file} ${digest}`)
-  );
-}
-async function code_change(base) {
-  const [commit, paths] = await Promise.all([
-    git_spawn.read(["rev-parse", "--verify", `${base}${AS_COMMIT}`]),
-    changed_paths.read_changed_since(base)
-  ]);
-  const code = paths.filter(
-    (file) => !test_declared_logic.is_test_file(file) && !run_record_path.is_run_record(file)
-  );
-  return { commit: commit.trim(), code, digests: await digests_of(code) };
-}
-async function read_tree(base) {
-  const [test_digests, configs, code] = await Promise.all([
-    kept_digests_of((file) => test_declared_logic.is_test_file(file)),
-    config_digests_of(),
-    code_change(base)
-  ]);
-  const test_contents = contents_digest(new Map([...test_digests, ...configs]));
-  const change = test_pinned_cache_logic.change_of(code.commit, code.code, code.digests);
-  return { test_digests, code, config: contents_digest(configs), test_contents, change };
-}
-async function read_all(file, base, hunks) {
-  const text = await read_text(file);
-  const greens = test_pinned_cache_logic.greens_of(text);
-  const files = [...hunks, ...greens].map((hunk) => hunk.file);
-  return [text, ...await Promise.all([read_tree(base), contents_of(files)])];
-}
-async function load(base, hunks, cache_file) {
-  const file = cache_file ?? path2.resolve(await git_spawn.read(["rev-parse", "--git-path", CACHE_NAME2]));
-  const [text, tree, contents] = await read_all(file, base, hunks);
-  const { test_digests, code, test_contents, change } = tree;
-  const greens = test_pinned_cache_logic.greens_of(text);
-  const remnants = test_pinned_prune_logic.remnants_of(hunks, greens);
-  const pruned = test_pinned_prune_logic.pruned_of(code, contents, remnants, greens);
-  const freshness = test_pinned_cache_logic.freshness_of(text, { change, pruned, test_contents });
-  const reach = test_pinned_reach.create({ ...code, test_digests });
-  const entries = test_pinned_cache_logic.entries_of(text);
-  return { file, base, ...tree, entries, freshness, reach, hunks, contents };
-}
-async function basis_of(cache, probe, file) {
-  if (probe.verdict !== "red") {
-    const tests = await cache.reach.related(file);
-    return tests && test_pinned_cache_logic.related_basis(tests, cache.test_digests, cache.config);
-  }
-  const digest = await cache.reach.failed(probe.failed);
-  return digest === void 0 ? void 0 : { digest };
-}
-async function known_by_basis(cache, entry, file) {
-  const { freshness, test_digests } = cache;
-  const stored = { verdict: entry.verdict, failed: Object.keys(entry.tests) };
-  const basis = await basis_of(cache, stored, file);
-  const held = test_pinned_cache_logic.fresh_verdict(entry, freshness, test_digests, basis?.digest);
-  return held ?? test_pinned_cache_logic.recheck_of(entry, freshness, basis, test_digests);
-}
-async function known_one(cache, key, file) {
-  const { freshness, test_digests } = cache;
-  const entry = cache.entries[key];
-  const kept = test_pinned_cache_logic.fresh_verdict(entry, freshness, test_digests);
-  if (kept !== void 0 || entry === void 0) return kept;
-  if (entry.basis === void 0) {
-    return test_pinned_cache_logic.recheck_of(entry, freshness, void 0, test_digests);
-  }
-  return await known_by_basis(cache, entry, file);
-}
-async function known(cache, keys2, files) {
-  return await Promise.all(
-    keys2.map(async (key, index) => await known_one(cache, key, files[index] ?? ""))
-  );
-}
-async function stored_basis(cache, key, probe, file) {
-  const entry = cache.entries[key];
-  const kept = test_pinned_cache_logic.fresh_verdict(entry, cache.freshness, cache.test_digests);
-  if (kept?.verdict === probe.verdict && entry?.basis !== void 0) {
-    return { digest: entry.basis, related: entry.related };
-  }
-  const failed = Object.keys(test_pinned_cache_logic.tests_of(probe.failed, cache.test_digests));
-  return await basis_of(cache, { ...probe, failed }, file);
-}
-async function is_steady(cache) {
-  const now = await read_tree(cache.base);
-  return now.change === cache.change && now.test_contents === cache.test_contents;
-}
-function write2(cache, entries, probes) {
-  const { code, contents, hunks } = cache;
-  const reached = test_pinned_prune_logic.greens_reached(
-    hunks,
-    probes.map((probe) => probe?.verdict)
-  );
-  const green = reached.map((hunk) => test_pinned_prune_logic.record_of(hunk));
-  const pruned = test_pinned_prune_logic.pruned_of(code, contents, reached, green);
-  const content = {
-    test_contents: cache.test_contents,
-    change: cache.change,
-    entries,
-    pruned,
-    green
-  };
-  atomic_write.replace_file(cache.file, `${JSON.stringify(content)}${LINE_BREAK}`);
-}
-async function settle(state, reached) {
-  const { cache, keys: keys2, files, probes, bases } = state;
-  const read3 = await Promise.all(
-    reached.map(
-      async ([index, probe]) => await stored_basis(cache, keys2[index] ?? "", probe, files[index] ?? "")
-    )
-  );
-  const is_kept = await is_steady(cache);
-  for (const [position, [index, probe]] of reached.entries()) {
-    probes[index] = probe;
-    bases[index] = is_kept ? read3[position] : void 0;
-  }
-  write2(cache, test_pinned_cache_logic.stored(keys2, probes, cache.test_digests, bases), probes);
-}
-function writer(cache, keys2) {
-  const files = cache.hunks.map((hunk) => hunk.file);
-  const state = { cache, keys: keys2, files, probes: [], bases: [] };
-  const queue = { last: Promise.resolve() };
-  async function record3(reached) {
-    const previous = queue.last;
-    const current = (async () => {
-      await previous;
-      await settle(state, reached);
-    })();
-    queue.last = current;
-    await current;
-  }
-  return { record: record3 };
-}
-var test_pinned_cache = { known, load, writer };
-
-// scripts/test/test-pinned-carry.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import path3 from "node:path";
-import { z } from "zod";
-var CARRY_NAME = "josh-test-pinned-carry.json";
-var SCHEMA = z.object({ tree: z.string(), pending: z.array(z.string()) });
-function tree_of(cache) {
-  return test_pinned_cache_logic.digest_of(`${cache.change}:${cache.test_contents}`);
-}
-function file_of(cache) {
-  return path3.join(path3.dirname(cache.file), CARRY_NAME);
-}
-async function pending_of(cache) {
-  try {
-    const text = await readFile2(file_of(cache), "utf8");
-    const stored = json_value.parse_with(text, SCHEMA);
-    return stored?.tree === tree_of(cache) ? stored.pending : [];
-  } catch {
-    return [];
-  }
-}
-function keys_of(cache) {
-  return test_pinned_cache_logic.distinct(
-    cache.hunks.map(
-      (hunk) => test_pinned_cache_logic.hunk_key(hunk, cache.contents.get(hunk.file) ?? "")
-    )
-  );
-}
-function is_held(known2) {
-  return known2 !== void 0 && !test_pinned_cache_logic.is_recheck(known2);
-}
-function keyed_of(cache) {
-  const identifiers = keys_of(cache);
-  return new Map(cache.hunks.map((hunk, index) => [hunk, identifiers[index] ?? ""]));
-}
-function keys(cache, hunks) {
-  const keyed = keyed_of(cache);
-  return hunks.map((hunk) => keyed.get(hunk) ?? "");
-}
-function ordered_of(cache, pending) {
-  const keyed = keyed_of(cache);
-  return cache.hunks.toSorted(
-    (left, right) => Number(pending.has(keyed.get(right) ?? "")) - Number(pending.has(keyed.get(left) ?? ""))
-  );
-}
-async function select(cache, max_hunks) {
-  const identifiers = keys_of(cache);
-  const pending = new Set(await pending_of(cache));
-  const known2 = await test_pinned_cache.known(
-    cache,
-    identifiers,
-    cache.hunks.map((hunk) => hunk.file)
-  );
-  const held = cache.hunks.filter((_hunk, index) => is_held(known2[index]));
-  const held_set = new Set(held);
-  const ordered = ordered_of(cache, pending).filter((hunk) => !held_set.has(hunk));
-  const split = test_pinned_logic.split(ordered, max_hunks);
-  return { checked: [...held, ...split.checked], unchecked: split.unchecked };
-}
-function record2(cache, hunks) {
-  const pending = keys(cache, hunks);
-  atomic_write.replace_file(file_of(cache), JSON.stringify({ tree: tree_of(cache), pending }));
-}
-var test_pinned_carry = { select, record: record2, keys };
-
-// scripts/test/test-pinned-functions.ts
-var STUB_BODY = "{ throw new Error('josh test:pinned') }";
-var SCRIPT_FILE = /\.[cm]?[jt]sx?$/u;
-var LINE_BREAK2 = "\n";
-var DEFAULT_NAME = "default";
-function is_script(file) {
-  return SCRIPT_FILE.test(file);
-}
-function is_function_value(api, node) {
-  if (node === void 0) return false;
-  return api.isArrowFunction(node) || api.isFunctionExpression(node);
-}
-function member_site(api, owner, member) {
-  if (api.isMethodDeclaration(member) && member.body !== void 0) {
-    return [{ name: `${owner}.${member.name.getText()}`, extent: member, body: member.body }];
-  }
-  if (!api.isPropertyAssignment(member) || !is_function_value(api, member.initializer)) return [];
-  return [
-    { name: `${owner}.${member.name.getText()}`, extent: member, body: member.initializer.body }
-  ];
-}
-function declaration_sites(api, declaration) {
-  const { initializer } = declaration;
-  const name = declaration.name.getText();
-  if (is_function_value(api, initializer)) {
-    return [{ name, extent: declaration, body: initializer.body }];
-  }
-  if (initializer === void 0 || !api.isObjectLiteralExpression(initializer)) return [];
-  return initializer.properties.flatMap((member) => member_site(api, name, member));
-}
-function function_site(statement) {
-  if (statement.body === void 0) return [];
-  return [{ name: statement.name?.text ?? DEFAULT_NAME, extent: statement, body: statement.body }];
-}
-function statement_sites(api, statement) {
-  if (api.isFunctionDeclaration(statement)) return function_site(statement);
-  if (!api.isVariableStatement(statement)) return [];
-  return statement.declarationList.declarations.flatMap(
-    (declaration) => declaration_sites(api, declaration)
-  );
-}
-function stub_hunk(file, source, site) {
-  const start = site.extent.getStart(source);
-  const first = source.getLineAndCharacterOfPosition(start).line;
-  const last = source.getLineAndCharacterOfPosition(site.extent.getEnd()).line;
-  const offset = start - source.getLineAndCharacterOfPosition(start).character;
-  const lines = source.text.slice(offset, source.getLineEndOfPosition(site.extent.getEnd()));
-  const before = lines.slice(0, site.body.getStart(source) - offset);
-  const stubbed = `${before}${STUB_BODY}${lines.slice(site.body.getEnd() - offset)}`;
-  return {
-    file,
-    new_start: first + 1,
-    new_count: last - first + 1,
-    old_lines: stubbed.split(LINE_BREAK2),
-    new_lines: lines.split(LINE_BREAK2),
-    function_name: site.name
-  };
-}
-function stub_hunks(api, file, content) {
-  const source = api.createSourceFile(file, content, api.ScriptTarget.Latest, true);
-  return source.statements.flatMap((statement) => statement_sites(api, statement)).map((site) => stub_hunk(file, source, site));
-}
-var test_pinned_functions = { STUB_BODY, is_script, stub_hunks };
-
-// scripts/test/test-pinned-rewire.ts
-function is_called(api, parent, node) {
-  if (!api.isCallExpression(parent) && !api.isNewExpression(parent)) return false;
-  return parent.expression === node || parent.arguments?.includes(node) === true;
-}
-function is_use(api, node) {
-  const { parent } = node;
-  if (api.isPropertyAccessExpression(parent)) return parent.expression === node;
-  return is_called(api, parent, node);
-}
-function is_import(api, parent) {
-  return api.isImportSpecifier(parent) || api.isImportClause(parent) || api.isNamespaceImport(parent);
-}
-function add_name(api, node, names) {
-  const { parent } = node;
-  if (is_use(api, node)) names.used.add(node.text);
-  if (!("name" in parent) || parent.name !== node) return;
-  names.bound.add(node.text);
-  if (is_import(api, parent)) names.imported.add(node.text);
-}
-function names_in(api, node, names) {
-  if (api.isIdentifier(node)) add_name(api, node, names);
-  api.forEachChild(node, (child) => {
-    names_in(api, child, names);
-  });
-}
-function names_of(api, file, content) {
-  const names = { bound: /* @__PURE__ */ new Set(), used: /* @__PURE__ */ new Set(), imported: /* @__PURE__ */ new Set() };
-  names_in(api, api.createSourceFile(file, content, api.ScriptTarget.ESNext, true), names);
-  return names;
-}
-function unbound_of(names) {
-  return [...names.used].filter(
-    (name) => !names.bound.has(name) && !Object.hasOwn(globalThis, name)
-  );
-}
-function tokens_of(api, text) {
-  const target = api.ScriptTarget.ESNext;
-  const scanner = api.createScanner(target, true, api.LanguageVariant.Standard, text);
-  const end = api.SyntaxKind.EndOfFileToken;
-  const tokens = [];
-  for (let kind = scanner.scan(); kind !== end; kind = scanner.scan()) {
-    tokens.push({ kind, text: scanner.getTokenText() });
-  }
-  return tokens;
-}
-function is_same_token(token, other, swap) {
-  if (other?.kind !== token.kind) return false;
-  return token.text === other.text || swap.from.has(token.text) && swap.to.has(other.text);
-}
-function is_renamed_only(olds, news, swap) {
-  if (olds.length !== news.length) return false;
-  return olds.every((token, index) => is_same_token(token, news[index], swap));
-}
-function is_import_only(api, file, text) {
-  const source = api.createSourceFile(file, text, api.ScriptTarget.ESNext, true);
-  return source.statements.every((statement) => api.isImportDeclaration(statement));
-}
-function new_text_of(content, hunk) {
-  const start = hunk.new_start - 1;
-  return content.split("\n").slice(start, start + hunk.new_count).join("\n");
-}
-function is_name_swap(api, hunk, new_text, swap) {
-  const old_text = hunk.old_lines.join("\n");
-  const is_imports = is_import_only(api, hunk.file, old_text);
-  if (is_imports && is_import_only(api, hunk.file, new_text)) return true;
-  return is_renamed_only(tokens_of(api, old_text), tokens_of(api, new_text), swap);
-}
-function is_rewire(api, content, hunk) {
-  if (!test_pinned_functions.is_script(hunk.file)) return false;
-  const after = names_of(api, hunk.file, content);
-  const before = names_of(api, hunk.file, test_pinned_logic.revert(content, hunk));
-  const unbound_now = new Set(unbound_of(after));
-  const unbound = unbound_of(before).filter((name) => !unbound_now.has(name));
-  if (unbound.length === 0) return false;
-  const swap = { from: new Set(unbound), to: after.imported };
-  return is_name_swap(api, hunk, new_text_of(content, hunk), swap);
-}
-var test_pinned_rewire = { is_rewire };
-
-// scripts/test/test-pinned-emit.ts
-function emitted(api, file, content) {
-  const compiler_options = { removeComments: true, target: api.ScriptTarget.ESNext };
-  return api.transpileModule(content, { compilerOptions: compiler_options, fileName: file }).outputText;
-}
-function changes_runtime(api, content, hunk) {
-  if (!test_pinned_functions.is_script(hunk.file)) return true;
-  const reverted2 = test_pinned_logic.revert(content, hunk);
-  return emitted(api, hunk.file, reverted2) !== emitted(api, hunk.file, content);
-}
-function probed_of(api, hunks, contents) {
-  const runtime = hunks.map((hunk, index) => ({ hunk, content: contents[index] ?? "" })).filter((read3) => changes_runtime(api, read3.content, read3.hunk));
-  const probed = runtime.filter(
-    (read3) => read3.hunk.parts !== void 0 || !test_pinned_rewire.is_rewire(api, read3.content, read3.hunk)
-  );
-  return { hunks: probed.map((read3) => read3.hunk), rewired: runtime.length - probed.length };
-}
-var test_pinned_emit = { changes_runtime, probed_of };
-
-// scripts/test/test-pinned-moves.ts
-function is_deletion(hunk) {
-  return hunk.new_count === 0 && hunk.old_lines.length > 0;
-}
-function moves_between(deletion, insertion) {
-  if (deletion.file !== insertion.file || !is_deletion(deletion)) return false;
-  return insertion.old_lines.length === 0 && JSON.stringify(deletion.old_lines) === JSON.stringify(insertion.new_lines);
-}
-function is_move(first, second) {
-  return moves_between(first, second) || moves_between(second, first);
-}
-function take_pair(hunk, remaining) {
-  const index = remaining.findIndex((candidate) => is_move(hunk, candidate));
-  if (index === -1) return hunk;
-  const partner = remaining.splice(index, 1).at(0);
-  return partner === void 0 ? hunk : { ...hunk, parts: [hunk, partner] };
-}
-function group(hunks) {
-  const result = [];
-  const remaining = [...hunks];
-  while (remaining.length > 0) {
-    const hunk = remaining.shift();
-    if (hunk !== void 0) result.push(take_pair(hunk, remaining));
-  }
-  return result;
-}
-var test_pinned_moves = { group };
-
-// scripts/test/test-pinned-probe.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import path5 from "node:path";
-
-// scripts/test/test-pinned-pool.ts
-var MAX_TREES = 4;
-var UNREAD_BUDGET = 1;
-function lane_plan(count, budget = UNREAD_BUDGET) {
-  const lanes = Math.max(1, Math.min(count, budget, MAX_TREES));
-  return { lanes, workers: Math.max(1, Math.floor(budget / lanes)) };
-}
-function deal(items, lanes) {
-  const groups = Array.from({ length: lanes }, () => []);
-  for (const [index, item] of items.entries()) groups[index % lanes]?.push(item);
-  return groups.filter((group2) => group2.length > 0);
-}
-function settled(outcomes) {
-  const failed = outcomes.find((outcome) => outcome.status === "rejected");
-  if (failed !== void 0) throw failed.reason;
-  return outcomes.flatMap((outcome) => outcome.status === "fulfilled" ? [outcome.value] : []);
-}
-async function run_lanes(items, lanes, run_lane) {
-  return settled(
-    await Promise.allSettled(deal(items, lanes).map(async (group2) => await run_lane(group2)))
-  );
-}
-function at(index, lanes) {
-  const position = Math.floor(index / lanes);
-  return [position, position + 1];
-}
-async function run_pool(items, lanes, run_lane) {
-  const results = await run_lanes(items, lanes, run_lane);
-  return items.flatMap((_item, index) => results[index % lanes]?.slice(...at(index, lanes)) ?? []);
-}
-var test_pinned_pool = { MAX_TREES, deal, lane_plan, run_pool };
-
-// scripts/test/test-pinned-type-check.ts
-import { writeFile } from "node:fs/promises";
-import path4 from "node:path";
-import { execa } from "execa";
-var CONFIG_NAME = "tsconfig.josh-pinned.json";
-var BASE_CONFIG = "./tsconfig.json";
-var BUILD_INFO = "josh-pinned.tsbuildinfo";
-var TSC_BIN = path4.join("node_modules", ".bin", "tsc");
-var TYPED_FILE = /\.[cm]?tsx?$/u;
-var TYPE_ERROR = /error TS\d+/u;
-var LINT_OPTIONS_OFF = {
-  noUnusedLocals: false,
-  noUnusedParameters: false,
-  allowUnreachableCode: true
-};
-function is_typed(file) {
-  return TYPED_FILE.test(file);
-}
-async function scope_of(file) {
-  if (!is_typed(file)) return [];
-  const graph = await import_graph.create(process.cwd());
-  if (graph === void 0) return [];
-  const target = path4.resolve(file);
-  const universe = await test_pinned_reach.code_universe();
-  const readers = universe.filter(
-    (reader) => is_typed(reader) && graph.imports(reader).includes(target)
-  );
-  return [file, ...readers.map((reader) => path4.relative(process.cwd(), reader))];
-}
-function config_text(scope, build_info) {
-  const compiler_options = {
-    ...LINT_OPTIONS_OFF,
-    noEmit: true,
-    incremental: true,
-    tsBuildInfoFile: build_info
-  };
-  const config = {
-    extends: BASE_CONFIG,
-    compilerOptions: compiler_options,
-    include: [],
-    files: scope
-  };
-  return `${JSON.stringify(config, void 0, "	")}
-`;
-}
-async function check(tree, scope) {
-  const build_info = path4.join(tree.parent, BUILD_INFO);
-  await writeFile(path4.join(tree.tree, CONFIG_NAME), config_text(scope, build_info));
-  const result = await execa(
-    path4.join(tree.tree, TSC_BIN),
-    ["-p", CONFIG_NAME, "--pretty", "false"],
-    {
-      cwd: tree.tree,
-      reject: false,
-      all: true
-    }
-  );
-  return { ran: result.exitCode !== void 0, red: TYPE_ERROR.test(result.all) };
-}
-async function is_red(tree, scope) {
-  if (scope.length === 0) return false;
-  const outcome = await check(tree, scope);
-  return outcome.red;
-}
-var test_pinned_type_check = { check, config_text, is_red, scope_of, CONFIG_NAME };
-
-// scripts/test/test-pinned-probe.ts
-var TREE_PREFIX = "josh-test-pinned-";
-var HEAD = "HEAD";
-var NO_TEST = { verdict: "no-test", failed: [], ran: 0 };
-async function direct_of(root, file) {
-  const importers = await direct_importers.importers_of(root, [file]);
-  return importers.get(file) ?? [];
-}
-async function import_plan(root, probe) {
-  const { file } = probe.hunk;
-  if (direct_importers.every_test_imports_of([file]).length > 0) {
-    return { reach: await direct_of(root, file) };
-  }
-  if (probe.reach === void 0) return { reach: [file] };
-  return test_pinned_stage.plan_over(file, await direct_of(root, file), probe.reach);
-}
-async function plan_of(root, probe) {
-  const plan = await import_plan(root, probe);
-  const spawned = probe.spawned ?? [];
-  return {
-    ...plan,
-    direct: plan.direct?.concat(spawned),
-    reach: [.../* @__PURE__ */ new Set([...plan.reach, ...spawned])]
-  };
-}
-function selection_over(root, files, workers) {
-  if (files.length === 0) return void 0;
-  const scope = { mode: "related", files, reason: "" };
-  const placed = { ...scope, files: files.map((test) => path5.join(root, test)) };
-  const flags = related_heavy_tests.exclude_flags(placed, root);
-  return [
-    ...related_scope.vitest_arguments(scope, flags),
-    ...unit_worker_share.worker_arguments([], workers)
-  ];
-}
-function recheck_selection(recheck, workers) {
-  return ["run", ...recheck.recheck, ...unit_worker_share.worker_arguments([], workers)];
-}
-async function selection_of(root, probe, workers) {
-  if (probe.recheck !== void 0) return recheck_selection(probe.recheck, workers);
-  const plan = await plan_of(root, probe);
-  return selection_over(root, plan.direct ?? plan.reach, workers);
-}
-async function with_revert(tree, hunk, action) {
-  const target = path5.join(tree.tree, hunk.file);
-  const content = await readFile3(target, "utf8");
-  await writeFile2(target, test_pinned_logic.revert(content, hunk));
-  try {
-    return await action();
-  } finally {
-    await writeFile2(target, content);
-  }
-}
-async function reverted_run(tree, hunk, selection) {
-  if (selection === void 0) return NO_TEST;
-  return await with_revert(tree, hunk, async () => await test_red.probe_in(tree, selection));
-}
-async function is_reverted_type_red(tree, hunk) {
-  const scope = await test_pinned_type_check.scope_of(hunk.file);
-  if (scope.length === 0 || await test_pinned_type_check.is_red(tree, scope)) return false;
-  return await with_revert(tree, hunk, async () => await test_pinned_type_check.is_red(tree, scope));
-}
-async function fresh_verdict(tree, probe, lane) {
-  const plan = await plan_of(tree.tree, probe);
-  async function run2(files) {
-    return await reverted_run(tree, probe.hunk, selection_over(tree.tree, files, lane.workers));
-  }
-  async function is_type_red() {
-    return await is_reverted_type_red(tree, probe.hunk);
-  }
-  return await test_pinned_stage.staged_verdict(plan, run2, is_type_red, lane.staged);
-}
-async function verdict_of(tree, probe, lane) {
-  if (probe.recheck === void 0) return await fresh_verdict(tree, probe, lane);
-  const selection = recheck_selection(probe.recheck, lane.workers);
-  const run2 = await reverted_run(tree, probe.hunk, selection);
-  return test_pinned_cache_logic.rechecked(probe.recheck, run2) ?? await fresh_verdict(tree, probe, lane);
-}
-function halt_on(lane, verdict) {
-  if (lane.halt !== void 0 && test_pinned_logic.is_unpinned(verdict)) lane.halt.is_set = true;
-}
-async function timed_verdict(tree, probe, lane) {
-  const started = Date.now();
-  const verdict = await verdict_of(tree, probe, lane);
-  lane.times.push(test_pinned_ledger.time_of(probe.hunk, verdict, Date.now() - started));
-  return verdict;
-}
-async function verdicts_in(tree, probes, lane) {
-  const verdicts = [];
-  for (const probe of probes) {
-    if (lane.halt?.is_set === true) break;
-    const verdict = await timed_verdict(tree, probe, lane);
-    halt_on(lane, verdict);
-    await lane.on_verdict(probe.index, verdict);
-    verdicts.push(verdict);
-  }
-  return verdicts;
-}
-async function pooled(paths, probes, lane) {
-  if (probes.length === 0) return [];
-  const plan = test_pinned_pool.lane_plan(probes.length, await test_unit_guard.vitest_share([]));
-  return await test_pinned_pool.run_pool(
-    probes,
-    plan.lanes,
-    async (group2) => await base_tree.with_tree(TREE_PREFIX, HEAD, async (tree) => {
-      await base_tree.copy_in(tree.tree, paths);
-      return await verdicts_in(tree, group2, { ...lane, workers: plan.workers });
-    })
-  );
-}
-function skipped_of(options) {
-  return {
-    held: options.held ?? 0,
-    rewired: options.rewired ?? 0,
-    over_cap: options.over_cap ?? 0,
-    origin: options.origin
-  };
-}
-async function checked_on(paths, probes, on_verdict, options = {}) {
-  const started = Date.now();
-  const times = [];
-  const staged = test_pinned_stage.none();
-  const halt = options.is_first_unpinned === true ? { is_set: false } : void 0;
-  const verdicts = await pooled(paths, probes, { on_verdict, times, staged, halt });
-  await test_pinned_ledger.record(skipped_of(options), times, Date.now() - started);
-  return { verdicts, staged };
-}
-var test_pinned_probe = { checked_on, selection_of };
-
-// scripts/test/test-pinned.ts
-var HEAD2 = "HEAD";
-var NO_OUTCOME = { unpinned: [], stopped: [] };
-var NO_REPORT = { ...NO_OUTCOME, unchecked: [], unparsed: [] };
-async function read_hunks(base, files) {
-  if (files.length === 0) return [];
-  const diff_args = ["diff", "-U0", "--no-color", "--no-ext-diff", "--diff-filter=M"];
-  const prefix_args = ["--src-prefix=a/", "--dst-prefix=b/", base, "--"];
-  return test_pinned_logic.parse_hunks(
-    await git_spawn.read([...diff_args, ...prefix_args, ...files])
-  );
-}
-function held_of(known2) {
-  return test_pinned_cache_logic.is_recheck(known2) ? void 0 : known2;
-}
-function recheck_of(known2) {
-  return test_pinned_cache_logic.is_recheck(known2) ? known2 : void 0;
-}
-function probes_of(hunks, known2) {
-  return hunks.map((hunk, index) => ({ hunk, index, recheck: recheck_of(known2[index]) })).filter((probe) => held_of(known2[probe.index]) === void 0);
-}
-async function counts_of(hunks, reach) {
-  const files = test_pinned_cache_logic.distinct(hunks.map((hunk) => hunk.file));
-  const related = await Promise.all(files.map(async (file) => await reach.related(file)));
-  return new Map(files.map((file, index) => [file, related[index]?.length ?? 0]));
-}
-function by_reach(probes, counts) {
-  const counted = probes.map((probe) => ({ ...probe, reach: counts.get(probe.hunk.file) }));
-  return test_pinned_logic.by_reach(counted, counts);
-}
-function reached_of(verdicts) {
-  return verdicts.flatMap((verdict, index) => verdict === void 0 ? [] : [[index, verdict]]);
-}
-function check_options(held, options) {
-  return {
-    held,
-    rewired: options.rewired ?? 0,
-    over_cap: options.over_cap ?? 0,
-    is_first_unpinned: options.is_first_unpinned === true,
-    origin: options.origin
-  };
-}
-async function with_spawned(probes, reach) {
-  const files = [...new Set(probes.map((probe) => probe.hunk.file))];
-  const spawned = await Promise.all(files.map(async (file) => await reach.spawned(file)));
-  const by_file = new Map(files.map((file, index) => [file, spawned[index]]));
-  return probes.map((probe) => ({ ...probe, spawned: by_file.get(probe.hunk.file) }));
-}
-async function verdicts_on(paths, probing) {
-  const verdicts = probing.known.map((entry) => held_of(entry));
-  const reached = reached_of(verdicts);
-  const probes = await with_spawned(
-    by_reach(probes_of(probing.hunks, probing.known), probing.counts),
-    probing.cache.reach
-  );
-  const writer2 = test_pinned_cache.writer({ ...probing.cache, hunks: probing.hunks }, probing.keys);
-  const options = check_options(reached.length, probing.options);
-  await writer2.record(reached);
-  const checked = await test_pinned_probe.checked_on(
-    paths,
-    probes,
-    async (index, verdict) => {
-      verdicts[index] = verdict;
-      await writer2.record([[index, verdict]]);
-    },
-    options
-  );
-  return { verdicts, staged: checked.staged };
-}
-function outcome_of(hunks, verdicts) {
-  const is_held2 = verdicts.every((verdict) => verdict !== void 0);
-  return { ...test_pinned_logic.outcome(hunks, verdicts), is_held: is_held2 };
-}
-function cut_of(hunks, verdicts) {
-  const cut = hunks.filter((_hunk, index) => verdicts[index] === void 0);
-  return cut.length === 0 ? {} : { cut };
-}
-function over_cap_of(over_cap) {
-  return over_cap.length === 0 ? {} : { over_cap };
-}
-async function checked_outcome(paths, read3, options) {
-  const { hunks, cache } = read3;
-  const keys2 = test_pinned_carry.keys(cache, hunks);
-  const known2 = await test_pinned_cache.known(
-    cache,
-    keys2,
-    hunks.map((hunk) => hunk.file)
-  );
-  if (options.is_cached_only) {
-    return outcome_of(
-      hunks,
-      known2.map((entry) => held_of(entry))
-    );
-  }
-  const { verdicts, staged } = await verdicts_on(paths, { ...read3, known: known2, keys: keys2, options });
-  return { ...outcome_of(hunks, verdicts), ...cut_of(hunks, verdicts), staged };
-}
-async function hinted_hunks(outcome, reach) {
-  return await Promise.all(
-    outcome.unpinned.map(async (hunk) => ({
-      ...hunk,
-      related_tests: await reach.related(hunk.file)
-    }))
-  );
-}
-async function outcome_on(cache, paths, changed, options) {
-  if (changed.length === 0) return NO_OUTCOME;
-  const counts = await counts_of(changed, cache.reach);
-  const { checked, unchecked } = test_pinned_logic.capped(changed, counts);
-  const capped_options = { ...options, over_cap: unchecked.length };
-  const outcome = await checked_outcome(paths, { hunks: checked, counts, cache }, capped_options);
-  const unpinned = await hinted_hunks(outcome, cache.reach);
-  return { ...outcome, unpinned, ...over_cap_of(unchecked) };
-}
-async function added_scripts(base, targets) {
-  const held = new Set(await changed_paths.read_held_at(base, targets));
-  return targets.filter((file) => !held.has(file) && test_pinned_functions.is_script(file));
-}
-async function stub_hunks_of(added) {
-  const api = review_code_tree.load_typescript(process.cwd());
-  if (api === void 0) return { hunks: [], unparsed: added };
-  const contents = await Promise.all(added.map(async (file) => await readFile4(file, "utf8")));
-  const hunks = added.flatMap(
-    (file, index) => test_pinned_functions.stub_hunks(api, file, contents[index] ?? "")
-  );
-  return { hunks, unparsed: [] };
-}
-async function runtime_hunks(hunks) {
-  const grouped = test_pinned_moves.group(hunks);
-  const api = review_code_tree.load_typescript(process.cwd());
-  if (api === void 0) return { hunks: grouped, unparsed: [], rewired: 0 };
-  const contents = await Promise.all(grouped.map(async (hunk) => await readFile4(hunk.file, "utf8")));
-  return { ...test_pinned_emit.probed_of(api, grouped, contents), unparsed: [] };
-}
-async function read_probes(base, targets) {
-  const stubs = await stub_hunks_of(await added_scripts(base, targets));
-  const changed = await runtime_hunks(await read_hunks(base, targets));
-  const hunks = [...changed.hunks, ...stubs.hunks];
-  return { hunks, unparsed: stubs.unparsed, rewired: changed.rewired };
-}
-async function existing_since(commit) {
-  const changed = await changed_paths.read_changed_since(commit);
-  return changed.filter((file) => existsSync3(file));
-}
-async function report_on(base, options, has_runner) {
-  const { max_hunks } = options;
-  const paths = await existing_since(HEAD2);
-  const changed = await existing_since(base);
-  const targets = await test_pinned_reach.probed_files(
-    changed.filter((file) => test_pinned_logic.is_target(file))
-  );
-  const probes = await read_probes(base, targets);
-  const cache = await test_pinned_cache.load(base, probes.hunks, options.cache_file);
-  const { checked, unchecked } = await test_pinned_carry.select(cache, has_runner ? max_hunks : 0);
-  if (!options.is_cached_only) test_pinned_carry.record(cache, unchecked);
-  const outcome = await outcome_on(cache, paths, checked, { ...options, rewired: probes.rewired });
-  return { ...outcome, unchecked, unparsed: probes.unparsed, max_hunks, has_runner };
-}
-async function report(options) {
-  const base = await change_base.resolved_through_merge();
-  const has_runner = test_red.has_runner();
-  if (base === void 0) return { ...NO_REPORT, max_hunks: options.max_hunks, has_runner };
-  const root = process.cwd();
-  const result = await test_pinned_snapshot.with_snapshot(async (snapshot) => ({
-    ...await report_on(base, { ...options, cache_file: snapshot.cache_file }, has_runner),
-    tree_hash: snapshot.tree_hash
-  }));
-  return { ...result, is_stale: test_pinned_snapshot.current_hash(root) !== result.tree_hash };
-}
-async function run(max_hunks, is_first_unpinned = false, origin) {
-  return await report({ max_hunks, is_cached_only: false, is_first_unpinned, origin });
-}
-async function cached(max_hunks) {
-  return await report({ max_hunks, is_cached_only: true });
-}
-async function held_report(max_hunks) {
-  const read3 = await cached(max_hunks);
-  return read3.is_held === true ? read3 : void 0;
-}
-var test_pinned = { cached, held_report, run };
-
-export {
-  test_pinned_record,
-  test_pinned_ledger,
-  test_pinned
-};