@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-72HZ2APA.js

@@ -0,0 +1,229 @@
+import {
+  extract_issue_number
+} from "./chunk-25LYH5QR.js";
+import {
+  main_merge_guard
+} from "./chunk-LDYDRXOY.js";
+import {
+  lane_install
+} from "./chunk-LAQZJX5C.js";
+import {
+  USAGE_ERROR_EXIT_CODE,
+  composite_arguments
+} from "./chunk-RSSJWMQS.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+import {
+  SUITE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/main-merge-regenerate.ts
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { execa } from "execa";
+
+// scripts/git/main-merge-budget-conflict.ts
+var BUDGET_TABLE_PATH = "scripts/document/document-byte-budget.ts";
+var CEILING_ROW = /^\t\{ path: '(?<path>[^']+)', bytes: (?<bytes>[\d_]+) \},$/u;
+var COMMENT_PREFIX = "	// ";
+var CONFLICT_MARKER = /^(?:<{7}|={7}|>{7}|\|{7})/mu;
+var BASE_SECTION = /^\|{7} .*\n(?:.*\n)*?(?=={7}\n)/gmu;
+var HUNK = /^<{7} .*\n(?<ours>(?:.*\n)*?)={7}\n(?<theirs>(?:.*\n)*?)>{7} .*\n(?=(?<after>.*))/gmu;
+function side_of(text) {
+  const lines = text.split("\n").slice(0, -1);
+  const last = lines.at(-1) ?? "";
+  const row = CEILING_ROW.test(last) ? last : void 0;
+  const comments = row === void 0 ? lines : lines.slice(0, -1);
+  if (comments.some((line) => !line.startsWith(COMMENT_PREFIX))) {
+    throw new Error(`${BUDGET_TABLE_PATH}: a conflict outside the ceiling rows`);
+  }
+  return { comments, row };
+}
+function ceiling_of(row) {
+  const groups = CEILING_ROW.exec(row)?.groups ?? {};
+  return { path: groups.path ?? "", bytes: Number(groups.bytes?.replaceAll("_", "")) };
+}
+function larger_row(ours, theirs) {
+  const [mine, other] = [ceiling_of(ours), ceiling_of(theirs)];
+  if (mine.path !== other.path) {
+    throw new Error(
+      `${BUDGET_TABLE_PATH}: rows of two pages conflict (${mine.path}, ${other.path})`
+    );
+  }
+  return mine.bytes >= other.bytes ? ours : theirs;
+}
+function rows_of(ours, theirs, after) {
+  if (ours.row !== void 0 && theirs.row !== void 0) return [larger_row(ours.row, theirs.row)];
+  if (ours.row === theirs.row && CEILING_ROW.test(after)) return [];
+  throw new Error(`${BUDGET_TABLE_PATH}: a ceiling row changed on one side only`);
+}
+function merge_hunk(ours, theirs, after) {
+  const [mine, other] = [side_of(ours), side_of(theirs)];
+  const comments = [.../* @__PURE__ */ new Set([...mine.comments, ...other.comments])];
+  return [...comments, ...rows_of(mine, other, after)].map((line) => `${line}
+`).join("");
+}
+function resolve(content) {
+  const resolved = content.replaceAll(BASE_SECTION, "").replaceAll(
+    HUNK,
+    (_hunk, ours, theirs, after) => merge_hunk(ours, theirs, after)
+  );
+  if (resolved === content || CONFLICT_MARKER.test(resolved)) {
+    throw new Error(`${BUDGET_TABLE_PATH}: a conflict left unresolved`);
+  }
+  return resolved;
+}
+var main_merge_budget_conflict = { BUDGET_TABLE_PATH, resolve };
+
+// scripts/git/main-merge-regenerate.ts
+var RESOLVED_FILES = [
+  {
+    path: "docs/josh-command-catalog.md",
+    command: ["pnpm", "exec", "tsx", "tools/document/generate-catalog-main.ts"]
+  },
+  {
+    path: main_merge_budget_conflict.BUDGET_TABLE_PATH,
+    rewrite: main_merge_budget_conflict.resolve
+  }
+];
+function resolved_for(files, table) {
+  const entries = files.map((file) => table.find((entry) => entry.path === file));
+  return entries.every((entry) => entry !== void 0) ? entries : [];
+}
+async function rewrite_file(entry, cwd) {
+  const file = path.join(cwd, entry.path);
+  await writeFile(file, entry.rewrite(await readFile(file, "utf8")));
+}
+async function regenerate_file(entry, cwd) {
+  const [binary = "", ...command_arguments] = entry.command;
+  await execa(binary, command_arguments, { cwd });
+}
+async function regenerate(entries, cwd) {
+  await Promise.all(
+    entries.map(async (entry) => {
+      await ("rewrite" in entry ? rewrite_file(entry, cwd) : regenerate_file(entry, cwd));
+    })
+  );
+}
+async function conclude_merge(entries) {
+  await git_spawn.with_output("add", ["--", ...entries.map((entry) => entry.path)]);
+  await git_spawn.with_output("commit", ["--no-edit"], { timeout_ms: SUITE_TIMEOUT_MS });
+}
+async function resolve2(files, table = RESOLVED_FILES) {
+  const entries = resolved_for(files, table);
+  if (entries.length === 0) return false;
+  try {
+    await regenerate(entries, await git_command.repository_root());
+    await conclude_merge(entries);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function is_resolvable(files, table = RESOLVED_FILES) {
+  return resolved_for(files, table).length > 0;
+}
+var main_merge_regenerate = { RESOLVED_FILES, is_resolvable, resolve: resolve2 };
+
+// scripts/git/main-merge.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var COMMAND_NAME = "main:merge";
+var LOCKFILE = "pnpm-lock.yaml";
+var INSTALL_OWED = "the merge brought in a lockfile change, but installing it failed \u2014 run `pnpm install --frozen-lockfile`";
+function merge_message(default_branch, current_branch) {
+  const issue_number = extract_issue_number(current_branch);
+  if (issue_number === void 0) return void 0;
+  return `Merge ${default_branch} into ${current_branch} ${issue_cite.plain_for("github", issue_number)}`;
+}
+async function unresolved_conflict(error) {
+  const files = main_merge_guard.unmerged_paths(await git_command.status());
+  if (files.length === 0) throw error;
+  return await main_merge_regenerate.resolve(files) ? void 0 : { kind: "conflict", files };
+}
+async function merge_into(target) {
+  const { default_branch, current_branch } = target;
+  try {
+    await git_command.merge_branch(default_branch, merge_message(default_branch, current_branch));
+  } catch (error) {
+    const conflict = await unresolved_conflict(error);
+    if (conflict !== void 0) return conflict;
+  }
+  return { kind: target.is_current ? "current" : "merged", branch: default_branch };
+}
+async function install_failure() {
+  try {
+    const result = await lane_install.install_dependencies(await git_command.repository_root());
+    return result.is_installed ? void 0 : result.output;
+  } catch (error) {
+    return error_text.message_of(error);
+  }
+}
+async function install_merged_lockfile(outcome, incoming) {
+  if (outcome.kind !== "merged" || !incoming.includes(LOCKFILE)) return;
+  const failure = await install_failure();
+  if (failure !== void 0) console.warn(`${INSTALL_OWED}
+${failure}`);
+}
+async function merge() {
+  const default_branch = await git_command.get_default_branch();
+  const current_branch = await git_command.branch();
+  await git_command.fetch_branch(default_branch);
+  const status = await git_command.status();
+  const incoming = await main_merge_guard.incoming_paths(default_branch);
+  const message = main_merge_guard.refusal(status, incoming, default_branch);
+  if (message !== void 0) return { kind: "refused", message };
+  const outcome = await merge_into({
+    default_branch,
+    current_branch,
+    is_current: incoming.length === 0
+  });
+  await install_merged_lockfile(outcome, incoming);
+  return outcome;
+}
+function failure_text(outcome) {
+  if (outcome.kind === "refused") return outcome.message;
+  if (outcome.kind === "conflict") return main_merge_guard.conflict_hint();
+  return void 0;
+}
+async function merge_default_branch() {
+  const outcome = await merge();
+  const failure = failure_text(outcome);
+  if (failure !== void 0) {
+    console.error(failure);
+    return FAILURE_EXIT_CODE;
+  }
+  if ("branch" in outcome) console.info(outcome.branch);
+  return SUCCESS_EXIT_CODE;
+}
+async function dispatch(argv) {
+  if (argv.length > 0) {
+    console.error(composite_arguments.format_rejection(COMMAND_NAME, []));
+    return USAGE_ERROR_EXIT_CODE;
+  }
+  return await merge_default_branch();
+}
+async function run(argv) {
+  try {
+    return await dispatch(argv);
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+var main_merge = { merge, run };
+
+export {
+  main_merge_regenerate,
+  main_merge
+};

package/dist/commands/chunk-72LAYP5S.js

@@ -0,0 +1,46 @@
+import {
+  run_startup
+} from "./chunk-IZPMBGAI.js";
+
+// scripts/josh/josh-run.ts
+import { execa } from "execa";
+var PNPM = "pnpm";
+var JOSH = "josh";
+var SUCCESS_EXIT_CODE = 0;
+var NONZERO_EXIT = 1;
+var FORWARDED_STDERR = ["pipe", "inherit"];
+function extra_options(timeout_ms, environment) {
+  const child_environment = { ...run_startup.environment(), ...environment };
+  return {
+    ...timeout_ms !== void 0 && { timeout: timeout_ms },
+    ...Object.keys(child_environment).length > 0 && { env: child_environment }
+  };
+}
+async function run_with_options(args, should_forward_stderr, options) {
+  const result = await execa(PNPM, [JOSH, ...args], {
+    reject: false,
+    stderr: should_forward_stderr ? FORWARDED_STDERR : "pipe",
+    ...options
+  });
+  return {
+    code: result.exitCode ?? NONZERO_EXIT,
+    out: result.stdout.trim(),
+    err: result.stderr.trim()
+  };
+}
+async function josh_run(args, should_forward_stderr = false, timeout_ms, environment) {
+  return await run_with_options(args, should_forward_stderr, extra_options(timeout_ms, environment));
+}
+async function josh_run_at(args, cwd) {
+  return await run_with_options(args, false, { ...extra_options(void 0, void 0), cwd });
+}
+function require_success(result, command) {
+  if (result.code === SUCCESS_EXIT_CODE) return;
+  const reason = [result.err, result.out].find((text) => text?.trim());
+  throw new Error(reason ?? `${command} exited ${String(result.code)}`);
+}
+var josh_command = { josh_run, josh_run_at, require_success };
+
+export {
+  josh_command
+};

package/dist/commands/chunk-72Y7PXUJ.js

@@ -0,0 +1,83 @@
+import {
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  SPLIT_ROUTE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+
+// scripts/split/split-resolution.ts
+var NOTICE_SECTION = `split-assessment.md \u2192 "${split_assess.NOTICE_SECTION}"`;
+function is_split_clear({ route, found_during }) {
+  const marked = lane_child_marker.marked_issue();
+  const finder = found_during ?? marked;
+  if (route !== SPLIT_ROUTE_LABEL || finder === void 0 || finder !== marked) return true;
+  console.error(
+    `refused: ${session_cite.issue(finder)} is a dispatched lane, which is never split \u2014 finish it; file an independent new requirement without \`--route split\` (${NOTICE_SECTION}).`
+  );
+  return false;
+}
+function is_notice(entry) {
+  return entry.kind === lane_ledger.KIND.SPLIT_NOTICE;
+}
+function is_split_child(entry) {
+  return entry.kind === lane_ledger.KIND.SPLIT_FILED;
+}
+function notices(entries) {
+  return entries.filter((entry) => is_notice(entry));
+}
+function split_issues(entries) {
+  return new Set(entries.filter((entry) => is_split_child(entry)).map((entry) => entry.issue));
+}
+async function record_child({ route, found_during, child }) {
+  if (route !== SPLIT_ROUTE_LABEL || found_during === void 0) return;
+  try {
+    await lane_ledger_write.record_split_filed({ issue: Number(found_during), child });
+  } catch (error) {
+    throw new Error(
+      `Created ${child}, but split-child evidence could not be recorded. Do not create another child. Recover with \`pnpm josh split:recover ${found_during} ${child}\`.`,
+      { cause: error }
+    );
+  }
+}
+async function record_fold({ origin, target }) {
+  try {
+    await lane_ledger_write.record_split_filed({
+      issue: Number(origin),
+      child: issue_cite.plain_for("program", target)
+    });
+  } catch (error) {
+    throw new Error(
+      `Folded into ${session_cite.issue(target)}, but split-child evidence for ${session_cite.issue(origin)} could not be recorded: ${error_text.message_of(error)}`,
+      { cause: error }
+    );
+  }
+}
+var split_resolution = {
+  is_split_clear,
+  notices,
+  record_child,
+  record_fold,
+  split_issues
+};
+
+export {
+  split_resolution
+};

package/dist/commands/chunk-77R6JEET.js

@@ -0,0 +1,128 @@
+import {
+  review_stamps
+} from "./chunk-PMC2N6JK.js";
+import {
+  test_unit_guard
+} from "./chunk-TXXEXJAV.js";
+import {
+  gate_tree
+} from "./chunk-3OSUM6DM.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  hook_decision
+} from "./chunk-HXAVYXUS.js";
+
+// scripts/gate/scoped-green.ts
+var SWITCH_ENV_KEY = "JOSH_SCOPED_GREEN";
+var SUCCESS_EXIT_CODE = 0;
+var LINT_SCRIPT = "lint:related";
+var TEST_SCRIPT = "test:related";
+var LINT_COMMAND = `pnpm josh ${LINT_SCRIPT}`;
+var TEST_COMMAND = `pnpm josh ${TEST_SCRIPT}`;
+function checks_of(sources) {
+  const lint = {
+    script: LINT_SCRIPT,
+    command: LINT_COMMAND,
+    stamp: review_stamps.lint_related_stamp,
+    source: sources.lint
+  };
+  const test = {
+    script: TEST_SCRIPT,
+    command: TEST_COMMAND,
+    stamp: review_stamps.test_related_stamp,
+    source: sources.test
+  };
+  return sources.is_unit_skipped ?? test_unit_guard.is_skipping(process.cwd()) ? [lint] : [lint, test];
+}
+function describes_tree(check, tree, base, is_overlooked = run_record_path.is_run_record) {
+  const stamp = check.stamp.read(check.source);
+  return stamp !== void 0 && file_map_stamp.changed_since(stamp, tree).every((relative) => is_overlooked(relative)) && file_map_stamp.describes_base(stamp, base) && check.stamp.describes_inputs(stamp);
+}
+function is_describable(files, base) {
+  return base !== void 0 && Object.keys(files).length > 0;
+}
+function is_answerable(tree, base) {
+  if (!hook_decision.is_switch_enabled(SWITCH_ENV_KEY)) return false;
+  return is_describable(tree, base);
+}
+function stale_checks(tree, base, sources) {
+  if (!is_answerable(tree, base)) return [];
+  return checks_of(sources).filter((check) => !describes_tree(check, tree, base));
+}
+function missing_checks(tree, base, sources = {}) {
+  return stale_checks(tree, base, sources).map((check) => check.command);
+}
+function missing_scripts(tree, base, sources = {}) {
+  return stale_checks(tree, base, sources).map((check) => check.script);
+}
+function overlooks_nothing() {
+  return false;
+}
+function green_scripts(tree, base, sources = {}) {
+  if (!is_answerable(tree, base)) return [];
+  return checks_of(sources).filter((check) => describes_tree(check, tree, base, overlooks_nothing)).map((check) => check.script);
+}
+var REFUSAL_HEADLINE = "\u26D4 scoped checks not green on this tree";
+var REISSUE_STEP = "and reissue this command.";
+var LANE_CHILD_STEP = 'then hand over to `pnpm josh ship --detach --review "<title> #<N>"` rather than reissuing the gate \u2014 this is a dispatched lane child, and ship runs the gate beside the review (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
+function refusal(missing, next_step) {
+  return `${REFUSAL_HEADLINE}: ${missing.join(" and ")} have not passed on the files this branch changed. The gate and review round 1 start together, so a brief composed now describes a tree neither check has read \u2014 joshuafolkken/kit#1503 spent 282 seconds, 31% of the run, picking up one lint rule and one failing test at a time after its review had already started. Run them in one call \u2014 \`${LINT_COMMAND} && ${TEST_COMMAND}\`, measured at 13.8 seconds \u2014 ${next_step} The record fixes when the checks run: only a merge with the default branch sharing nothing with this branch's change is recorded without a run. \`.claude/skills/workflow-commands/chain-rule.md\` \u2192 "Orchestration facts single-sourced here".`;
+}
+function next_step_of(sources) {
+  return sources.is_lane_child === true ? LANE_CHILD_STEP : REISSUE_STEP;
+}
+function refusal_for(tree, base, sources = {}) {
+  const missing = missing_checks(tree, base, sources);
+  return missing.length === 0 ? void 0 : refusal(missing, next_step_of(sources));
+}
+function is_recordable_scope(command_arguments) {
+  return command_arguments.length === 0;
+}
+async function read_before(command_arguments) {
+  if (!is_recordable_scope(command_arguments)) return void 0;
+  return await gate_tree.read_gate_tree();
+}
+function is_unmoved(before, after) {
+  if (before.base !== after.base) return false;
+  return JSON.stringify(before.files) === JSON.stringify(after.files);
+}
+function record_green(stamp, tree, target, blobs) {
+  if (!is_describable(tree.files, tree.base)) return;
+  try {
+    stamp.write(tree.files, target, tree.base, blobs);
+  } catch {
+  }
+}
+async function record_if_green(stamp, record) {
+  const { before, exit_code, target } = record;
+  if (before === void 0 || exit_code !== SUCCESS_EXIT_CODE || !is_unmoved(before, await gate_tree.read_gate_tree())) {
+    return;
+  }
+  record_green(stamp, before, target, record.blobs);
+}
+var scoped_green = {
+  LINT_COMMAND,
+  LINT_SCRIPT,
+  REFUSAL_HEADLINE,
+  SWITCH_ENV_KEY,
+  TEST_COMMAND,
+  TEST_SCRIPT,
+  green_scripts,
+  is_recordable_scope,
+  is_unmoved,
+  missing_checks,
+  missing_scripts,
+  read_before,
+  record_green,
+  record_if_green,
+  refusal_for
+};
+
+export {
+  scoped_green
+};

package/dist/commands/chunk-7GICNM73.js

@@ -0,0 +1,137 @@
+import {
+  whole_suite_files
+} from "./chunk-4MRBLCDB.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/test/direct-importers.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var PACKAGE_FILE = "package.json";
+var WILDCARD = "*";
+var CURRENT_DIRECTORY_PREFIX = "./";
+var NUL = "\0";
+var SCOPE_PREFIX = "@";
+var SCOPED_SEGMENTS = 2;
+var NON_PACKAGE_PATTERN = /(?:^[.#/])|:/u;
+var SPECIFIER_PATTERN = /(?:\bfrom\s+|\bimport\s*\(\s*|\bimport\s+|\bmock\(\s*)["']([^"']+)["']/gu;
+function module_key(file) {
+  const posix = file.split(path.sep).join(path.posix.sep);
+  return posix.slice(0, posix.length - path.posix.extname(posix).length);
+}
+function specifiers_of(source) {
+  return [...source.matchAll(SPECIFIER_PATTERN)].flatMap((match) => match.slice(1));
+}
+function alias_target(specifier, imports) {
+  const exact = imports[specifier];
+  if (exact !== void 0) return exact;
+  const key = Object.keys(imports).find(
+    (pattern) => pattern.endsWith(WILDCARD) && specifier.startsWith(pattern.slice(0, -1))
+  );
+  if (key === void 0) return void 0;
+  return imports[key]?.split(WILDCARD).join(specifier.slice(key.length - 1));
+}
+function relative_target(specifier, from) {
+  return path.posix.join(path.posix.dirname(from), specifier);
+}
+function resolve_specifier(specifier, from, imports) {
+  if (specifier.startsWith(".")) return module_key(relative_target(specifier, from));
+  const target = alias_target(specifier, imports);
+  if (target === void 0) return void 0;
+  return module_key(path.posix.normalize(target.replace(CURRENT_DIRECTORY_PREFIX, "")));
+}
+function names_any(source, from, scoped, imports) {
+  return specifiers_of(source).some((specifier) => {
+    const resolved = resolve_specifier(specifier, from, imports);
+    return resolved !== void 0 && scoped.has(resolved);
+  });
+}
+function read_imports(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(path.join(root, PACKAGE_FILE), "utf8"));
+    const imports = Reflect.get(new Object(parsed), "imports");
+    if (typeof imports !== "object" || imports === null) return {};
+    return Object.fromEntries(
+      Object.entries(imports).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+  } catch {
+    return {};
+  }
+}
+function read_source_at(root, file) {
+  try {
+    return readFileSync(path.join(root, file), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function source_reader(root) {
+  return { imports: read_imports(root), read_source: (file) => read_source_at(root, file) };
+}
+async function work_tree_files(root) {
+  const listed = await git_spawn.read(["-C", root, "ls-files", "-coz", "--exclude-standard"]);
+  return listed.split(NUL).filter((file) => file !== "");
+}
+async function test_files(root) {
+  const files = await work_tree_files(root);
+  return files.filter((file) => test_declared_logic.is_test_file(file));
+}
+function importers_among(file, tests, reader) {
+  const scoped = /* @__PURE__ */ new Set([module_key(file)]);
+  return tests.filter((test) => {
+    const source = reader.read_source(test);
+    return source !== void 0 && names_any(source, test, scoped, reader.imports);
+  });
+}
+function every_test_imports_of(files) {
+  return files.filter((file) => whole_suite_files.EVERY_TEST_IMPORTS.has(path.normalize(file)));
+}
+function is_every_test_import(root, argument) {
+  return whole_suite_files.EVERY_TEST_IMPORTS.has(path.relative(root, path.resolve(argument)));
+}
+async function importers_of(root, files) {
+  if (files.length === 0) return /* @__PURE__ */ new Map();
+  const tests = await test_files(root);
+  const reader = source_reader(root);
+  return new Map(files.map((file) => [file, importers_among(file, tests, reader)]));
+}
+async function every_test_importers(root, files) {
+  return await importers_of(root, every_test_imports_of(files));
+}
+function package_of(specifier) {
+  if (NON_PACKAGE_PATTERN.test(specifier)) return void 0;
+  const segments = specifier.split(path.posix.sep);
+  const kept = specifier.startsWith(SCOPE_PREFIX) ? SCOPED_SEGMENTS : 1;
+  return segments.slice(0, kept).join(path.posix.sep);
+}
+function imports_package(source, packages) {
+  return specifiers_of(source).some((specifier) => packages.has(package_of(specifier) ?? ""));
+}
+async function package_importers(root, packages, is_source) {
+  if (packages.size === 0) return [];
+  const files = await work_tree_files(root);
+  const sources = files.filter((file) => is_source(file));
+  return sources.filter((file) => imports_package(read_source_at(root, file) ?? "", packages));
+}
+var direct_importers = {
+  every_test_importers,
+  package_importers,
+  every_test_imports_of,
+  importers_of,
+  is_every_test_import,
+  module_key,
+  names_any,
+  resolve_specifier,
+  source_reader,
+  specifiers_of
+};
+
+export {
+  direct_importers
+};

package/dist/commands/chunk-7OZT74HR.js

@@ -0,0 +1,78 @@
+import {
+  lane_stop_stats
+} from "./chunk-LAUKNN57.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+
+// scripts/lane/lane-cut-stats.ts
+var CUT_PHASE = /cut \(([^)]+)\)$/u;
+var UNKNOWN_PHASE = "unknown";
+var ALL = "all";
+var COLUMNS = ["cuts", "per lane median", "per lane max", "total"];
+function cuts_of(events) {
+  return events.filter((event) => event.kind === run_event_stream.EVENT_KIND.CUT).map((event) => ({
+    issue: lane_stop_stats.issue_of(event),
+    phase: CUT_PHASE.exec(event.text)?.[1] ?? UNKNOWN_PHASE
+  }));
+}
+function phases_of(cuts) {
+  return [...new Set(cuts.map((cut) => cut.phase))].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function count_text(name, count) {
+  return `${name} \xD7${String(count)}`;
+}
+function line(events, issue) {
+  const cuts = cuts_of(events).filter((cut) => cut.issue === issue);
+  if (cuts.length === 0) return void 0;
+  const causes = phases_of(cuts).map(
+    (phase) => count_text(phase, cuts.filter((cut) => cut.phase === phase).length)
+  );
+  return `${count_text("run:cut", cuts.length)} (${causes.join(", ")})`;
+}
+function lanes_of(entries, cuts) {
+  const dispatched = entries.filter((entry) => lane_stage_stats.is_dispatch(entry));
+  return [.../* @__PURE__ */ new Set([...dispatched.map((entry) => entry.issue), ...cuts.map((cut) => cut.issue)])];
+}
+function count_cell(value) {
+  return value === void 0 ? lane_stats.MISSING : String(value);
+}
+function row(name, lanes, cuts) {
+  const per_lane = lanes.map((issue) => cuts.filter((cut) => cut.issue === issue).length);
+  return lane_stats.to_row([
+    name,
+    count_cell(lane_stats.median(per_lane)),
+    count_cell(lane_stats.peak(per_lane)),
+    String(cuts.length)
+  ]);
+}
+function table(entries, window, events) {
+  const cuts = cuts_of(lane_stats.in_window(events, window));
+  const lanes = lanes_of(lane_stats.in_window(entries, window), cuts);
+  const phase_rows = phases_of(cuts).map(
+    (phase) => row(
+      phase,
+      lanes,
+      cuts.filter((cut) => cut.phase === phase)
+    )
+  );
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    row(ALL, lanes, cuts),
+    ...phase_rows
+  ].join("\n");
+}
+var lane_cut_stats = { line, table };
+
+export {
+  lane_cut_stats
+};