@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/dist/hooks/{chunk-O6GDRNJB.js → chunk-XGBNSWEI.js}

@@ -1,30 +1,236 @@
 import {
-  resolve_local_bin,
-  resolve_package_bin
-} from "./chunk-EFXE6C37.js";
+  toolchain_inputs
+} from "./chunk-TUIFS5E7.js";
 import {
   ESLINT_EDIT_CACHE_FLAGS,
+  resolve_local_bin,
+  resolve_package_bin,
   time_density_hook
-} from "./chunk-TNUMY6NL.js";
+} from "./chunk-PT5R6UJD.js";
 import {
   file_reader,
+  git_spawn_sync,
   json_value
-} from "./chunk-APUO6U4J.js";
+} from "./chunk-WR2KQAYZ.js";
 import {
-  HOOK_PROCESS_TIMEOUT_MS
-} from "./chunk-DGT54IH5.js";
+  HOOK_PROCESS_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS,
+  atomic_write
+} from "./chunk-AZX4FGQ3.js";
 
 // scripts/hooks/format-edited-file.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import path3 from "node:path";
+
+// scripts/lint/eslint-daemon.ts
+import { lstatSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
+
+// scripts/lib/buffered-process.ts
+import { existsSync } from "node:fs";
+import { execa } from "execa";
+
+// scripts/lib/pnpm-reach.ts
+var PNPM = "pnpm";
+var NOT_FOUND_CODE = "ENOENT";
+var PREREQUISITES_URL = "https://github.com/joshuafolkken/kit/blob/main/docs/setup/prerequisites.md#2-install-pnpm-and-nodejs";
+var NOT_ON_PATH_NOTICE = [
+  "pnpm was not found on the PATH this process sees, so the command could not start.",
+  "A shell opened by an editor, an agent or a service can have a different PATH from your terminal.",
+  `Install pnpm or add its directory to that PATH: ${PREREQUISITES_URL}`
+].join("\n");
+function is_not_found(result) {
+  return result.code === NOT_FOUND_CODE;
+}
+var pnpm_reach = { PNPM, NOT_ON_PATH_NOTICE, is_not_found };
+
+// scripts/lib/buffered-process.ts
+var { PNPM: PNPM2 } = 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 environment = { ...process.env };
+  if (environment["NO_COLOR"] === void 0) environment["FORCE_COLOR"] = FORCE_COLOR;
+  else delete environment["FORCE_COLOR"];
+  return environment;
+}
+async function run_buffered_process(command_args, options = {}) {
+  const started_at = performance.now();
+  const result = await execa(PNPM2, [...command_args], {
+    env: 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
+  };
+}
+function is_process_failed(result) {
+  return result.exit_code !== 0;
+}
+var buffered_process = { child_environment, is_process_failed, run_buffered_process };
+
+// scripts/lint/eslint-daemon.ts
 import { execa as execa2 } from "execa";
+var ESLINT_DAEMON = "eslint_d";
+var DAEMON_STOP = "stop";
+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 MODULE_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
+function is_borrowed_install(project_root) {
+  return lstatSync(path.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_DIRECTORY, 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 fingerprint(project_root) {
+  const head = git_spawn_sync.read(["rev-parse", "HEAD"], { cwd: project_root }) ?? NO_HEAD;
+  return `${toolchain_inputs.digest(project_root)}:${head}`;
+}
+function eslint_directory(project_root) {
+  try {
+    return path.dirname(
+      createRequire(path.join(project_root, "package.json")).resolve("eslint/package.json")
+    );
+  } catch {
+    return void 0;
+  }
+}
+function read_text(file) {
+  try {
+    return readFileSync(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_text(path.join(directory, DAEMON_RECORD)),
+    recorded: read_text(path.join(directory, FINGERPRINT_RECORD))
+  };
+}
+function record_text(daemon, current) {
+  return `${daemon}${RECORD_SEPARATOR}${current}`;
+}
+function is_stale(record, current) {
+  if (record.daemon === void 0) return false;
+  return record.recorded !== record_text(record.daemon, current);
+}
+function remember(project_root, current) {
+  const directory = eslint_directory(project_root);
+  if (directory === void 0) return;
+  const daemon = read_text(path.join(directory, DAEMON_RECORD));
+  if (daemon === void 0) return;
+  try {
+    atomic_write.replace_file(
+      path.join(directory, FINGERPRINT_RECORD),
+      record_text(daemon, current)
+    );
+  } catch {
+  }
+}
+function remember_started(project_root, before) {
+  if (read_record(project_root).daemon === before.daemon) return;
+  remember(project_root, fingerprint(project_root));
+}
+async function spawn_daemon(cli, cli_arguments, options) {
+  const result = await execa2(process.execPath, [cli, ...cli_arguments], {
+    reject: false,
+    all: true,
+    cwd: options.project_root,
+    env: { ...buffered_process.child_environment(), ESLINT_D_MISS: "fail" },
+    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);
+  if (is_stale(read_record(project_root), current)) 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);
+  return outcome;
+}
+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) {
+  const started_at = performance.now();
+  const outcome = await run(pnpm_arguments, { project_root: process.cwd() });
+  if (outcome === void 0) return await buffered_process.run_buffered_process(pnpm_arguments);
+  return {
+    output: outcome.output,
+    exit_code: outcome.exit_code,
+    elapsed_ms: performance.now() - started_at
+  };
+}
+var eslint_daemon = {
+  eslint_arguments_of,
+  fingerprint,
+  is_config_input,
+  is_stale,
+  read_record,
+  record_text,
+  remember_started,
+  resolve_daemon_cli,
+  run,
+  run_or_cold,
+  ESLINT_DAEMON
+};
+
+// scripts/hooks/format-edited-file.ts
+import { execa as execa4 } from "execa";
 import { z } from "zod";
 
 // scripts/hooks/edited-cspell.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { execa } from "execa";
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+import { execa as execa3 } from "execa";
 var CSPELL_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -52,19 +258,19 @@ var CSPELL_ARGS = [
   "--no-progress",
   "--no-summary"
 ];
-var PNPM = "pnpm";
+var PNPM3 = "pnpm";
 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 (!existsSync(file_path) || !CSPELL_EXTENSIONS.has(path.extname(file_path).toLowerCase())) {
+  if (!existsSync2(file_path) || !CSPELL_EXTENSIONS.has(path2.extname(file_path).toLowerCase())) {
     return false;
   }
-  const relative = path.relative(path.resolve(project_root), path.resolve(file_path));
-  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+  const relative = path2.relative(path2.resolve(project_root), path2.resolve(file_path));
+  return relative !== "" && !relative.startsWith("..") && !path2.isAbsolute(relative);
 }
 async function run_cspell(file_path, project_root) {
-  const result = await execa(PNPM, [...CSPELL_ARGS, file_path], {
+  const result = await execa3(PNPM3, [...CSPELL_ARGS, file_path], {
     reject: false,
     cwd: project_root,
     stdout: "pipe",
@@ -133,10 +339,10 @@ ${REWRITE_RANGE_PREFIX}${String(range.start_line)}-${String(range.end_line)}:
 `;
   return `${head}${cap_body(range.body, MAX_REWRITE_CHARS - head.length)}`;
 }
-function read_text(file_path) {
+function read_text2(file_path) {
   return file_path === void 0 ? "" : file_reader.read_if_readable(file_path) ?? "";
 }
-var rewrite_notice = { build, read_text };
+var rewrite_notice = { build, read_text: read_text2 };
 
 // scripts/hooks/format-edited-file.ts
 var hook_payload_schema = z.object({
@@ -162,46 +368,43 @@ var ESLINT_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", "
 var EXCLUDED_ANYWHERE = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 var EXCLUDED_AT_ROOT = /* @__PURE__ */ new Set(["dist", "build"]);
 var PARENT_SEGMENT = "..";
-var PNPM2 = "pnpm";
+var PNPM4 = "pnpm";
 var PRETTIER_BIN = "prettier";
 var PRETTIER_ARGUMENTS = ["--write", "--ignore-unknown"];
-var ESLINT_BIN = "eslint";
+var ESLINT_BIN2 = "eslint";
 var ESLINT_ARGUMENTS = [
   "--fix",
   "--no-error-on-unmatched-pattern",
   ...ESLINT_EDIT_CACHE_FLAGS
 ];
-var ESLINT_DAEMON = "eslint_d";
+var { ESLINT_DAEMON: ESLINT_DAEMON2 } = eslint_daemon;
 var DAEMON_RESTART = "restart";
-var ESLINT_CONFIG_DIR = "eslint";
-var ESLINT_CONFIG_ENTRY = /^eslint\.config\.[cm]?[jt]s$/u;
 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";
-var MODULE_DIRECTORY = path2.dirname(fileURLToPath(import.meta.url));
 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(path2.sep);
+  const segments = relative_path.split(path3.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 = path2.relative(path2.resolve(project_root), path2.resolve(file_path));
-  const is_inside_root = relative !== "" && relative.split(path2.sep)[0] !== PARENT_SEGMENT && !path2.isAbsolute(relative);
+  const relative = path3.relative(path3.resolve(project_root), path3.resolve(file_path));
+  const is_inside_root = relative !== "" && relative.split(path3.sep)[0] !== PARENT_SEGMENT && !path3.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) && existsSync2(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 = path2.extname(file_path).toLowerCase();
+  const extension = path3.extname(file_path).toLowerCase();
   const commands = [];
   if (ESLINT_EXTENSIONS.has(extension)) {
-    commands.push({ bin: ESLINT_BIN, command_arguments: [...ESLINT_ARGUMENTS, file_path] });
+    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] });
@@ -218,38 +421,35 @@ function select_invocation(command, routes) {
   if (routes.shim !== void 0) {
     return { bin: routes.shim, command_arguments: command.command_arguments };
   }
-  return { bin: PNPM2, command_arguments: ["exec", command.bin, ...command.command_arguments] };
+  return { bin: PNPM4, command_arguments: ["exec", command.bin, ...command.command_arguments] };
 }
-var DAEMON_BINS = /* @__PURE__ */ new Set([ESLINT_BIN, ESLINT_DAEMON]);
-function resolve_daemon_cli(bin, project_root) {
+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 resolve_package_bin(MODULE_DIRECTORY, ESLINT_DAEMON, ESLINT_DAEMON) ?? resolve_package_bin(project_root, ESLINT_DAEMON, ESLINT_DAEMON);
-}
-function is_eslint_config_input(relative_path) {
-  return relative_path.split(path2.sep)[0] === ESLINT_CONFIG_DIR || ESLINT_CONFIG_ENTRY.test(relative_path);
+  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 || !is_eslint_config_input(relative) || resolve_daemon_cli(ESLINT_DAEMON, project_root) === void 0) {
+  if (relative === void 0 || !eslint_daemon.is_config_input(relative) || resolve_daemon_cli2(ESLINT_DAEMON2, project_root) === void 0) {
     return [];
   }
-  return [{ bin: ESLINT_DAEMON, command_arguments: [DAEMON_RESTART] }];
+  return [{ bin: ESLINT_DAEMON2, command_arguments: [DAEMON_RESTART] }];
 }
 function resolve_invocations(command, project_root) {
   const shim = resolve_local_bin(project_root, command.bin);
   const routes = {
-    daemon_cli: resolve_daemon_cli(command.bin, project_root),
-    shim: existsSync2(shim) ? shim : void 0
+    daemon_cli: resolve_daemon_cli2(command.bin, project_root),
+    shim: existsSync3(shim) ? shim : void 0
   };
   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_failure(outcome) {
+function is_start_failure2(outcome) {
   return outcome.exit_code !== 0 && outcome.stdout.length === 0;
 }
 async function spawn_invocation(invocation, project_root) {
-  const result = await execa2(invocation.bin, [...invocation.command_arguments], {
+  const result = await execa4(invocation.bin, [...invocation.command_arguments], {
     reject: false,
     cwd: project_root,
     env: { ESLINT_D_MISS: "fail" },
@@ -263,12 +463,12 @@ 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_failure(outcome)) return outcome;
+    if (!is_start_failure2(outcome)) return outcome;
   }
   return outcome;
 }
 function eslint_unfixed(command, outcome) {
-  if (command.bin !== ESLINT_BIN || outcome.exit_code === 0 || outcome.stdout.length === 0) {
+  if (command.bin !== ESLINT_BIN2 || outcome.exit_code === 0 || outcome.stdout.length === 0) {
     return void 0;
   }
   return outcome.stdout;
@@ -298,7 +498,9 @@ async function format_edited_file(raw_payload, runner, project_root) {
     ...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);
+  eslint_daemon.remember_started(project_root, daemon_before);
   return format_diagnostics(unfixed === "" ? void 0 : unfixed);
 }
 async function format_edited_payload(raw_payload, project_root) {