@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/hooks/chunk-5R5YFQR5.js

@@ -1,931 +0,0 @@
-import {
-  resolve_tsx_runner,
-  run_board_usage_rusage,
-  toolchain_inputs
-} from "./chunk-IURJANNZ.js";
-import {
-  core_weights,
-  direct_launch,
-  pnpm_reach,
-  resolve_package_bin
-} from "./chunk-AO4TOV4V.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-G5WSPYJ6.js";
-import {
-  file_reader
-} from "./chunk-FOW4B7OQ.js";
-import {
-  HOOK_PROCESS_TIMEOUT_MS,
-  LINT_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS,
-  atomic_write,
-  execa,
-  external_exports,
-  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 existsSync3 } from "node:fs";
-import path6 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(record2, current) {
-  if (record2.daemon === void 0) return false;
-  return record2.recorded !== record_text(record2.daemon, current);
-}
-function state_of(record2, current) {
-  if (record2.daemon === void 0) return DAEMON_STATE.STARTED;
-  return is_stale(record2, 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, record2, relative) {
-  const { daemon, recorded } = record2;
-  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/hooks/edited-cspell.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path5 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 (!existsSync2(file_path) || !CSPELL_EXTENSIONS.has(path5.extname(file_path).toLowerCase())) {
-    return false;
-  }
-  const relative = path5.relative(path5.resolve(project_root), path5.resolve(file_path));
-  return relative !== "" && !relative.startsWith("..") && !path5.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}${path5.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(path6.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 = path6.relative(path6.resolve(project_root), path6.resolve(file_path));
-  const is_inside_root = relative !== "" && relative.split(path6.sep)[0] !== PARENT_SEGMENT && !path6.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) && existsSync3(file_path);
-}
-function plan_commands(file_path, project_root) {
-  if (!is_formattable(file_path, project_root)) return [];
-  const extension = path6.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) {
-  let unfixed = "";
-  for (const command of plan) {
-    try {
-      unfixed = eslint_unfixed(command, await runner(command, project_root)) ?? unfixed;
-    } catch {
-      continue;
-    }
-  }
-  return unfixed;
-}
-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
-};