@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/hooks/chunk-46PTTMGE.js

@@ -0,0 +1,1625 @@
+import {
+  input_fingerprint,
+  lint_related_scope,
+  resolve_tsx_runner,
+  run_board_usage_rusage,
+  toolchain_inputs
+} from "./chunk-WCJ2GWYJ.js";
+import {
+  core_weights,
+  direct_launch,
+  pnpm_reach,
+  project_checks,
+  resolve_package_bin
+} from "./chunk-L6IZZ2IL.js";
+import {
+  ESLINT_EDIT_CACHE_FLAGS,
+  cost_blocks,
+  find_package_directory,
+  time_batch_guard,
+  time_hook_transcript,
+  time_round_trips,
+  time_spans,
+  transcript_tail
+} from "./chunk-UZXMFOVK.js";
+import {
+  file_reader
+} from "./chunk-YRKS5ZKE.js";
+import {
+  HOOK_PROCESS_TIMEOUT_MS,
+  LINT_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS,
+  atomic_write,
+  execa,
+  external_exports,
+  git_common_directory,
+  git_spawn_sync,
+  json_value,
+  stamp_file
+} from "./chunk-CY3ADSDR.js";
+
+// scripts/time-runtime/time-density.ts
+var MIN_ROUND_TRIPS = 10;
+var NOTICE_INTERVAL_MS = 3e5;
+var ONE_CALL = 1;
+var NONE = 0;
+function has_whole_tail(text) {
+  const last = text.split("\n").findLast((line) => line.trim() !== "");
+  return last !== void 0 && time_spans.parse_line(last) !== void 0;
+}
+function assistant_lines(text) {
+  return text.split("\n").map((line) => time_spans.parse_line(line)).filter((line) => line?.type === time_spans.ASSISTANT_TYPE);
+}
+function last_turn_calls(text) {
+  if (!has_whole_tail(text)) return NONE;
+  const lines = assistant_lines(text);
+  const message_id = lines.at(-1)?.message_id;
+  if (message_id === void 0 || message_id === time_spans.NO_MESSAGE_ID) return NONE;
+  return lines.filter((line) => line.message_id === message_id).flatMap((line) => line.blocks).filter((block) => block.type === cost_blocks.TOOL_USE_TYPE).length;
+}
+function read_window(text) {
+  const { spans } = time_spans.parse_timeline(text);
+  const round_trip_count = time_round_trips.count_round_trips(spans);
+  const call_count = time_round_trips.count_calls(spans);
+  return {
+    density: time_round_trips.per_round_trip(call_count, round_trip_count),
+    round_trip_count,
+    turn_calls: last_turn_calls(text)
+  };
+}
+function is_due(reading, since_last_ms) {
+  if (reading.round_trip_count < MIN_ROUND_TRIPS || reading.turn_calls !== ONE_CALL || !time_round_trips.is_below_floor(reading.density)) {
+    return false;
+  }
+  return since_last_ms >= NOTICE_INTERVAL_MS;
+}
+function format_notice(reading, candidates = "") {
+  const density = time_round_trips.format_density(reading.density);
+  const floor = time_round_trips.format_density(time_round_trips.CALLS_PER_ROUND_TRIP_FLOOR);
+  return `\u26A0 batching: ${density} calls per round trip over the last ${String(reading.round_trip_count)}, under the ${floor} floor, and this turn issued one call. Independent reads, greps, gh queries and edits go out together; the criterion is whether this call's input needs another call's result, not what kind of call it is \u2014 prompts/collaboration-workflow/turn-batching.md.${candidates}`;
+}
+var time_density = {
+  MIN_ROUND_TRIPS,
+  NOTICE_INTERVAL_MS,
+  format_notice,
+  is_due,
+  last_turn_calls,
+  read_window
+};
+
+// scripts/time-runtime/time-density-hook.ts
+var NOTICE_PREFIX = "josh-density-notice-";
+var NEVER_MS = 0;
+var payload_schema = external_exports.object({
+  transcript_path: external_exports.string().min(1).optional(),
+  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
+  // fork"; rejected, it would fail `safeParse` for the whole payload and silence the line for every
+  // edit of the main line — the opposite of this module's stated failure direction.
+  agent_id: external_exports.string().nullish()
+});
+var notice_schema = external_exports.object({ notified_at_ms: external_exports.number() });
+var call_schema = external_exports.object({ tool_name: external_exports.string().min(1), tool_input: external_exports.unknown() });
+function parse_transcript_path(raw_payload) {
+  const payload = json_value.parse_with(raw_payload, payload_schema);
+  if (payload?.transcript_path === void 0) return void 0;
+  return time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
+}
+function parse_call(raw_payload) {
+  const call = json_value.parse_with(raw_payload, call_schema);
+  if (call === void 0) return void 0;
+  return { name: call.tool_name, input: call.tool_input };
+}
+function notice_path(transcript_path) {
+  return stamp_file.stamp_path(NOTICE_PREFIX, transcript_path);
+}
+function last_notice_ms(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return NEVER_MS;
+  return json_value.parse_with(raw, notice_schema)?.notified_at_ms ?? NEVER_MS;
+}
+function arm_throttle(target, now_ms) {
+  try {
+    stamp_file.write_stamp(target, { notified_at_ms: now_ms });
+  } catch {
+  }
+}
+function notice_for(raw_payload, now_ms) {
+  const transcript_path = parse_transcript_path(raw_payload);
+  if (transcript_path === void 0) return void 0;
+  const tail = transcript_tail.read_tail(transcript_path);
+  const reading = time_density.read_window(tail);
+  const target = notice_path(transcript_path);
+  if (!time_density.is_due(reading, now_ms - last_notice_ms(target))) return void 0;
+  const candidates = time_batch_guard.pairing_candidates(tail, parse_call(raw_payload));
+  if (candidates === "") return void 0;
+  arm_throttle(target, now_ms);
+  return time_density.format_notice(reading, candidates);
+}
+function density_notice(raw_payload, now_ms = Date.now()) {
+  try {
+    return notice_for(raw_payload, now_ms);
+  } catch {
+    return void 0;
+  }
+}
+var time_density_hook = {
+  density_notice,
+  notice_path,
+  parse_call,
+  parse_transcript_path
+};
+
+// scripts/hooks/format-edited-file.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path9 from "node:path";
+
+// scripts/lint/eslint-daemon.ts
+import { createHash as createHash2 } from "node:crypto";
+import { lstatSync, readFileSync as readFileSync3 } from "node:fs";
+import { createRequire } from "node:module";
+import path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// eslint/untyped-environment.js
+var ENVIRONMENT_VARIABLE = "JOSH_ESLINT_UNTYPED";
+var ENABLED = "1";
+function is_requested(variables) {
+  return variables[ENVIRONMENT_VARIABLE] === ENABLED;
+}
+function environment() {
+  return { [ENVIRONMENT_VARIABLE]: ENABLED };
+}
+var untyped_environment = { environment, is_requested, ENVIRONMENT_VARIABLE };
+
+// scripts/lint/eslint-daemon-calls.ts
+import { appendFileSync, readFileSync } from "node:fs";
+import path from "node:path";
+var CALLS_RECORD = ".eslint_d-calls";
+var LINE_SEPARATOR = "\n";
+var DAEMON_RECORD_PID = /^\S+ \S+ (?<pid>\d+)/u;
+var LAST_LINE = /total=(?<total>\d+) pid=(?<pid>\d+)$/u;
+var DAEMON_CALLER = {
+  EDIT_HOOK: "edit-hook",
+  WARM: "warm",
+  PRE_COMMIT: "pre-commit",
+  LINT_RELATED: "lint:related"
+};
+function pid_of(daemon_record = "") {
+  return DAEMON_RECORD_PID.exec(daemon_record)?.groups?.["pid"];
+}
+function read_text(file) {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+function previous_total(text, pid) {
+  const groups = LAST_LINE.exec(text.trimEnd())?.groups;
+  if (groups?.["pid"] !== pid) return void 0;
+  return Number(groups["total"]);
+}
+function line_of(call, total, pid, now) {
+  const { caller, files } = call;
+  return `${now.toISOString()} caller=${caller} files=${String(files)} total=${String(total)} pid=${pid}${LINE_SEPARATOR}`;
+}
+function write_line(file, line, is_new_daemon) {
+  try {
+    if (is_new_daemon) atomic_write.replace_file(file, line);
+    else appendFileSync(file, line);
+  } catch {
+  }
+}
+function record(directory, daemon_record, call, now = /* @__PURE__ */ new Date()) {
+  const pid = pid_of(daemon_record);
+  if (pid === void 0) return;
+  const file = path.join(directory, CALLS_RECORD);
+  const previous = previous_total(read_text(file), pid);
+  write_line(file, line_of(call, (previous ?? 0) + call.files, pid, now), previous === void 0);
+}
+var eslint_daemon_calls = { pid_of, record, CALLS_RECORD, DAEMON_CALLER };
+
+// scripts/lint/eslint-daemon-sources.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+var CHANGED_FILES = ["diff", "HEAD", "--name-only", "--relative", "-z"];
+var NEW_FILES = ["ls-files", "--others", "--exclude-standard", "-z"];
+var PATH_SEPARATOR = "\0";
+var LINE_SEPARATOR2 = "\n";
+var ENTRY_SEPARATOR = "	";
+var DIGEST_ALGORITHM = "sha256";
+var ABSENT = "absent";
+var UNREAD = ":unread";
+function by_text(left, right) {
+  return left.localeCompare(right);
+}
+function lines_of(text) {
+  return text.split(LINE_SEPARATOR2).filter((line) => line !== "");
+}
+function content_digest(file) {
+  try {
+    return createHash(DIGEST_ALGORITHM).update(readFileSync2(file)).digest("hex");
+  } catch {
+    return ABSENT;
+  }
+}
+function changed_paths(project_root) {
+  const listed = [CHANGED_FILES, NEW_FILES].map(
+    (git_arguments) => git_spawn_sync.read(git_arguments, { cwd: project_root }) ?? UNREAD
+  );
+  const paths = listed.join(PATH_SEPARATOR).split(PATH_SEPARATOR);
+  return [...new Set(paths.filter((relative) => relative !== ""))];
+}
+function snapshot(project_root) {
+  return changed_paths(project_root).map(
+    (relative) => `${relative}${ENTRY_SEPARATOR}${content_digest(path2.join(project_root, relative))}`
+  ).toSorted(by_text).join(LINE_SEPARATOR2);
+}
+function refresh(recorded, current, relative) {
+  const prefix = `${relative}${ENTRY_SEPARATOR}`;
+  const [inputs = "", ...entries] = lines_of(recorded);
+  const others = entries.filter((line) => !line.startsWith(prefix));
+  const fresh = lines_of(current).filter((line) => line.startsWith(prefix));
+  return [inputs, ...[...others, ...fresh].toSorted(by_text)].join(LINE_SEPARATOR2);
+}
+var eslint_daemon_sources = { refresh, snapshot, LINE_SEPARATOR: LINE_SEPARATOR2 };
+
+// scripts/lint/eslint-heap.ts
+import path3 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// scripts/lib/buffered-process.ts
+import { existsSync } from "node:fs";
+var { PNPM } = pnpm_reach;
+var FORCE_COLOR = "1";
+function is_pnpm_missing(result, cwd) {
+  return pnpm_reach.is_not_found(result) && existsSync(cwd ?? process.cwd());
+}
+function unfinished_reason(result, cwd) {
+  if (result.exitCode !== void 0) return [];
+  const reason = [result.shortMessage ?? ""];
+  if (is_pnpm_missing(result, cwd)) reason.push(pnpm_reach.NOT_ON_PATH_NOTICE);
+  return reason;
+}
+function collect_output(all, reason) {
+  return [all, ...reason].filter((part) => part !== "").join("\n");
+}
+function child_environment() {
+  const environment3 = { ...process.env };
+  if (environment3["NO_COLOR"] === void 0) environment3["FORCE_COLOR"] = FORCE_COLOR;
+  else delete environment3["FORCE_COLOR"];
+  return environment3;
+}
+async function run_buffered_launch(launch, options) {
+  const started_at = performance.now();
+  const result = await execa(launch.file, [...launch.args], {
+    env: options.environment ?? child_environment(),
+    extendEnv: false,
+    all: true,
+    reject: false,
+    ...options.cwd !== void 0 && { cwd: options.cwd },
+    timeout: options.timeout_ms ?? SUITE_TIMEOUT_MS
+  });
+  return {
+    output: collect_output(result.all, unfinished_reason(result, options.cwd)),
+    exit_code: result.exitCode,
+    elapsed_ms: performance.now() - started_at
+  };
+}
+async function run_buffered_process(command_args, options = {}) {
+  return await run_buffered_launch({ file: PNPM, args: command_args }, options);
+}
+async function run_buffered_direct(pnpm_arguments, options = {}) {
+  const launch = direct_launch(options.cwd ?? process.cwd(), pnpm_arguments);
+  return await run_buffered_launch(launch, options);
+}
+function is_process_failed(result) {
+  return result.exit_code !== 0;
+}
+var buffered_process = {
+  child_environment,
+  is_process_failed,
+  run_buffered_direct,
+  run_buffered_process
+};
+
+// scripts/lint/eslint-heap.ts
+var { ESLINT_HEAP_MIB } = core_weights;
+var HEAP_FLAG = /--max[-_]old[-_]space[-_]size\b/u;
+var NODE_OPTIONS = "NODE_OPTIONS";
+var MODULE_DIRECTORY = path3.dirname(fileURLToPath(import.meta.url));
+var MEMORY_PATH = path3.join(
+  find_package_directory(MODULE_DIRECTORY),
+  "scripts/lint/eslint-memory.js"
+);
+var MEMORY_IMPORT = `--import=${pathToFileURL(MEMORY_PATH).href}`;
+function with_heap(given_options) {
+  const current = given_options?.trim() ?? "";
+  if (HEAP_FLAG.test(current)) return current;
+  const heap = `--max-old-space-size=${String(ESLINT_HEAP_MIB)}`;
+  return current === "" ? heap : `${current} ${heap}`;
+}
+function environment2() {
+  const child = buffered_process.child_environment();
+  return { ...child, [NODE_OPTIONS]: with_heap(child[NODE_OPTIONS]) };
+}
+async function run_cold(pnpm_arguments) {
+  const child = environment2();
+  return await buffered_process.run_buffered_direct(pnpm_arguments, {
+    environment: { ...child, [NODE_OPTIONS]: `${child[NODE_OPTIONS] ?? ""} ${MEMORY_IMPORT}` }
+  });
+}
+var eslint_heap = { environment: environment2, run_cold, with_heap };
+
+// scripts/lint/eslint-daemon.ts
+var ESLINT_DAEMON = "eslint_d";
+var DAEMON_STOP = "stop";
+var STOP_TIMEOUT_MS = 1e4;
+var PNPM_EXEC = "exec";
+var ESLINT_BIN = "eslint";
+var PNPM_ESLINT_PREFIX_LENGTH = 2;
+var NODE_MODULES = "node_modules";
+var DAEMON_RECORD = ".eslint_d";
+var FINGERPRINT_RECORD = ".eslint_d-toolchain";
+var RECORD_SEPARATOR = "\n";
+var NO_HEAD = "no-head";
+var LIST_FILES = ["ls-files", "--cached", "--others", "--exclude-standard"];
+var DIGEST_ALGORITHM2 = "sha256";
+var MODULE_DIRECTORY2 = path4.dirname(fileURLToPath2(import.meta.url));
+var DAEMON_STATE = {
+  REUSED: "daemon reused",
+  RESTARTED: "daemon restarted",
+  STARTED: "daemon started",
+  COLD_FALLBACK: "daemon unreachable, cold process"
+};
+function is_borrowed_install(project_root) {
+  return lstatSync(path4.join(project_root, NODE_MODULES), {
+    throwIfNoEntry: false
+  })?.isSymbolicLink() === true;
+}
+function resolve_daemon_cli(project_root) {
+  if (is_borrowed_install(project_root)) return void 0;
+  return resolve_package_bin(MODULE_DIRECTORY2, ESLINT_DAEMON, ESLINT_DAEMON) ?? resolve_package_bin(project_root, ESLINT_DAEMON, ESLINT_DAEMON);
+}
+function is_config_input(relative_path) {
+  return toolchain_inputs.is_input(relative_path);
+}
+function eslint_arguments_of(pnpm_arguments) {
+  if (pnpm_arguments[0] !== PNPM_EXEC || pnpm_arguments[1] !== ESLINT_BIN) return void 0;
+  return pnpm_arguments.slice(PNPM_ESLINT_PREFIX_LENGTH);
+}
+function digest_of(text) {
+  return createHash2(DIGEST_ALGORITHM2).update(text).digest("hex");
+}
+function fingerprint(project_root) {
+  const head = git_spawn_sync.read(["rev-parse", "HEAD"], { cwd: project_root }) ?? NO_HEAD;
+  const files = git_spawn_sync.read(LIST_FILES, { cwd: project_root }) ?? NO_HEAD;
+  const inputs = `${toolchain_inputs.digest(project_root)}:${head}:${digest_of(files)}`;
+  const sources = eslint_daemon_sources.snapshot(project_root);
+  return sources === "" ? inputs : `${inputs}${eslint_daemon_sources.LINE_SEPARATOR}${sources}`;
+}
+function eslint_directory(project_root) {
+  try {
+    return path4.dirname(
+      createRequire(path4.join(project_root, "package.json")).resolve("eslint/package.json")
+    );
+  } catch {
+    return void 0;
+  }
+}
+function read_text2(file) {
+  try {
+    return readFileSync3(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function read_record(project_root) {
+  const directory = eslint_directory(project_root);
+  if (directory === void 0) return { daemon: void 0, recorded: void 0 };
+  return {
+    daemon: read_text2(path4.join(directory, DAEMON_RECORD)),
+    recorded: read_text2(path4.join(directory, FINGERPRINT_RECORD))
+  };
+}
+function record_text(daemon, current) {
+  return `${daemon}${RECORD_SEPARATOR}${current}`;
+}
+function is_stale(record3, current) {
+  if (record3.daemon === void 0) return false;
+  return record3.recorded !== record_text(record3.daemon, current);
+}
+function state_of(record3, current) {
+  if (record3.daemon === void 0) return DAEMON_STATE.STARTED;
+  return is_stale(record3, current) ? DAEMON_STATE.RESTARTED : DAEMON_STATE.REUSED;
+}
+function remember(project_root, current) {
+  const directory = eslint_directory(project_root);
+  if (directory === void 0) return;
+  const daemon = read_text2(path4.join(directory, DAEMON_RECORD));
+  if (daemon === void 0) return;
+  try {
+    atomic_write.replace_file(
+      path4.join(directory, FINGERPRINT_RECORD),
+      record_text(daemon, current)
+    );
+  } catch {
+  }
+}
+function remember_read(project_root, record3, relative) {
+  const { daemon, recorded } = record3;
+  if (daemon === void 0 || recorded === void 0 || is_borrowed_install(project_root)) return;
+  const prefix = record_text(daemon, "");
+  if (!recorded.startsWith(prefix)) return;
+  const current = eslint_daemon_sources.snapshot(project_root);
+  remember(
+    project_root,
+    eslint_daemon_sources.refresh(recorded.slice(prefix.length), current, relative)
+  );
+}
+function remember_after_edit(project_root, before, edited) {
+  const after = read_record(project_root);
+  if (after.daemon !== before.daemon) remember(project_root, fingerprint(project_root));
+  else if (edited !== void 0) remember_read(project_root, after, edited);
+}
+function record_call(project_root, call) {
+  const directory = eslint_directory(project_root);
+  if (call === void 0 || directory === void 0 || is_borrowed_install(project_root)) return;
+  eslint_daemon_calls.record(directory, read_text2(path4.join(directory, DAEMON_RECORD)), call);
+}
+function launch_environment() {
+  return {
+    NODE_OPTIONS: eslint_heap.with_heap(process.env["NODE_OPTIONS"]),
+    ESLINT_D_MISS: "fail",
+    ...untyped_environment.environment()
+  };
+}
+function daemon_environment() {
+  return { ...eslint_heap.environment(), ...launch_environment() };
+}
+async function spawn_daemon(cli, cli_arguments, options) {
+  const result = await execa(process.execPath, [cli, ...cli_arguments], {
+    reject: false,
+    all: true,
+    cwd: options.project_root,
+    env: daemon_environment(),
+    extendEnv: false,
+    ...options.timeout_ms !== void 0 && { timeout: options.timeout_ms }
+  });
+  return { exit_code: result.exitCode ?? 1, stdout: result.stdout, output: result.all };
+}
+function is_start_failure(outcome) {
+  return outcome.exit_code !== 0 && outcome.stdout.length === 0;
+}
+async function run_current(cli, eslint_arguments, options) {
+  const { project_root } = options;
+  const current = fingerprint(project_root);
+  const daemon = state_of(read_record(project_root), current);
+  if (daemon === DAEMON_STATE.RESTARTED) await spawn_daemon(cli, [DAEMON_STOP], options);
+  const outcome = await spawn_daemon(cli, eslint_arguments, options);
+  if (is_start_failure(outcome)) return void 0;
+  remember(project_root, current);
+  record_call(project_root, options.call);
+  return { ...outcome, daemon };
+}
+async function stop(project_root) {
+  const cli = resolve_daemon_cli(project_root);
+  if (cli === void 0) return false;
+  const outcome = await spawn_daemon(cli, [DAEMON_STOP], {
+    project_root,
+    timeout_ms: STOP_TIMEOUT_MS
+  });
+  return outcome.exit_code === 0;
+}
+async function run(pnpm_arguments, options) {
+  const eslint_arguments = eslint_arguments_of(pnpm_arguments);
+  if (eslint_arguments === void 0) return void 0;
+  const cli = resolve_daemon_cli(options.project_root);
+  if (cli === void 0) return void 0;
+  return await run_current(cli, eslint_arguments, options);
+}
+async function run_or_cold(pnpm_arguments, call) {
+  const started_at = performance.now();
+  const outcome = await run(pnpm_arguments, { project_root: process.cwd(), call });
+  if (outcome === void 0) {
+    const cold = await eslint_heap.run_cold(pnpm_arguments);
+    return { ...cold, daemon: DAEMON_STATE.COLD_FALLBACK };
+  }
+  return {
+    output: outcome.output,
+    exit_code: outcome.exit_code,
+    elapsed_ms: performance.now() - started_at,
+    daemon: outcome.daemon
+  };
+}
+var eslint_daemon = {
+  eslint_arguments_of,
+  fingerprint,
+  is_config_input,
+  is_stale,
+  launch_environment,
+  read_record,
+  record_call,
+  record_text,
+  remember_after_edit,
+  resolve_daemon_cli,
+  run,
+  run_or_cold,
+  stop,
+  ESLINT_DAEMON
+};
+
+// scripts/lint/eslint-warm.ts
+import { spawn } from "node:child_process";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var WARM_CLI = fileURLToPath3(new URL("eslint-warm-cli.ts", import.meta.url));
+var TYPED_SOURCES = ["ls-files", "--", "*.ts", ":!*.d.ts"];
+var FALLBACK_TARGET = "eslint.config.js";
+var LINE_SEPARATOR3 = "\n";
+function warm_target(project_root) {
+  const listed = git_spawn_sync.read(TYPED_SOURCES, { cwd: project_root }) ?? "";
+  const [first] = listed.split(LINE_SEPARATOR3);
+  return first === void 0 || first === "" ? FALLBACK_TARGET : first;
+}
+async function warm(project_root) {
+  await eslint_daemon.run(["exec", "eslint", warm_target(project_root)], {
+    project_root,
+    timeout_ms: LINT_TIMEOUT_MS,
+    call: { caller: eslint_daemon_calls.DAEMON_CALLER.WARM, files: 1 }
+  });
+}
+function ignore_error() {
+}
+function start(project_root) {
+  if (process.env["VITEST"] !== void 0) return;
+  try {
+    const runner = resolve_tsx_runner();
+    const options = { cwd: project_root, detached: true, stdio: "ignore" };
+    const child = spawn(runner.executable, [...runner.leading_arguments, WARM_CLI], options);
+    child.on("error", ignore_error);
+    child.unref();
+  } catch {
+    ignore_error();
+  }
+}
+var eslint_warm = { start, warm };
+
+// scripts/lint/eslint-trim.ts
+var FOOTPRINT_LIMIT_MB = 600;
+var BYTES_PER_KB = 1024;
+var BYTES_PER_MB = BYTES_PER_KB * BYTES_PER_KB;
+function default_reader() {
+  return run_board_usage_rusage.rusage_reader(process.platform, run_board_usage_rusage.load_builtin);
+}
+function is_heavy(project_root, reader) {
+  const pid = eslint_daemon_calls.pid_of(eslint_daemon.read_record(project_root).daemon);
+  if (pid === void 0 || reader === void 0) return false;
+  const footprint_bytes = reader(Number(pid))?.footprint_bytes ?? 0;
+  return footprint_bytes > FOOTPRINT_LIMIT_MB * BYTES_PER_MB;
+}
+async function trim(project_root, reader = default_reader()) {
+  if (!is_heavy(project_root, reader) || !await eslint_daemon.stop(project_root)) return false;
+  eslint_warm.start(project_root);
+  return true;
+}
+var eslint_trim = { trim, BYTES_PER_MB, FOOTPRINT_LIMIT_MB };
+
+// scripts/lint/eslint-cache-dependencies.ts
+import { rmSync, writeFileSync } from "node:fs";
+import path7 from "node:path";
+import { parse, stringify } from "flatted";
+
+// scripts/lint/import-graph.ts
+import path6 from "node:path";
+
+// scripts/lint/import-graph-store.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path5 from "node:path";
+var STORE_VERSION = 1;
+var STORE_NAME = `import-graph.v${String(STORE_VERSION)}.json`;
+var ENVIRONMENT_FILES = ["package.json", "pnpm-lock.yaml"];
+var EXTENSION = /(?:\.d)?\.[^./]+$/u;
+var INDEX = "index";
+var stored_dependency = external_exports.tuple([external_exports.string(), external_exports.boolean()]);
+var stored_file = external_exports.object({
+  hash: external_exports.string(),
+  all: external_exports.array(stored_dependency).optional(),
+  runtime: external_exports.array(stored_dependency).optional()
+});
+var stored_graph = external_exports.object({
+  version: external_exports.literal(STORE_VERSION),
+  environment: external_exports.string(),
+  files: external_exports.record(external_exports.string(), stored_file)
+});
+function store_path(root) {
+  const common = git_common_directory.repository(root);
+  return common === void 0 ? void 0 : path5.join(common, git_common_directory.STATE_DIRECTORY, STORE_NAME);
+}
+function environment_of(root, config_files) {
+  const relatives = [...config_files.map((file) => path5.relative(root, file)), ...ENVIRONMENT_FILES];
+  const digests = Object.entries(input_fingerprint.of_files(root, relatives));
+  return input_fingerprint.of_entries(digests.map(([file, digest]) => `${file}:${digest}`));
+}
+function open(root, config_files) {
+  return {
+    root,
+    environment: environment_of(root, config_files),
+    file_path: store_path(root),
+    files: void 0,
+    seeded: /* @__PURE__ */ new Set(),
+    memo: { all: /* @__PURE__ */ new Map(), runtime: /* @__PURE__ */ new Map() },
+    unresolved: { all: /* @__PURE__ */ new Set(), runtime: /* @__PURE__ */ new Set() },
+    content_hashes: /* @__PURE__ */ new Map()
+  };
+}
+function remember2(store, name, file, references) {
+  const found = references.filter((dependency) => dependency !== void 0);
+  if (found.length < references.length) store.unresolved[name].add(file);
+  store.memo[name].set(file, found);
+  return found;
+}
+function content_hash(store, file) {
+  const known = store.content_hashes.get(file);
+  if (known !== void 0) return known;
+  const computed = input_fingerprint.of_file(file);
+  store.content_hashes.set(file, computed);
+  return computed;
+}
+function read_files(store) {
+  const text = store.file_path === void 0 ? void 0 : file_reader.read_if_readable(store.file_path);
+  const stored = text === void 0 ? void 0 : json_value.parse_with(text, stored_graph);
+  return stored?.environment === store.environment ? stored.files : {};
+}
+function files_of(store) {
+  store.files ??= read_files(store);
+  return store.files;
+}
+function module_stem(file) {
+  const stem = file.replace(EXTENSION, "");
+  return path5.basename(stem) === INDEX ? path5.dirname(stem) : stem;
+}
+function added_stems(store, universe) {
+  const files = files_of(store);
+  const added = universe.filter((file) => !Object.hasOwn(files, path5.relative(store.root, file)));
+  return new Set(added.map((file) => module_stem(file)));
+}
+function rebased(store, stored) {
+  return stored.map(([file, external]) => ({ file: path5.join(store.root, file), external }));
+}
+function is_standing(dependency, seeding) {
+  return existsSync2(dependency.file) && !seeding.added.has(module_stem(dependency.file));
+}
+function stored_edges(store, name, file, seeding) {
+  const entry = seeding.files[path5.relative(store.root, file)];
+  const stored = entry?.hash === content_hash(store, file) ? entry[name] : void 0;
+  if (stored === void 0) return void 0;
+  const dependencies = rebased(store, stored);
+  return dependencies.every((dependency) => is_standing(dependency, seeding)) ? dependencies : void 0;
+}
+function seed(store, name, universe) {
+  if (store.seeded.has(name)) return [];
+  store.seeded.add(name);
+  const seeding = { files: files_of(store), added: added_stems(store, universe) };
+  const memo = store.memo[name];
+  return universe.filter((file) => {
+    const stored = stored_edges(store, name, file, seeding);
+    if (stored !== void 0 && !memo.has(file)) memo.set(file, stored);
+    return stored === void 0;
+  });
+}
+function entry_of(store, name, file) {
+  const dependencies = store.memo[name].get(file);
+  if (dependencies === void 0 || store.unresolved[name].has(file)) return void 0;
+  const hash = content_hash(store, file);
+  const known = files_of(store)[path5.relative(store.root, file)];
+  const entry = known?.hash === hash ? { ...known } : { hash };
+  entry[name] = dependencies.map((dependency) => [
+    path5.relative(store.root, dependency.file),
+    dependency.external
+  ]);
+  return entry;
+}
+function write(store, file_path) {
+  const files = Object.entries(files_of(store)).filter(
+    ([file]) => existsSync2(path5.join(store.root, file))
+  );
+  const graph = {
+    version: STORE_VERSION,
+    environment: store.environment,
+    files: Object.fromEntries(files)
+  };
+  atomic_write.replace_file(file_path, JSON.stringify(graph));
+}
+function keep(store, name, missing) {
+  if (missing.length === 0 || store.file_path === void 0) return;
+  const files = files_of(store);
+  for (const file of missing) {
+    const entry = entry_of(store, name, file);
+    if (entry !== void 0) files[path5.relative(store.root, file)] = entry;
+  }
+  write(store, store.file_path);
+}
+var import_graph_store = { content_hash, keep, open, remember: remember2, seed, store_path };
+
+// scripts/test/test-inputs.ts
+var GLOBALS = /* @__PURE__ */ new Set([
+  "undefined",
+  "NaN",
+  "Infinity",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "BigInt",
+  "Symbol",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "JSON",
+  "RegExp",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "Promise",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite"
+]);
+var UNSAFE = /* @__PURE__ */ new Set([
+  "process",
+  "global",
+  "globalThis",
+  "eval",
+  "Function",
+  "require",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "vi",
+  "vitest",
+  "inject",
+  "provide",
+  "toMatchSnapshot",
+  "toMatchFileSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "matchSnapshot"
+]);
+function is_property(typescript, node) {
+  const { parent } = node;
+  return typescript.isPropertyAccessExpression(parent) && parent.name === node || (typescript.isPropertyAssignment(parent) || typescript.isMethodDeclaration(parent)) && parent.name === node;
+}
+function is_unsafe_syntax(typescript, node) {
+  return [
+    typescript.isNamespaceImport(node),
+    typescript.isElementAccessExpression(node),
+    node.kind === typescript.SyntaxKind.ThisKeyword,
+    typescript.isMetaProperty(node)
+  ].includes(true);
+}
+function is_dynamic_import(typescript, node) {
+  return typescript.isCallExpression(node) && node.expression.kind === typescript.SyntaxKind.ImportKeyword;
+}
+function is_unknown_identifier(typescript, node, checker) {
+  if (UNSAFE.has(node.text)) return true;
+  return !is_property(typescript, node) && checker.getSymbolAtLocation(node) === void 0 && !GLOBALS.has(node.text);
+}
+function is_unknown(typescript, node, checker) {
+  if (is_unsafe_syntax(typescript, node) || is_dynamic_import(typescript, node)) return true;
+  if (!typescript.isIdentifier(node)) return false;
+  return is_unknown_identifier(typescript, node, checker);
+}
+function is_closed(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest, true);
+  const host = typescript.createCompilerHost({});
+  host.getSourceFile = (name) => name === file ? source : void 0;
+  const program = typescript.createProgram([file], { noLib: true, noResolve: true }, host);
+  const checker = program.getTypeChecker();
+  function unknown(node) {
+    if (typescript.isTypeNode(node)) return false;
+    return is_unknown(typescript, node, checker) || typescript.forEachChild(node, unknown) === true;
+  }
+  return program.getSyntacticDiagnostics(source).length === 0 && !unknown(source);
+}
+var test_inputs = { is_closed };
+
+// scripts/lint/type-only-imports.ts
+function declaration_of(typescript, statement) {
+  if (typescript.isImportDeclaration(statement)) return statement;
+  if (typescript.isExportDeclaration(statement)) return statement;
+  return void 0;
+}
+function is_type_only(typescript, declaration) {
+  if (typescript.isExportDeclaration(declaration)) return declaration.isTypeOnly;
+  return declaration.importClause?.phaseModifier === typescript.SyntaxKind.TypeKeyword;
+}
+function type_only_position(typescript, source, statement) {
+  const declaration = declaration_of(typescript, statement);
+  if (declaration === void 0 || !is_type_only(typescript, declaration)) return void 0;
+  const specifier = declaration.moduleSpecifier;
+  if (specifier === void 0 || !typescript.isStringLiteral(specifier)) return void 0;
+  return specifier.getStart(source);
+}
+function runtime_specifiers(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const type_only = new Set(
+    source.statements.map((statement) => type_only_position(typescript, source, statement))
+  );
+  return typescript.preProcessFile(content, true, true).importedFiles.filter((reference) => !type_only.has(reference.pos)).map((reference) => reference.fileName);
+}
+function strings(typescript, file) {
+  const content = file_reader.read_if_readable(file) ?? "";
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const found = [];
+  function visit(node) {
+    if (typescript.isStringLiteralLike(node) || typescript.isTemplateLiteralToken(node)) {
+      found.push(node.text);
+    }
+    typescript.forEachChild(node, visit);
+  }
+  visit(source);
+  return found;
+}
+var type_only_imports = { runtime_specifiers, strings };
+
+// scripts/lint/import-test-inputs.ts
+var DECLARATION_EXTENSION = /\.d\.[cm]?ts$/u;
+var TYPESCRIPT_EXTENSION = /\.[cm]?tsx?$/u;
+var JAVASCRIPT_EXTENSIONS = ["js", "jsx", "mjs", "cjs"];
+function is_runtime_source(typescript, file) {
+  if (DECLARATION_EXTENSION.test(file)) return false;
+  if (!TYPESCRIPT_EXTENSION.test(file)) return true;
+  return JAVASCRIPT_EXTENSIONS.every(
+    (extension) => !typescript.sys.fileExists(file.replace(TYPESCRIPT_EXTENSION, () => `.${extension}`))
+  );
+}
+function dependencies_of(typescript, resolve, file, content) {
+  const specifiers = type_only_imports.runtime_specifiers(typescript, file, content);
+  const dependencies = specifiers.filter((name) => name !== "vitest").map((name) => name.startsWith(".") ? resolve(name, file) : void 0);
+  if (dependencies.some((dependency) => dependency === void 0 || dependency.external)) {
+    return void 0;
+  }
+  return dependencies.flatMap((dependency) => dependency?.file ?? []);
+}
+function read_source(typescript, resolve, file) {
+  if (!is_runtime_source(typescript, file)) return void 0;
+  const content = file_reader.read_if_readable(file);
+  if (content === void 0 || !test_inputs.is_closed(typescript, file, content)) return void 0;
+  return dependencies_of(typescript, resolve, file, content);
+}
+function unvisited(file, reached, read) {
+  return reached.has(file) ? [] : read(file);
+}
+function closure(file, read) {
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [file];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    const dependencies = unvisited(current, reached, read);
+    if (dependencies === void 0) return void 0;
+    reached.add(current);
+    pending.push(...dependencies);
+  }
+  return [...reached];
+}
+function create(typescript, resolve) {
+  const cache = /* @__PURE__ */ new Map();
+  function read(file) {
+    if (!cache.has(file)) cache.set(file, read_source(typescript, resolve, file));
+    return cache.get(file);
+  }
+  return (file) => closure(file, read);
+}
+var import_test_inputs2 = { create };
+
+// scripts/lint/import-graph.ts
+var TSCONFIG = "tsconfig.json";
+var NODE_MODULES2 = "node_modules";
+var MODULE_STATEMENT = /^(?:import|export)\b/mu;
+var GLOBAL_DECLARATION = /^declare (?:global|module|namespace)\b/mu;
+async function load_typescript() {
+  try {
+    const module = await import("typescript");
+    return module.default;
+  } catch {
+    return void 0;
+  }
+}
+function parsed_config(typescript, root) {
+  const config_file = path6.join(root, TSCONFIG);
+  if (!typescript.sys.fileExists(config_file)) return void 0;
+  const source = typescript.readJsonConfigFile(config_file, typescript.sys.readFile);
+  const parsed = typescript.parseJsonSourceFileConfigFileContent(
+    source,
+    typescript.sys,
+    root,
+    void 0,
+    config_file
+  );
+  return {
+    options: parsed.options,
+    file_names: parsed.fileNames,
+    config_files: [config_file, ...source.extendedSourceFiles ?? []]
+  };
+}
+function is_installed(file) {
+  return file.split(path6.sep).includes(NODE_MODULES2);
+}
+function as_dependency(file, external) {
+  if (file === void 0) return void 0;
+  return { file, external: external === true && is_installed(file) };
+}
+function relative_to(specifier, file) {
+  return { file: path6.resolve(path6.dirname(file), specifier), external: false };
+}
+function resolve_module(context, specifier, file) {
+  const { typescript, options, resolution_cache } = context;
+  const resolved = typescript.resolveModuleName(
+    specifier,
+    file,
+    options,
+    typescript.sys,
+    resolution_cache
+  ).resolvedModule;
+  if (resolved !== void 0) {
+    return as_dependency(resolved.resolvedFileName, resolved.isExternalLibraryImport);
+  }
+  if (!specifier.startsWith(".")) return void 0;
+  return relative_to(specifier, file);
+}
+function resolve_type(resolver, name, file) {
+  const { typescript, options } = resolver;
+  const resolved = typescript.resolveTypeReferenceDirective(
+    name,
+    file,
+    options,
+    typescript.sys
+  ).resolvedTypeReferenceDirective;
+  return as_dependency(resolved?.resolvedFileName, resolved?.isExternalLibraryImport);
+}
+function references_of(context, file, content) {
+  const processed = context.typescript.preProcessFile(content, true, true);
+  return [
+    ...processed.importedFiles.map(
+      (reference) => resolve_module(context, reference.fileName, file)
+    ),
+    ...processed.referencedFiles.map((reference) => relative_to(reference.fileName, file)),
+    ...processed.typeReferenceDirectives.map(
+      (reference) => resolve_type(context, reference.fileName, file)
+    )
+  ];
+}
+function direct_dependencies(context, file) {
+  const known = context.store.memo.all.get(file);
+  if (known !== void 0) return known;
+  const references = references_of(context, file, file_reader.read_if_readable(file) ?? "");
+  return import_graph_store.remember(context.store, "all", file, references);
+}
+function runtime_dependencies(context, file) {
+  const known = context.store.memo.runtime.get(file);
+  if (known !== void 0) return known;
+  const content = file_reader.read_if_readable(file) ?? "";
+  const references = type_only_imports.runtime_specifiers(context.typescript, file, content).map((specifier) => resolve_module(context, specifier, file));
+  return import_graph_store.remember(context.store, "runtime", file, references);
+}
+function is_ambient(file) {
+  const content = file_reader.read_if_readable(file) ?? "";
+  return GLOBAL_DECLARATION.test(content) || !MODULE_STATEMENT.test(content);
+}
+function ambient_of(resolver, root, config) {
+  const config_file = path6.join(root, TSCONFIG);
+  const declarations = [
+    ...config.file_names.filter((file) => is_ambient(file)),
+    ...config.config_files
+  ].map((file) => ({ file, external: false }));
+  const types = resolver.typescript.getAutomaticTypeDirectiveNames(resolver.options, resolver.typescript.sys).map((name) => resolve_type(resolver, name, config_file)).filter((dependency) => dependency !== void 0);
+  return [...declarations, ...types];
+}
+function is_unvisited(dependency, start2, reached) {
+  return dependency.file !== start2 && !reached.has(dependency.file);
+}
+function join(dependencies, start2, reached) {
+  const next = dependencies.filter((dependency) => is_unvisited(dependency, start2, reached));
+  for (const dependency of next) reached.set(dependency.file, dependency);
+  return next.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function reachable(context, file) {
+  const reached = /* @__PURE__ */ new Map();
+  const pending = [file, ...join(context.ambient, file, reached)];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    pending.push(...join(direct_dependencies(context, current), file, reached));
+  }
+  return reached;
+}
+function token_of(context, dependency) {
+  const name = path6.relative(context.root, dependency.file);
+  if (dependency.external) return name;
+  return `${name}:${import_graph_store.content_hash(context.store, dependency.file)}`;
+}
+function closure_hash(context, file) {
+  const tokens = [...reachable(context, file).values()].map(
+    (dependency) => token_of(context, dependency)
+  );
+  return input_fingerprint.of_entries(tokens);
+}
+function closure2(context, file) {
+  return [...reachable(context, file).values()].filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function imports(context, file, content) {
+  const dependencies = content === void 0 ? direct_dependencies(context, file) : references_of(context, file, content).filter((dependency) => dependency !== void 0);
+  return dependencies.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function append(map, key, value) {
+  const known = map.get(key);
+  if (known === void 0) map.set(key, [value]);
+  else known.push(value);
+}
+function reverse_edges(context, universe, edges) {
+  const reverse = /* @__PURE__ */ new Map();
+  const missing = import_graph_store.seed(context.store, edges.name, universe);
+  for (const file of universe) {
+    for (const dependency of edges.of(context, file)) {
+      append(reverse, dependency.file, file);
+    }
+  }
+  import_graph_store.keep(context.store, edges.name, missing);
+  return reverse;
+}
+function importers(context, files, universe, edges) {
+  const reverse = reverse_edges(context, universe, edges);
+  const reached = new Set(files);
+  const pending = [...files];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    const next = (reverse.get(current) ?? []).filter((file) => !reached.has(file));
+    for (const file of next) reached.add(file);
+    pending.push(...next);
+  }
+  return reached;
+}
+function project_module(context, specifier, file) {
+  const dependency = resolve_module(context, specifier, file);
+  if (dependency === void 0) return void 0;
+  const relative = path6.relative(context.root, dependency.file);
+  return relative.startsWith(`..${path6.sep}`) || path6.isAbsolute(relative) ? void 0 : dependency;
+}
+function graph_of(context) {
+  return {
+    // Type-checker suffixes need not select the source the runner executes.
+    test_inputs: context.options.moduleSuffixes === void 0 ? import_test_inputs2.create(
+      context.typescript,
+      (specifier, file) => project_module(context, specifier, file)
+    ) : void 0,
+    closure: (file) => closure2(context, file),
+    closure_hash: (file) => closure_hash(context, file),
+    imports: (file, content) => imports(context, file, content),
+    importers: (files, universe) => importers(context, files, universe, { name: "all", of: direct_dependencies }),
+    runtime_importers: (files, universe) => importers(context, files, universe, { name: "runtime", of: runtime_dependencies }),
+    strings: (file) => type_only_imports.strings(context.typescript, file)
+  };
+}
+async function create2(root) {
+  const typescript = await load_typescript();
+  if (typescript === void 0) return void 0;
+  const parsed = parsed_config(typescript, root);
+  if (parsed === void 0) return void 0;
+  return graph_of({
+    root,
+    typescript,
+    options: parsed.options,
+    resolution_cache: typescript.createModuleResolutionCache(root, (name) => name, parsed.options),
+    ambient: ambient_of({ typescript, options: parsed.options }, root, parsed),
+    store: import_graph_store.open(root, parsed.config_files)
+  });
+}
+var import_graph = { create: create2 };
+
+// scripts/lint/eslint-cache-dependencies.ts
+function is_record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function is_entry(item) {
+  if (!is_record(item)) return false;
+  const { key, value } = item;
+  return typeof key === "string" && is_record(value);
+}
+function is_entries(value) {
+  return Array.isArray(value) && value.every((item) => is_entry(item));
+}
+function parsed_or_undefined(content) {
+  try {
+    return parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function read_entries(cache_file) {
+  const content = file_reader.read_optional(cache_file);
+  if (content === void 0) return void 0;
+  const parsed = parsed_or_undefined(content);
+  return is_entries(parsed) ? parsed : void 0;
+}
+function read_or_discard(cache_file) {
+  const entries = read_entries(cache_file);
+  if (entries === void 0) rmSync(cache_file, { force: true });
+  return entries ?? [];
+}
+function write_entries(cache_file, entries) {
+  writeFileSync(cache_file, stringify(entries));
+}
+function recorded_hash(entry) {
+  const { data } = entry.value;
+  if (!is_record(data)) return void 0;
+  const { dependencies } = data;
+  return typeof dependencies === "string" ? dependencies : void 0;
+}
+function drop_stale(cache_file, graph) {
+  const entries = read_or_discard(cache_file);
+  const hashes = new Map(entries.map((entry) => [entry.key, graph.closure_hash(entry.key)]));
+  const kept = entries.filter((entry) => recorded_hash(entry) === hashes.get(entry.key));
+  if (kept.length !== entries.length) write_entries(cache_file, kept);
+  return { hashes, drop: { dropped: entries.length - kept.length, total: entries.length } };
+}
+function record_entry(entry, hashes, graph) {
+  const { data } = entry.value;
+  if (!is_record(data) || "dependencies" in data) return false;
+  Object.assign(data, { dependencies: hashes.get(entry.key) ?? graph.closure_hash(entry.key) });
+  return true;
+}
+function record2(cache_file, hashes, graph) {
+  const entries = read_entries(cache_file);
+  if (entries === void 0) return;
+  const recorded = entries.filter((entry) => record_entry(entry, hashes, graph));
+  if (recorded.length > 0) write_entries(cache_file, entries);
+}
+async function guard_counted(cache_file, run3, root = process.cwd()) {
+  const graph = await import_graph.create(root);
+  if (graph === void 0) return { result: await run3() };
+  const location = path7.resolve(root, cache_file);
+  const { hashes, drop } = drop_stale(location, graph);
+  const result = await run3();
+  record2(location, hashes, graph);
+  return { result, drop };
+}
+async function guard(cache_file, run3, root = process.cwd()) {
+  const { result } = await guard_counted(cache_file, run3, root);
+  return result;
+}
+var eslint_cache_dependencies = { guard, guard_counted };
+
+// scripts/lint/lint-shard.ts
+var SHARD_FLAG_PREFIX = "--shard=";
+var FIRST_SHARD = 1;
+var SECOND_SHARD = 2;
+var WHOLE_TREE = ".";
+var IGNORE_PATTERN_FLAG = "--ignore-pattern";
+var FORMATTING_SHARD_REASON = `shard ${String(FIRST_SHARD)} checks the whole tree's formatting`;
+var FIRST_SHARD_DIRECTORIES = [
+  "scripts/run",
+  "scripts/issue",
+  "scripts/epic",
+  "scripts/review"
+];
+var SHARDS = [FIRST_SHARD, SECOND_SHARD];
+function parse_shard(value) {
+  const shard = Number(value);
+  if (shard === FIRST_SHARD || shard === SECOND_SHARD) return shard;
+  throw new Error(
+    `josh lint: unknown shard "${value}" \u2014 use --shard=${String(FIRST_SHARD)} or --shard=${String(SECOND_SHARD)}`
+  );
+}
+function shard_of(arguments_) {
+  const flag = arguments_.find((argument) => argument.startsWith(SHARD_FLAG_PREFIX));
+  return flag === void 0 ? void 0 : parse_shard(flag.slice(SHARD_FLAG_PREFIX.length));
+}
+function shard_flag(shard) {
+  return `${SHARD_FLAG_PREFIX}${String(shard)}`;
+}
+function second_shard_targets() {
+  return [
+    WHOLE_TREE,
+    ...FIRST_SHARD_DIRECTORIES.flatMap((directory) => [IGNORE_PATTERN_FLAG, `${directory}/`])
+  ];
+}
+function eslint_targets(shard) {
+  if (shard === void 0) return [WHOLE_TREE];
+  return shard === FIRST_SHARD ? FIRST_SHARD_DIRECTORIES : second_shard_targets();
+}
+function checks_formatting(shard) {
+  return shard !== SECOND_SHARD;
+}
+function describe(shard) {
+  if (shard === void 0) return "";
+  return ` \xB7 shard ${String(shard)} of ${String(SECOND_SHARD)}`;
+}
+var lint_shard = {
+  FIRST_SHARD_DIRECTORIES,
+  FORMATTING_SHARD_REASON,
+  SHARDS,
+  WHOLE_TREE,
+  checks_formatting,
+  describe,
+  eslint_targets,
+  shard_flag,
+  shard_of
+};
+
+// scripts/lint/format-steps.ts
+async function in_order(steps, execute) {
+  const results = [];
+  for (const step of steps) {
+    results.push(await execute(step));
+  }
+  return results;
+}
+async function run_step(step, directory) {
+  const environment3 = step.check === "eslint" ? { env: eslint_heap.environment(), extendEnv: false } : {};
+  const launch = direct_launch(directory, step.args);
+  const result = await execa(launch.file, [...launch.args], {
+    cwd: directory,
+    stdio: "inherit",
+    reject: false,
+    ...environment3
+  });
+  return result.exitCode ?? 1;
+}
+async function run_unless_skipped(step, directory) {
+  const reason = step.check === "eslint" ? project_checks.eslint_skip_reason(directory) : project_checks.prettier_skip_reason(directory);
+  if (reason === void 0) return await run_step(step, directory);
+  console.info(project_checks.skip_notice(step.check, reason));
+  return 0;
+}
+async function run2(steps, cache_file, directory) {
+  const results = await in_order(steps, async (step) => {
+    if (step.check !== "eslint") return await run_unless_skipped(step, directory);
+    return await eslint_cache_dependencies.guard(
+      cache_file,
+      async () => await run_unless_skipped(step, directory),
+      directory
+    );
+  });
+  return results.find((code) => code !== 0) ?? 0;
+}
+async function run_scoped(scope, directory) {
+  const files = scope.mode === "all" ? [lint_shard.WHOLE_TREE] : scope.files;
+  const eslint = [...lint_related_scope.eslint_arguments(files), "--fix"];
+  const prettier = lint_related_scope.prettier_arguments(files, void 0, directory);
+  const steps = [{ check: "eslint", args: eslint }];
+  if (scope.mode === "all" || !prettier.includes(project_checks.WEB_FILES)) {
+    steps.push({
+      check: "prettier",
+      args: prettier.map((argument) => argument === "--check" ? "--write" : argument)
+    });
+  }
+  return await run2(steps, lint_related_scope.RELATED_CACHES.eslint_file, directory);
+}
+var format_steps = { in_order, run: run2, run_scoped };
+
+// scripts/hooks/edited-cspell.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path8 from "node:path";
+var CSPELL_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".json",
+  ".jsonc",
+  ".yml",
+  ".yaml",
+  ".html",
+  ".css"
+]);
+var CSPELL_ARGS = [
+  "lint",
+  "--words-only",
+  "--unique",
+  "--no-progress",
+  "--no-summary"
+];
+var CSPELL_BIN = "cspell";
+var STDIN_SCHEME = "stdin://";
+var HEADER = "The edit hook found words cspell does not know; fix them or add them to `cspell.config.yaml` now rather than at the gate:";
+var MAX_DIAGNOSTIC_CHARS = 4e3;
+var TRUNCATION_NOTICE = "\n\u2026(unknown words truncated)";
+function is_checkable(file_path, project_root) {
+  if (!existsSync3(file_path) || !CSPELL_EXTENSIONS.has(path8.extname(file_path).toLowerCase())) {
+    return false;
+  }
+  const relative = path8.relative(path8.resolve(project_root), path8.resolve(file_path));
+  return relative !== "" && !relative.startsWith("..") && !path8.isAbsolute(relative);
+}
+function cspell_command(project_root) {
+  return direct_launch(project_root, ["exec", CSPELL_BIN]);
+}
+async function run_cspell(request) {
+  const launch = cspell_command(request.project_root);
+  const target = `${STDIN_SCHEME}${path8.resolve(request.file_path)}`;
+  const result = await execa(launch.file, [...launch.args, ...CSPELL_ARGS, target], {
+    reject: false,
+    cwd: request.project_root,
+    input: request.text,
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: HOOK_PROCESS_TIMEOUT_MS
+  });
+  return result.stdout;
+}
+function format_unknown_words(stdout) {
+  const words = stdout.split("\n").map((word) => word.trim()).filter((word) => word.length > 0);
+  if (words.length === 0) return void 0;
+  const joined = words.join("\n");
+  const body = joined.length > MAX_DIAGNOSTIC_CHARS ? `${joined.slice(0, MAX_DIAGNOSTIC_CHARS)}${TRUNCATION_NOTICE}` : joined;
+  return `${HEADER}
+${body}`;
+}
+async function spelling_diagnostics(file_path, project_root, text, runner = run_cspell) {
+  if (file_path === void 0 || !is_checkable(file_path, project_root)) return void 0;
+  try {
+    return format_unknown_words(await runner({ file_path, project_root, text }));
+  } catch {
+    return void 0;
+  }
+}
+var edited_cspell = { cspell_command, format_unknown_words, run_cspell, spelling_diagnostics };
+
+// scripts/hooks/format-rewrite-notice.ts
+var MAX_REWRITE_CHARS = 600;
+var REWRITE_TRUNCATION_NOTICE = "\n\u2026(truncated)";
+var REWRITE_HEADER = "The format hook rewrote this file, so your copy is stale; re-read these lines before the next Edit.";
+var REWRITE_RANGE_PREFIX = "Lines ";
+var LINE_SEPARATOR4 = "\n";
+var FIRST_LINE = 1;
+function common_prefix_length(before, after) {
+  const limit = Math.min(before.length, after.length);
+  let index = 0;
+  while (index < limit && before[index] === after[index]) index += 1;
+  return index;
+}
+function common_suffix_length(before, after, prefix) {
+  const limit = Math.min(before.length, after.length) - prefix;
+  let index = 0;
+  while (index < limit && before.at(-1 - index) === after.at(-1 - index)) index += 1;
+  return index;
+}
+function changed_range(before, after) {
+  const before_lines = before.split(LINE_SEPARATOR4);
+  const after_lines = after.split(LINE_SEPARATOR4);
+  const prefix = common_prefix_length(before_lines, after_lines);
+  const last = after_lines.length - common_suffix_length(before_lines, after_lines, prefix);
+  return {
+    start_line: prefix + FIRST_LINE,
+    end_line: Math.max(prefix + FIRST_LINE, last),
+    body: after_lines.slice(prefix, last).join(LINE_SEPARATOR4)
+  };
+}
+function cap_body(body, budget) {
+  if (body.length <= budget) return body;
+  return `${body.slice(0, Math.max(0, budget - REWRITE_TRUNCATION_NOTICE.length))}${REWRITE_TRUNCATION_NOTICE}`;
+}
+function build(before, after) {
+  if (before === after) return void 0;
+  const range = changed_range(before, after);
+  const head = `${REWRITE_HEADER}
+${REWRITE_RANGE_PREFIX}${String(range.start_line)}-${String(range.end_line)}:
+`;
+  return `${head}${cap_body(range.body, MAX_REWRITE_CHARS - head.length)}`;
+}
+function read_text3(file_path) {
+  return file_path === void 0 ? "" : file_reader.read_if_readable(file_path) ?? "";
+}
+var rewrite_notice = { build, read_text: read_text3 };
+
+// scripts/hooks/format-edited-file.ts
+var hook_payload_schema = external_exports.object({
+  tool_input: external_exports.object({ file_path: external_exports.string().min(1) }).optional()
+});
+var PRETTIER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".json",
+  ".jsonc",
+  ".md",
+  ".yml",
+  ".yaml",
+  ".css",
+  ".html"
+]);
+var ESLINT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".svelte"]);
+var EXCLUDED_ANYWHERE = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+var EXCLUDED_AT_ROOT = /* @__PURE__ */ new Set(["dist", "build"]);
+var PARENT_SEGMENT = "..";
+var PRETTIER_BIN = "prettier";
+var PRETTIER_ARGUMENTS = ["--write", "--ignore-unknown"];
+var ESLINT_BIN2 = "eslint";
+var ESLINT_ARGUMENTS = [
+  "--fix",
+  "--no-error-on-unmatched-pattern",
+  ...ESLINT_EDIT_CACHE_FLAGS
+];
+var { ESLINT_DAEMON: ESLINT_DAEMON2 } = eslint_daemon;
+var DAEMON_RESTART = "restart";
+var DIAGNOSTIC_HEADER = "The edit hook could not auto-fix these lint problems; address them now rather than at the gate:";
+var MAX_DIAGNOSTIC_CHARS2 = 4e3;
+var DIAGNOSTIC_TRUNCATION_NOTICE = "\n\u2026(diagnostics truncated)";
+var SECTION_SEPARATOR = "\n\n";
+function parse_edited_path(raw_payload) {
+  return json_value.parse_with(raw_payload, hook_payload_schema)?.tool_input?.file_path;
+}
+function is_excluded(relative_path) {
+  const segments = relative_path.split(path9.sep);
+  return segments.some((segment) => EXCLUDED_ANYWHERE.has(segment)) || EXCLUDED_AT_ROOT.has(segments[0] ?? "");
+}
+function relative_to_root(project_root, file_path) {
+  const relative = path9.relative(path9.resolve(project_root), path9.resolve(file_path));
+  const is_inside_root = relative !== "" && relative.split(path9.sep)[0] !== PARENT_SEGMENT && !path9.isAbsolute(relative);
+  return is_inside_root ? relative : void 0;
+}
+function is_formattable(file_path, project_root) {
+  const relative = relative_to_root(project_root, file_path);
+  return relative !== void 0 && !is_excluded(relative) && existsSync4(file_path);
+}
+function plan_commands(file_path, project_root) {
+  if (!is_formattable(file_path, project_root)) return [];
+  const extension = path9.extname(file_path).toLowerCase();
+  const commands = [];
+  if (ESLINT_EXTENSIONS.has(extension)) {
+    commands.push({ bin: ESLINT_BIN2, command_arguments: [...ESLINT_ARGUMENTS, file_path] });
+  }
+  if (PRETTIER_EXTENSIONS.has(extension)) {
+    commands.push({ bin: PRETTIER_BIN, command_arguments: [...PRETTIER_ARGUMENTS, file_path] });
+  }
+  return commands;
+}
+function select_invocation(command, routes) {
+  if (routes.daemon_cli !== void 0) {
+    return {
+      bin: process.execPath,
+      command_arguments: [routes.daemon_cli, ...command.command_arguments]
+    };
+  }
+  return { bin: routes.launch.file, command_arguments: routes.launch.args };
+}
+var DAEMON_BINS = /* @__PURE__ */ new Set([ESLINT_BIN2, ESLINT_DAEMON2]);
+function resolve_daemon_cli2(bin, project_root) {
+  if (!DAEMON_BINS.has(bin)) return void 0;
+  return eslint_daemon.resolve_daemon_cli(project_root);
+}
+function plan_daemon_restart(file_path, project_root) {
+  const relative = relative_to_root(project_root, file_path);
+  if (relative === void 0 || !eslint_daemon.is_config_input(relative) || resolve_daemon_cli2(ESLINT_DAEMON2, project_root) === void 0) {
+    return [];
+  }
+  return [{ bin: ESLINT_DAEMON2, command_arguments: [DAEMON_RESTART] }];
+}
+function resolve_invocations(command, project_root) {
+  const routes = {
+    daemon_cli: resolve_daemon_cli2(command.bin, project_root),
+    launch: direct_launch(project_root, ["exec", command.bin, ...command.command_arguments])
+  };
+  const without_daemon = select_invocation(command, { ...routes, daemon_cli: void 0 });
+  if (routes.daemon_cli === void 0) return [without_daemon];
+  return [select_invocation(command, routes), without_daemon];
+}
+function is_start_failure2(outcome) {
+  return outcome.exit_code !== 0 && outcome.stdout.length === 0;
+}
+async function spawn_invocation(invocation, project_root) {
+  const result = await execa(invocation.bin, [...invocation.command_arguments], {
+    reject: false,
+    cwd: project_root,
+    env: eslint_daemon.launch_environment(),
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: HOOK_PROCESS_TIMEOUT_MS
+  });
+  return { exit_code: result.exitCode ?? 1, stdout: result.stdout };
+}
+async function run_command(command, project_root) {
+  let outcome = { exit_code: 0, stdout: "" };
+  for (const invocation of resolve_invocations(command, project_root)) {
+    outcome = await spawn_invocation(invocation, project_root);
+    if (!is_start_failure2(outcome)) return outcome;
+  }
+  return outcome;
+}
+function eslint_unfixed(command, outcome) {
+  if (command.bin !== ESLINT_BIN2 || outcome.exit_code === 0 || outcome.stdout.length === 0) {
+    return void 0;
+  }
+  return outcome.stdout;
+}
+function format_diagnostics(unfixed) {
+  if (unfixed === void 0) return void 0;
+  const is_over = unfixed.length > MAX_DIAGNOSTIC_CHARS2;
+  const body = is_over ? `${unfixed.slice(0, MAX_DIAGNOSTIC_CHARS2)}${DIAGNOSTIC_TRUNCATION_NOTICE}` : unfixed;
+  return `${DIAGNOSTIC_HEADER}
+${body}`;
+}
+async function collect_unfixed(plan, runner, project_root) {
+  const results = await format_steps.in_order(plan, async (command) => {
+    try {
+      return eslint_unfixed(command, await runner(command, project_root));
+    } catch {
+      return "";
+    }
+  });
+  return results.findLast(Boolean) ?? "";
+}
+function linted_path(plan, file_path, project_root) {
+  if (plan.every((command) => command.bin !== ESLINT_BIN2)) return void 0;
+  return relative_to_root(project_root, file_path);
+}
+async function record_lint(project_root) {
+  const call = { caller: eslint_daemon_calls.DAEMON_CALLER.EDIT_HOOK, files: 1 };
+  eslint_daemon.record_call(project_root, call);
+  await eslint_trim.trim(project_root);
+}
+async function format_edited_file(raw_payload, runner, project_root) {
+  const file_path = parse_edited_path(raw_payload);
+  if (file_path === void 0) return void 0;
+  const plan = [
+    ...plan_commands(file_path, project_root),
+    ...plan_daemon_restart(file_path, project_root)
+  ];
+  const daemon_before = eslint_daemon.read_record(project_root);
+  const unfixed = await collect_unfixed(plan, runner, project_root);
+  const linted = linted_path(plan, file_path, project_root);
+  eslint_daemon.remember_after_edit(project_root, daemon_before, linted);
+  if (linted !== void 0) await record_lint(project_root);
+  return format_diagnostics(unfixed === "" ? void 0 : unfixed);
+}
+async function format_edited_payload(raw_payload, project_root) {
+  return await format_edited_file(raw_payload, run_command, project_root);
+}
+var HOOK_EVENT_NAME = "PostToolUse";
+function build_envelope(additional_context) {
+  return JSON.stringify({
+    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: additional_context }
+  });
+}
+function compose_context(notice, diagnostics) {
+  const sections = [notice, diagnostics].filter(
+    (section) => section !== void 0
+  );
+  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
+}
+function report_no_payload() {
+  process.stderr.write(
+    "format:edited reads a Claude Code PostToolUse payload on stdin; it is not run by hand.\n"
+  );
+}
+async function run_hook(payload) {
+  const notice = time_density_hook.density_notice(payload);
+  const file_path = parse_edited_path(payload);
+  const before = rewrite_notice.read_text(file_path);
+  const pending_spelling = edited_cspell.spelling_diagnostics(file_path, process.cwd(), before);
+  const lint = await format_edited_payload(payload, process.cwd());
+  const rewrite = rewrite_notice.build(before, rewrite_notice.read_text(file_path));
+  const spelling = await pending_spelling;
+  const parts = compose_context(rewrite, compose_context(lint, spelling));
+  const context = compose_context(notice, parts);
+  if (context !== void 0) process.stdout.write(`${build_envelope(context)}
+`);
+}
+
+export {
+  time_density_hook,
+  format_edited_payload,
+  build_envelope,
+  compose_context,
+  report_no_payload,
+  run_hook
+};