@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-VL5I2IOD.js

@@ -0,0 +1,332 @@
+import {
+  hook_lap
+} from "./chunk-RWPCK3CO.js";
+import {
+  CATEGORY_ORDER,
+  COMMAND_MAP
+} from "./chunk-CCHJZEF5.js";
+import {
+  USAGE_ERROR_EXIT_CODE,
+  composite_arguments
+} from "./chunk-RSSJWMQS.js";
+import {
+  ALIASES
+} from "./chunk-ROJXMBXP.js";
+import {
+  core_budget
+} from "./chunk-ZCHZU6NX.js";
+import {
+  josh_environment_file
+} from "./chunk-NFKULY26.js";
+import {
+  repo_origin
+} from "./chunk-4ZHWTTQW.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+import {
+  resolve_local_bin,
+  resolve_package_bin
+} from "./chunk-SVV4U5AR.js";
+import {
+  package_version_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  resolve_spawn_exit
+} from "./chunk-KTLR4Y32.js";
+
+// scripts/josh/josh-logic.ts
+import { dirname as __josh_dirname2 } from "node:path";
+import { fileURLToPath as __josh_file_path2 } from "node:url";
+import { existsSync as existsSync2 } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import { execaSync } from "execa";
+
+// scripts/josh/command-suggest.ts
+var MAX_SUGGESTION_DISTANCE = 3;
+function at(values, index) {
+  return values[index] ?? 0;
+}
+function fill_distance_row(source, target, row, previous) {
+  const current = [row];
+  for (let col = 1; col <= target.length; col++) {
+    const cost = source[row - 1] === target[col - 1] ? 0 : 1;
+    const deletion = at(previous, col) + 1;
+    const insertion = at(current, col - 1) + 1;
+    const substitution = at(previous, col - 1) + cost;
+    current.push(Math.min(deletion, insertion, substitution));
+  }
+  return current;
+}
+function edit_distance(source, target) {
+  let previous = Array.from({ length: target.length + 1 }, (_unused, index) => index);
+  for (let row = 1; row <= source.length; row++) {
+    previous = fill_distance_row(source, target, row, previous);
+  }
+  return at(previous, target.length);
+}
+function closest_command(input, commands) {
+  const within = commands.map((command) => ({ command, distance: edit_distance(input, command) })).filter((scored) => scored.distance <= MAX_SUGGESTION_DISTANCE).toSorted((left, right) => left.distance - right.distance);
+  return within[0]?.command;
+}
+var command_suggest = { closest_command, edit_distance };
+
+// scripts/josh/josh-in-process.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/josh/josh-in-process.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var TYPESCRIPT_EXTENSION = ".ts";
+var JAVASCRIPT_EXTENSION = ".js";
+var BUNDLED_COMMAND_DIRECTORY = path.join("dist", "commands");
+var FAILURE_EXIT_CODE = 1;
+function is_typescript_dispatcher(dispatcher_url) {
+  return dispatcher_url.endsWith(TYPESCRIPT_EXTENSION);
+}
+function bundled_script_path(package_directory, script) {
+  const name = `${path.basename(script, TYPESCRIPT_EXTENSION)}${JAVASCRIPT_EXTENSION}`;
+  return path.join(package_directory, BUNDLED_COMMAND_DIRECTORY, name);
+}
+function in_process_target(script, package_directory, dispatcher_url) {
+  const script_path = path.join(package_directory, script);
+  const module_path = is_typescript_dispatcher(dispatcher_url) ? script_path : bundled_script_path(package_directory, script);
+  return { module_path, script_path };
+}
+function read_exit_code() {
+  const code = process.exitCode;
+  return typeof code === "number" ? code : 0;
+}
+function resolve_real_path(script_path) {
+  try {
+    return realpathSync(script_path);
+  } catch {
+    return script_path;
+  }
+}
+async function run_in_process(target, script_arguments) {
+  process.argv = [process.execPath, resolve_real_path(target.script_path), ...script_arguments];
+  try {
+    await import(pathToFileURL(resolve_real_path(target.module_path)).href);
+  } catch (error) {
+    console.error(error);
+    return FAILURE_EXIT_CODE;
+  }
+  return read_exit_code();
+}
+var josh_in_process = { bundled_script_path, in_process_target, run_in_process };
+
+// scripts/josh/kit-only.ts
+function kit_only_notice(cmd) {
+  return `\`josh ${cmd}\` is a kit-only command \u2014 run it from the kit repository (joshuafolkken/kit), not from a consumer project.`;
+}
+function is_kit_only(entry) {
+  return entry.is_kit_only === true;
+}
+function kit_only_command_names() {
+  return Object.entries(COMMAND_MAP).filter(([, entry]) => is_kit_only(entry)).map(([name]) => name);
+}
+var kit_only = {
+  is_kit_only,
+  command_names: kit_only_command_names,
+  notice: kit_only_notice
+};
+
+// scripts/josh/run-github-prerequisite.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+var GITHUB_RUN_COMMANDS = /* @__PURE__ */ new Set([
+  "run:entry",
+  "run:prep",
+  "run:next",
+  "run:step",
+  "run:merge",
+  "run:tail"
+]);
+function explanation(root, command) {
+  if (!GITHUB_RUN_COMMANDS.has(command)) return void 0;
+  if (!existsSync(path2.join(root, ".git"))) {
+    return `${command} requires Git and a GitHub origin. Run git init and add a GitHub origin first.`;
+  }
+  const url = git_spawn_sync.origin_url(root);
+  if (url !== void 0 && repo_origin.parse_origin_url(url)) return void 0;
+  return `${command} requires a GitHub origin. Add an origin pointing to GitHub first.`;
+}
+var run_github_prerequisite = { explanation };
+
+// scripts/josh/josh-logic.ts
+var __josh_meta2 = import.meta;
+var __josh_source_url2 = new URL("../../scripts/josh/josh-logic.ts", __josh_meta2.url).href;
+var __josh_source_filename2 = __josh_file_path2(__josh_source_url2);
+var __josh_source_dirname2 = __josh_dirname2(__josh_source_filename2);
+var COLUMN_WIDTH = 26;
+var ALIAS_PAD_WIDTH = 2;
+var TSX_BIN = "tsx";
+var TSX_PACKAGE = "tsx";
+var UNKNOWN_COMMAND_EXIT_CODE = -1;
+var PACKAGE_DIR = find_package_directory(path3.dirname(fileURLToPath(__josh_source_url2)));
+function resolve_tsx_executable() {
+  const candidates = [
+    resolve_local_bin(PACKAGE_DIR, TSX_BIN),
+    resolve_local_bin(process.cwd(), TSX_BIN)
+  ];
+  return candidates.find(existsSync2) ?? TSX_BIN;
+}
+function resolve_tsx_cli_entry() {
+  for (const base_directory of [PACKAGE_DIR, process.cwd()]) {
+    const cli_entry = resolve_package_bin(base_directory, TSX_PACKAGE, TSX_BIN);
+    if (cli_entry !== void 0) return cli_entry;
+  }
+  return void 0;
+}
+function resolve_tsx_runner() {
+  const cli_entry = resolve_tsx_cli_entry();
+  if (cli_entry !== void 0) {
+    return { executable: process.execPath, leading_arguments: [cli_entry] };
+  }
+  return { executable: resolve_tsx_executable(), leading_arguments: [] };
+}
+function read_package_version() {
+  return package_manifest.read_manifest(PACKAGE_DIR, package_version_schema).version;
+}
+var HEADER = `josh v${read_package_version()} \u2014 Joshua Folkken's dev toolkit`;
+var USAGE = "Usage: josh <command> [options]";
+var ALL_HINT = "Run 'josh --all' to list every available command.";
+function build_alias_lookup() {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const [alias, cmd] of Object.entries(ALIASES)) lookup.set(cmd, alias);
+  return lookup;
+}
+function resolve_alias(cmd) {
+  return Object.hasOwn(ALIASES, cmd) ? ALIASES[cmd] ?? cmd : cmd;
+}
+function format_command_line(cmd, entry, alias) {
+  const prefix = alias ? `${alias}, `.padEnd(ALIAS_PAD_WIDTH + ALIAS_PAD_WIDTH) : "";
+  return `  ${(prefix + cmd).padEnd(COLUMN_WIDTH)}${entry.description}`;
+}
+function format_category_section(category, entries, alias_lookup) {
+  const lines = entries.map(
+    ([cmd, entry]) => format_command_line(cmd, entry, alias_lookup.get(cmd))
+  );
+  return [`${category}:`, ...lines].join("\n");
+}
+function is_visible_command(entry, is_all, is_consumer) {
+  if (is_consumer && kit_only.is_kit_only(entry)) return false;
+  return is_all || entry.reference[1] === "developer";
+}
+function collect_visible(is_all, is_consumer) {
+  const by_category = new Map(
+    CATEGORY_ORDER.map((cat) => [cat, []])
+  );
+  for (const [cmd, entry] of Object.entries(COMMAND_MAP)) {
+    if (is_visible_command(entry, is_all, is_consumer)) {
+      by_category.get(entry.category)?.push([cmd, entry]);
+    }
+  }
+  return by_category;
+}
+function format_help(is_all = false, is_consumer = false) {
+  const by_category = collect_visible(is_all, is_consumer);
+  const alias_lookup = build_alias_lookup();
+  const sections = CATEGORY_ORDER.map((cat) => [cat, by_category.get(cat) ?? []]).filter(([, entries]) => entries.length > 0).map(([cat, entries]) => format_category_section(cat, entries, alias_lookup));
+  const footer = is_all ? USAGE : `${USAGE}
+${ALL_HINT}`;
+  return [HEADER, "", sections.join("\n\n"), "", footer].join("\n");
+}
+function all_command_names() {
+  return [...Object.keys(COMMAND_MAP), ...Object.keys(ALIASES)];
+}
+function format_unknown_command(cmd) {
+  const suggestion = command_suggest.closest_command(cmd, all_command_names());
+  const hint = suggestion === void 0 ? "" : ` Did you mean '${suggestion}'?`;
+  return `Unknown command: ${cmd}.${hint} Run 'josh --help' for common commands or 'josh --all' for the full list.`;
+}
+function run_shell_command(shell, extra) {
+  const [executable = "", ...rest_arguments] = shell;
+  const result = execaSync(executable, [...rest_arguments, ...extra], {
+    stdio: "inherit",
+    reject: false
+  });
+  return resolve_spawn_exit(executable, result);
+}
+async function run_script_entry(entry, script, subcommand_arguments) {
+  const script_arguments = [...entry.default_script_arguments ?? [], ...subcommand_arguments];
+  const target = josh_in_process.in_process_target(script, PACKAGE_DIR, __josh_source_url2);
+  josh_environment_file.apply_node_flags(entry.tsx_arguments ?? []);
+  return await josh_in_process.run_in_process(target, script_arguments);
+}
+function github_prerequisite_exit(resolved, is_consumer) {
+  if (!is_consumer) return void 0;
+  const prerequisite = run_github_prerequisite.explanation(process.cwd(), resolved);
+  if (prerequisite === void 0) return void 0;
+  console.error(prerequisite);
+  return USAGE_ERROR_EXIT_CODE;
+}
+function pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer) {
+  if (is_consumer && kit_only.is_kit_only(entry)) {
+    console.error(kit_only.notice(resolved));
+    return USAGE_ERROR_EXIT_CODE;
+  }
+  const prerequisite_exit = github_prerequisite_exit(resolved, is_consumer);
+  if (prerequisite_exit !== void 0) return prerequisite_exit;
+  const rejection = composite_arguments.reject_extra_arguments(
+    resolved,
+    entry,
+    subcommand_arguments
+  );
+  if (rejection === void 0) return void 0;
+  console.error(rejection);
+  return USAGE_ERROR_EXIT_CODE;
+}
+async function run_entry(entry, subcommand_arguments) {
+  if (entry.shell) return run_shell_command(entry.shell, subcommand_arguments);
+  return await run_script_entry(entry, entry.script ?? "", subcommand_arguments);
+}
+function declared(value) {
+  return typeof value === "function" ? value() : value;
+}
+async function dispatch_entry(command, entry, subcommand_arguments) {
+  const weight = declared(entry.core_weight);
+  if (weight === void 0) return await run_entry(entry, subcommand_arguments);
+  return await core_budget.with_command_reservation(
+    weight,
+    async () => await run_entry(entry, subcommand_arguments),
+    { memory_mb: declared(entry.memory_mb), command, is_unit: entry.is_unit_claim }
+  );
+}
+async function run_command(cmd, subcommand_arguments, is_consumer = false) {
+  const resolved = resolve_alias(cmd);
+  const entry = Object.hasOwn(COMMAND_MAP, resolved) ? COMMAND_MAP[resolved] : void 0;
+  if (!entry) return UNKNOWN_COMMAND_EXIT_CODE;
+  const early_exit = pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer);
+  if (early_exit !== void 0) return early_exit;
+  return await hook_lap.timed_command(
+    resolved,
+    entry.category,
+    subcommand_arguments,
+    async () => await dispatch_entry(resolved, entry, subcommand_arguments)
+  );
+}
+var josh_logic = {
+  all_command_names,
+  format_help,
+  format_unknown_command,
+  run_command,
+  run_shell_command
+};
+
+export {
+  resolve_tsx_runner,
+  josh_logic
+};

