@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-K3LHBJDY.js

@@ -0,0 +1,1223 @@
+import {
+  test_red
+} from "./chunk-QHWQJCV5.js";
+import {
+  review_code_tree
+} from "./chunk-EKKUHXFD.js";
+import {
+  related_heavy_tests
+} from "./chunk-FQPL6T66.js";
+import {
+  direct_importers
+} from "./chunk-7GICNM73.js";
+import {
+  test_pinned_logic,
+  test_pinned_stage
+} from "./chunk-I36PDO6I.js";
+import {
+  test_pinned_cache_logic,
+  test_pinned_reach
+} from "./chunk-PTJ6X3QK.js";
+import {
+  related_scope
+} from "./chunk-QA44M56F.js";
+import {
+  test_unit_guard
+} from "./chunk-TXXEXJAV.js";
+import {
+  gate_log
+} from "./chunk-VCWNMRH7.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  config_fingerprint,
+  test_runner_config
+} from "./chunk-HQ5U6OZR.js";
+import {
+  import_graph
+} from "./chunk-CVZXDKCV.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  base_tree
+} from "./chunk-H6TBBVC2.js";
+import {
+  lane_ledger_pinned_origin
+} from "./chunk-Y2RNUX4W.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  unit_worker_share
+} from "./chunk-MTPFNRYF.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.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-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.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
+};