package/dist/commands/chunk-VLN6TSPJ.js

@@ -0,0 +1,139 @@
+import {
+  PACKAGE_DIR
+} from "./chunk-3CCGKX7Y.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+
+// scripts/josh/stamp-file.ts
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// scripts/josh/platform-temporary.ts
+import { accessSync, constants } from "node:fs";
+import { tmpdir } from "node:os";
+var POSIX_TEMP_ROOT = "/tmp";
+var WINDOWS_PLATFORM = "win32";
+function is_writable_directory(directory) {
+  try {
+    accessSync(directory, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolve_temporary_root(platform, can_write = is_writable_directory) {
+  if (platform === WINDOWS_PLATFORM) return tmpdir();
+  return can_write(POSIX_TEMP_ROOT) ? POSIX_TEMP_ROOT : tmpdir();
+}
+var TEMP_ROOT_KEY = "JOSH_TEMP_ROOT";
+function temporary_root(override, platform) {
+  return override === void 0 || override === "" ? resolve_temporary_root(platform) : override;
+}
+var PLATFORM_TEMP_ROOT = temporary_root(process.env[TEMP_ROOT_KEY], process.platform);
+var platform_temporary = {
+  TEMP_ROOT_KEY,
+  resolve_temporary_root,
+  is_writable_directory,
+  temporary_root
+};
+
+// scripts/josh/stamp-file.ts
+var HASH_ALGORITHM = "sha256";
+var STAMP_SUFFIX = ".json";
+var STAMP_KEY_LENGTH = 16;
+var STAMP_FILE_MODE = 384;
+var STAMP_WRITE_FLAG = "wx";
+var STAMP_CREATE_FLAG = STAMP_WRITE_FLAG;
+var EXISTS_ERROR_CODE = "EEXIST";
+var ACCOUNT_KEY_SEPARATOR = ":";
+function digest(content) {
+  return createHash(HASH_ALGORITHM).update(content).digest("hex");
+}
+function account_key() {
+  return String(process.getuid?.() ?? "");
+}
+function stamp_name(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  const key = digest(`${account_key()}${ACCOUNT_KEY_SEPARATOR}${root}`).slice(0, STAMP_KEY_LENGTH);
+  return `${prefix}${key}${suffix}`;
+}
+function stamp_path(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  return path.join(PLATFORM_TEMP_ROOT, stamp_name(prefix, root, suffix));
+}
+function write_exclusively(target, content) {
+  rmSync(target, { force: true });
+  writeFileSync(target, content, { flag: STAMP_WRITE_FLAG, mode: STAMP_FILE_MODE });
+  return target;
+}
+function write_stamp(target, payload) {
+  return write_exclusively(target, JSON.stringify(payload));
+}
+function is_own_regular_file(source) {
+  const stats = lstatSync(source);
+  if (!stats.isFile()) return false;
+  const uid = process.getuid?.();
+  return uid === void 0 || stats.uid === uid;
+}
+function is_foreign_file(target) {
+  try {
+    return lstatSync(target).isFile() && !is_own_regular_file(target);
+  } catch {
+    return false;
+  }
+}
+function replace_text_stamp(target, text) {
+  if (is_foreign_file(target)) {
+    throw new Error(`refusing to replace another account's file: ${target}`);
+  }
+  atomic_write.replace_file(target, text, { mode: STAMP_FILE_MODE });
+  return target;
+}
+function replace_stamp(target, payload) {
+  return replace_text_stamp(target, JSON.stringify(payload));
+}
+function write_text_stamp(target, text) {
+  return write_exclusively(target, text);
+}
+function create_stamp(target, payload) {
+  try {
+    writeFileSync(target, JSON.stringify(payload), {
+      flag: STAMP_CREATE_FLAG,
+      mode: STAMP_FILE_MODE
+    });
+    return true;
+  } catch (error) {
+    if (error.code === EXISTS_ERROR_CODE) return false;
+    throw error;
+  }
+}
+function remove_stamp(target) {
+  rmSync(target, { force: true });
+}
+function read_stamp_text(source) {
+  try {
+    if (!is_own_regular_file(source)) return void 0;
+    return readFileSync(source, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var stamp_file = {
+  create_stamp,
+  digest,
+  is_own_regular_file,
+  read_stamp_text,
+  replace_stamp,
+  replace_text_stamp,
+  remove_stamp,
+  stamp_name,
+  stamp_path,
+  write_stamp,
+  write_text_stamp
+};
+
+export {
+  PLATFORM_TEMP_ROOT,
+  platform_temporary,
+  stamp_file
+};

package/dist/commands/chunk-VMG3QB6C.js

@@ -0,0 +1,81 @@
+import {
+  lane_close
+} from "./chunk-XUXCFPDK.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/lane/lane-preserve.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+function preserved_comment(message, cause) {
+  return [
+    `The lane held uncommitted work when ${cause}, so it was stashed:`,
+    `- recover with \`pnpm josh stash:pop "${message}"\``
+  ].join("\n");
+}
+async function push_work(issue, directory, occasion) {
+  const message = git_stash.work_message(issue, occasion);
+  await git_stash.push(message, directory);
+  return message;
+}
+async function announce(issue, message, cause) {
+  await git_gh_issue_write.issue_try_comment(issue, preserved_comment(message, cause));
+}
+var KEEP_LOCK_PREFIX = "josh-lane-keep-lock-";
+var KEEP_LOCK_WAIT_MS = 6e4;
+var KEEP_LOCK_TIMEOUT = "another keep of this lane held the lock for the whole wait";
+function keep_lock_path(issue, directory) {
+  return repository_lock.lock_path(`${KEEP_LOCK_PREFIX}${issue}-`, directory);
+}
+async function stash_of(issue, directory, occasion) {
+  if (!await git_stash.has_work(directory)) return void 0;
+  return await push_work(issue, directory, occasion);
+}
+async function locked_stash_of(issue, directory, occasion) {
+  const kept = await repository_lock.with_lock(
+    async () => ({ stash: await stash_of(issue, directory, occasion) }),
+    keep_lock_path(issue, directory),
+    KEEP_LOCK_WAIT_MS
+  );
+  if (kept === void 0) return { kind: "unsaved", directory, reason: KEEP_LOCK_TIMEOUT };
+  return { kind: "saved", stash: kept.stash };
+}
+async function keep_work(issue, directory, occasion) {
+  try {
+    return await locked_stash_of(issue, directory, occasion);
+  } catch (error) {
+    return { kind: "unsaved", directory, reason: error_text.message_of(error) };
+  }
+}
+async function preserve_lane(issue, occasion, cause) {
+  const lane = await lane_close.resolve_lane(issue);
+  const { directory } = lane.targets;
+  if (!existsSync(path.join(directory, ".git"))) return true;
+  const kept = await keep_work(issue, directory, occasion);
+  if (kept.kind === "unsaved") {
+    console.error(
+      `${session_cite.issue(issue)}: uncommitted work could not be stashed \u2014 lane left at ${directory}`
+    );
+    return false;
+  }
+  if (kept.stash !== void 0) await announce(issue, kept.stash, cause);
+  return true;
+}
+var lane_preserve = { announce, keep_work, preserve_lane };
+
+export {
+  lane_preserve
+};

package/dist/commands/chunk-VO25PMGS.js

@@ -0,0 +1,58 @@
+import {
+  eslint_daemon,
+  eslint_daemon_calls
+} from "./chunk-KTV2HNWB.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-VL5I2IOD.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  LINT_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lint/eslint-warm.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lint/eslint-warm.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var WARM_CLI = fileURLToPath(new URL("eslint-warm-cli.ts", __josh_source_url));
+var TYPED_SOURCES = ["ls-files", "--", "*.ts", ":!*.d.ts"];
+var FALLBACK_TARGET = "eslint.config.js";
+var LINE_SEPARATOR = "\n";
+function warm_target(project_root) {
+  const listed = git_spawn_sync.read(TYPED_SOURCES, { cwd: project_root }) ?? "";
+  const [first] = listed.split(LINE_SEPARATOR);
+  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 };
+
+export {
+  eslint_warm
+};

package/dist/commands/chunk-VPRQFM2T.js

@@ -0,0 +1,37 @@
+import {
+  lane_plan_check
+} from "./chunk-ZJJLROJY.js";
+import {
+  plan_consumers_section
+} from "./chunk-SRG6PKVS.js";
+import {
+  backlog_overlap
+} from "./chunk-MDGPJOLK.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+
+// scripts/lane/lane-plan-auto.ts
+var SUCCESS_EXIT_CODE = 0;
+var PATH_PLACEHOLDER = "<path>...";
+var IMPORTS_HINT = "Append `--imports <path>...` naming the existing modules the new code imports \u2014 lane:plan probes their main guards before the first edit.";
+function command_of(issue_number, paths) {
+  const named = paths.length === 0 ? PATH_PLACEHOLDER : paths.map((path) => shell_quote.word(path)).join(" ");
+  return `pnpm josh lane:plan ${issue_number} ${named}`;
+}
+function paths_of(plan) {
+  return [...backlog_overlap.declared_paths(plan_consumers_section.without(plan))];
+}
+async function run_from_plan(issue_number, plan, directory = process.cwd()) {
+  const paths = paths_of(plan);
+  const lane = lane_plan_check.plan_of([issue_number, ...paths], /* @__PURE__ */ new Date());
+  console.info(command_of(issue_number, paths));
+  console.info(IMPORTS_HINT);
+  if (lane === void 0) return SUCCESS_EXIT_CODE;
+  return await lane_plan_check.check_plan(lane_plan_check.placed(lane, directory), directory);
+}
+var lane_plan_auto = { IMPORTS_HINT, command_of, paths_of, run_from_plan };
+
+export {
+  lane_plan_auto
+};