@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-LX2ENXHZ.js

@@ -0,0 +1,197 @@
+import {
+  shared_cache
+} from "./chunk-WXLW7S4M.js";
+import {
+  gh_failure,
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-transport.ts
+import { z } from "zod";
+
+// scripts/gh/git-gh-rate-limit.ts
+var FORBIDDEN_STATUS = 403;
+var TOO_MANY_REQUESTS_STATUS = 429;
+var RATE_LIMIT_STATUSES = /* @__PURE__ */ new Set([
+  FORBIDDEN_STATUS,
+  TOO_MANY_REQUESTS_STATUS
+]);
+var MILLISECONDS_PER_SECOND = 1e3;
+var RATE_LIMIT_MESSAGE = /rate limit (?:already )?exceeded|exceeded a secondary rate limit/iu;
+var EXHAUSTED_HEADER = /^x-ratelimit-remaining:\s*0\s*$/imu;
+var RESET_HEADER = /^x-ratelimit-reset:\s*(?<epoch>\d+)\s*$/imu;
+var STATUS_PATTERNS = [
+  /\(HTTP (?<status>\d{3})\)/u,
+  /^HTTP\/\S+ (?<status>\d{3})/mu,
+  /"status":\s*"?(?<status>\d{3})/u
+];
+var AUTH_HINT = "check `gh auth status` and the network";
+function status_of(text) {
+  const status = STATUS_PATTERNS.map((pattern) => pattern.exec(text)?.groups?.["status"]).find(
+    (found) => found !== void 0
+  );
+  return status === void 0 ? void 0 : Number(status);
+}
+function is_exhausted(text) {
+  if (RATE_LIMIT_MESSAGE.test(text)) return true;
+  const status = status_of(text);
+  return status !== void 0 && RATE_LIMIT_STATUSES.has(status) && EXHAUSTED_HEADER.test(text);
+}
+function epoch_to_date(epoch) {
+  const seconds = Number(epoch);
+  if (epoch === void 0 || !Number.isSafeInteger(seconds) || seconds <= 0) return void 0;
+  return new Date(seconds * MILLISECONDS_PER_SECOND);
+}
+async function read_reset() {
+  try {
+    const epoch = await git_gh_exec.exec_gh_api({
+      path: "rate_limit",
+      jq_filter: ".resources.core.reset",
+      should_retry: false
+    });
+    return epoch_to_date(epoch.trim());
+  } catch (error) {
+    error_text.trace_swallowed("gh_rate_limit.read_reset", error);
+    return void 0;
+  }
+}
+function exhausted_message(resets_at) {
+  const when = resets_at === void 0 ? "at an unread time" : `at ${resets_at.toISOString()}`;
+  return `GitHub rate limit exhausted, resets ${when} \u2014 wait for the reset; this is not an authentication failure, so do not refresh gh auth`;
+}
+async function failure_hint(text) {
+  if (!is_exhausted(text)) return AUTH_HINT;
+  const resets_at = epoch_to_date(RESET_HEADER.exec(text)?.groups?.["epoch"]) ?? await read_reset();
+  return exhausted_message(resets_at);
+}
+var gh_rate_limit = { AUTH_HINT, exhausted_message, failure_hint, is_exhausted };
+
+// scripts/gh/git-gh-transport.ts
+var TRANSPORT_ENV_VAR = "JOSH_GH_TRANSPORT";
+var GRAPHQL_PATH = "graphql";
+var FORBIDDEN_STATUS2 = 403;
+var MS_KEPT = 36e5;
+var DEFAULT_HOST = "github.com";
+var PROBE_QUERY = "query { viewer { login } }";
+var NOT_PROBED = "not probed";
+var TRANSPORT_CACHE = { prefix: "josh-gh-transport-", ttl_ms: MS_KEPT };
+var REFUSED_MESSAGE = `GitHub refused a GraphQL read, and ${TRANSPORT_ENV_VAR}=graphql forbids reading it through REST \u2014 set it to auto or rest to read where GraphQL is refused`;
+var partial_document_schema = z.looseObject({
+  data: z.looseObject({}),
+  errors: z.array(z.unknown()).nonempty()
+});
+var transport_schema = z.enum(["graphql", "rest"]);
+var setting_schema = z.enum(["auto", "graphql", "rest"]);
+var logins = /* @__PURE__ */ new Map();
+function parse_setting(raw) {
+  if (raw === void 0 || raw === "") return "auto";
+  return setting_schema.safeParse(raw).data;
+}
+function setting() {
+  const raw = process.env[TRANSPORT_ENV_VAR];
+  const parsed = parse_setting(raw);
+  if (parsed === void 0) {
+    throw new Error(`${TRANSPORT_ENV_VAR} must be auto, graphql or rest, not ${String(raw)}`);
+  }
+  return parsed;
+}
+async function read_login(host) {
+  try {
+    return await git_gh_exec.exec_gh_command(["config", "get", "user", "--host", host]);
+  } catch {
+    return "";
+  }
+}
+async function key_of() {
+  const host = process.env["GH_HOST"] ?? DEFAULT_HOST;
+  const login = logins.get(host) ?? read_login(host);
+  logins.set(host, login);
+  return `${host}/${await login}`;
+}
+function is_refused(error) {
+  if (gh_failure.failure_of(error)?.status !== FORBIDDEN_STATUS2) return false;
+  return !gh_rate_limit.is_exhausted(error_text.message_of(error));
+}
+async function send(body) {
+  return await git_gh_exec.exec_gh_api({ path: GRAPHQL_PATH, body: JSON.stringify(body) });
+}
+async function probe() {
+  try {
+    await send({ query: PROBE_QUERY });
+    return "graphql";
+  } catch (error) {
+    return is_refused(error) ? "rest" : void 0;
+  }
+}
+async function current(now_ms = Date.now()) {
+  const chosen = setting();
+  if (chosen !== "auto") return chosen;
+  const request = { slot: TRANSPORT_CACHE, key: await key_of(), schema: transport_schema };
+  return await shared_cache.remember(request, probe, now_ms) ?? "graphql";
+}
+async function on_failure(error, now_ms) {
+  if (!is_refused(error)) return;
+  if (setting() === "graphql") throw new Error(REFUSED_MESSAGE, { cause: error });
+  shared_cache.write(TRANSPORT_CACHE, await key_of(), "rest", now_ms);
+}
+function partial_answer(error) {
+  const body = gh_failure.body_of(error);
+  if (body === void 0) return void 0;
+  return json_value.parse_with(body, partial_document_schema) === void 0 ? void 0 : body;
+}
+async function sent_or_failed(body, now_ms, recovered) {
+  try {
+    return await send(body);
+  } catch (error) {
+    await on_failure(error, now_ms);
+    return recovered?.(error);
+  }
+}
+async function answer_of(body, now_ms, recovered) {
+  if (await current(now_ms) === "rest") return void 0;
+  return await sent_or_failed(body, now_ms, recovered);
+}
+async function query(body, now_ms = Date.now()) {
+  return await answer_of(body, now_ms);
+}
+async function query_partial(body, now_ms = Date.now()) {
+  return await answer_of(body, now_ms, partial_answer);
+}
+async function kept(now_ms) {
+  return shared_cache.read(TRANSPORT_CACHE, await key_of(), transport_schema, now_ms);
+}
+async function known(now_ms = Date.now()) {
+  const chosen = parse_setting(process.env[TRANSPORT_ENV_VAR]);
+  if (chosen === void 0) return void 0;
+  return chosen === "auto" ? await kept(now_ms) : chosen;
+}
+async function label(now_ms = Date.now()) {
+  const chosen = parse_setting(process.env[TRANSPORT_ENV_VAR]);
+  if (chosen === void 0) return `invalid ${TRANSPORT_ENV_VAR}`;
+  if (chosen !== "auto") return chosen;
+  return `${await kept(now_ms) ?? NOT_PROBED} (auto)`;
+}
+function forget_logins() {
+  logins.clear();
+}
+var git_gh_transport = {
+  current,
+  forget_logins,
+  known,
+  label,
+  query,
+  query_partial,
+  TRANSPORT_CACHE
+};
+
+export {
+  gh_rate_limit,
+  GRAPHQL_PATH,
+  git_gh_transport
+};

package/dist/commands/chunk-M32UPB2D.js

@@ -0,0 +1,110 @@
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/josh/file-map-stamp.ts
+function is_file_map(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+function identity_fields({ pid, process_start }) {
+  return {
+    ...typeof pid === "number" && { pid },
+    ...typeof process_start === "string" && { process_start }
+  };
+}
+function tree_fields({ base, completed_at, blobs }) {
+  return {
+    ...typeof base === "string" && { base },
+    ...typeof completed_at === "string" && { completed_at },
+    ...is_file_map(blobs) && { blobs }
+  };
+}
+function input_fields({ inputs }) {
+  return typeof inputs === "string" ? { inputs } : {};
+}
+function parse_stamp(raw) {
+  const parsed = JSON.parse(raw);
+  const { taken_at, files } = parsed;
+  if (typeof taken_at !== "string" || !is_file_map(files)) return void 0;
+  return {
+    taken_at,
+    files,
+    ...identity_fields(parsed),
+    ...tree_fields(parsed),
+    ...input_fields(parsed)
+  };
+}
+function writer_state(stamp) {
+  if (stamp === void 0) return false;
+  return process_identity.is_same_process(stamp.pid, stamp.process_start);
+}
+function is_writer_running(stamp) {
+  return writer_state(stamp) === true;
+}
+function is_writer_gone(stamp) {
+  return writer_state(stamp) === false;
+}
+function describes_base(stamp, base) {
+  return base !== void 0 && stamp.base === base;
+}
+function changed_since(stamp, tree) {
+  const names = /* @__PURE__ */ new Set([...Object.keys(stamp.files), ...Object.keys(tree)]);
+  return [...names].filter((name) => stamp.files[name] !== tree[name]).toSorted((left, right) => left.localeCompare(right));
+}
+function read_at(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  try {
+    return parse_stamp(raw);
+  } catch {
+    return void 0;
+  }
+}
+function is_own_record(stamp) {
+  return stamp.pid === process.pid && !is_writer_gone(stamp);
+}
+function complete_at(target) {
+  const stamp = read_at(target);
+  if (stamp === void 0 || !is_own_record(stamp)) return void 0;
+  return stamp_file.write_stamp(target, { ...stamp, completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+function create(prefix, root, inputs) {
+  function resolve() {
+    return stamp_file.stamp_path(prefix, root);
+  }
+  return {
+    stamp_path: resolve,
+    // `base` goes into the payload undefined and all — `JSON.stringify` drops an undefined value,
+    // so a caller that has no base writes exactly the record it wrote before this field existed.
+    // `own_fields` is what writes the pid, and the writing process's start time beside it — assembled in one place so no record can carry half an identity.
+    write: (files, target = resolve(), base, blobs) => stamp_file.write_stamp(target, {
+      taken_at: (/* @__PURE__ */ new Date()).toISOString(),
+      files,
+      ...process_identity.own_fields(),
+      base,
+      blobs,
+      inputs: inputs?.()
+    }),
+    complete: (target = resolve()) => complete_at(target),
+    read: (source = resolve()) => read_at(source),
+    describes_inputs: (stamp) => inputs === void 0 || stamp.inputs === inputs(),
+    remove: (target = resolve()) => {
+      stamp_file.remove_stamp(target);
+    }
+  };
+}
+var file_map_stamp = {
+  changed_since,
+  create,
+  describes_base,
+  is_writer_running,
+  parse_stamp
+};
+
+export {
+  file_map_stamp
+};

package/dist/commands/chunk-M3UGRNNB.js

@@ -0,0 +1,103 @@
+import {
+  epic_add_body,
+  epic_chains,
+  epic_read,
+  epic_shape
+} from "./chunk-MOD3FG4V.js";
+import {
+  epic_sections
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_relations
+} from "./chunk-WTIPX5NG.js";
+import {
+  epic_validate
+} from "./chunk-RFWB2KAV.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+
+// scripts/epic/epic-untrack-plan.ts
+function touches(link, children) {
+  return children.has(link.blocker) || children.has(link.blocked);
+}
+function without_rows(body, children) {
+  const lines = epic_sections.to_body_lines(body);
+  const removed = new Set(
+    epic_sections.find_indices(
+      lines,
+      (line) => epic_parse.parse_task_list_issue_numbers(line).some((child) => children.has(child))
+    )
+  );
+  return lines.lines.filter((_line, index) => !removed.has(index)).join("\n");
+}
+function rewrite(reading, children) {
+  const chains = epic_parse.parse_dependency_chains(reading.subject.body);
+  const removed = epic_chains.links_of(chains).filter((link) => touches(link, children));
+  return epic_add_body.rewrite_body({
+    body: without_rows(reading.subject.body ?? "", children),
+    placed: [],
+    chains_after: epic_chains.remove_links(chains, removed),
+    does_clear_declaration: removed.length > 0
+  });
+}
+function build_plan(reading, children) {
+  const tracked = epic_parse.parse_task_list_issue_numbers(reading.subject.body);
+  const error = epic_shape.find_subject_error(
+    { ...reading.subject, epic_number: reading.subject.number },
+    tracked
+  );
+  if (error !== void 0) return { error };
+  const selected = new Set(children);
+  const rewritten = rewrite(reading, selected);
+  if ("error" in rewritten) return rewritten;
+  const results = epic_validate.validate_epic({ ...reading.subject, body: rewritten.body });
+  if (!epic_validate.is_epic_valid(results)) {
+    return { error: "The remaining body would fail epic:check; nothing was written." };
+  }
+  return {
+    plan: {
+      body: rewritten.body,
+      removed: epic_graph.undeclared_relations([], reading.recorded, reading.repo).filter((link) => touches(link, selected))
+    }
+  };
+}
+var epic_untrack_plan = { build_plan };
+
+// scripts/epic/epic-untrack.ts
+var FAILURE = 1;
+var SUCCESS = 0;
+function refuse(error) {
+  console.error(`\u2716 ${error}`);
+  return FAILURE;
+}
+async function untrack(epic_number, children) {
+  const reading = await epic_read.read_epic(epic_number);
+  if ("error" in reading) return refuse(reading.error);
+  const outcome = epic_untrack_plan.build_plan(reading, children);
+  if ("error" in outcome) return refuse(outcome.error);
+  const failures = await epic_relations.apply_relations(outcome.plan.removed, "drop");
+  console.info(
+    epic_relations.format_relation_report({
+      failures,
+      links: outcome.plan.removed,
+      action: "drop"
+    })
+  );
+  if (failures > 0) return FAILURE;
+  if (outcome.plan.body !== reading.subject.body) {
+    await git_gh_command.issue_edit_body(String(epic_number), outcome.plan.body);
+  }
+  return SUCCESS;
+}
+var epic_untrack = { untrack };
+
+export {
+  epic_untrack
+};

package/dist/commands/chunk-M4WG74Q7.js

@@ -0,0 +1,260 @@
+import {
+  lane_cache_run
+} from "./chunk-EHVEWJQ4.js";
+import {
+  lint_timing
+} from "./chunk-EAOTR2WL.js";
+import {
+  eslint_daemon
+} from "./chunk-KTV2HNWB.js";
+import {
+  eslint_cache_dependencies
+} from "./chunk-6O45F6YI.js";
+import {
+  verification_inputs
+} from "./chunk-MHXIJKGP.js";
+import {
+  lint_shard
+} from "./chunk-ZECFKW7D.js";
+import {
+  lint_related_scope
+} from "./chunk-DLHH3MLS.js";
+import {
+  changed_file_scope
+} from "./chunk-QX2EMUXV.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  ESLINT_CACHE_FILE,
+  ESLINT_CACHE_FLAGS,
+  PRETTIER_CACHE_FLAGS
+} from "./chunk-TBIX5FRN.js";
+import {
+  eslint_heap
+} from "./chunk-CGYDIYHD.js";
+import {
+  FAIL_EXIT_CODE,
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+
+// scripts/lint/lint-parallel.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// scripts/lint/lint-gate-scope.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { environment_flags } from "@joshuafolkken/kit/env";
+var GATE_CACHES = {
+  eslint_file: ESLINT_CACHE_FILE,
+  eslint_flags: ESLINT_CACHE_FLAGS,
+  prettier_flags: PRETTIER_CACHE_FLAGS
+};
+var CI_REASON = "CI lints the whole tree";
+var CONFIG_REASON = "a changed file configures the toolchain or the linters";
+var VOCABULARY = {
+  label: "josh lint --changed",
+  fallback_suffix: "checking the whole tree instead",
+  narrowed_suffix: "checking only them"
+};
+function all_scope(reason) {
+  return { mode: "all", files: [], reason };
+}
+function configures_lint(files, root) {
+  return verification_inputs.configures(
+    gate_labels.LINT_LABEL,
+    files.map((file) => path.relative(root, file).split(path.sep).join("/")),
+    root
+  );
+}
+function resolve_gate_scope(files, root, environment) {
+  if (environment_flags.is_ci_enabled(environment["CI"])) return all_scope(CI_REASON);
+  if (files !== void 0 && configures_lint(files, root)) return all_scope(CONFIG_REASON);
+  return changed_file_scope.resolve_scope(files, lint_related_scope.scope_inputs(existsSync));
+}
+function narrowed_run(files) {
+  return {
+    prettier: lint_related_scope.prettier_arguments(files, GATE_CACHES),
+    eslint: lint_related_scope.eslint_arguments(files, GATE_CACHES),
+    eslint_cache_file: GATE_CACHES.eslint_file
+  };
+}
+function describe_scope(scope, root) {
+  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+}
+var lint_gate_scope = {
+  CHANGED_FLAG: "--changed",
+  CI_REASON,
+  CONFIG_REASON,
+  describe_scope,
+  narrowed_run,
+  resolve_gate_scope
+};
+
+// scripts/lint/lint-parallel.ts
+function eslint_args_of(shard) {
+  return ["exec", "eslint", ...lint_shard.eslint_targets(shard), ...ESLINT_CACHE_FLAGS];
+}
+var ESLINT_ARGS = eslint_args_of(void 0);
+function prettier_check_args(targets) {
+  return ["exec", "prettier", "--check", ...targets, ...PRETTIER_CACHE_FLAGS];
+}
+var PRETTIER_ARGS = prettier_check_args([lint_shard.WHOLE_TREE]);
+function project_prettier_args() {
+  return prettier_check_args(
+    project_checks.prettier_targets(process.cwd(), [lint_shard.WHOLE_TREE])
+  );
+}
+var LEFT_TO_FORMATTING_SHARD = {
+  output: `josh prettier: ${lint_shard.FORMATTING_SHARD_REASON}.
+`,
+  exit_code: 0,
+  elapsed_ms: 0
+};
+function prettier_args_of(shard) {
+  return lint_shard.checks_formatting(shard) ? project_prettier_args() : void 0;
+}
+var GATE_TIMING_LABEL = "lint";
+var COLD_RUN = { warm_daemon: false };
+async function run_eslint_process(eslint) {
+  if (eslint.warm_daemon) return await eslint_daemon.run_or_cold(eslint.args, eslint.call);
+  return await eslint_heap.run_cold(eslint.args);
+}
+async function run_eslint(eslint) {
+  const { cache_file } = eslint;
+  return await lane_cache_run.run(cache_file, async () => {
+    const is_cached = existsSync2(cache_file);
+    const { result, drop } = await eslint_cache_dependencies.guard_counted(
+      cache_file,
+      async () => await run_eslint_process(eslint)
+    );
+    return { ...result, is_cached, drop };
+  });
+}
+function write_output(result) {
+  const { output } = result;
+  if (!output) return;
+  process.stdout.write(output.endsWith("\n") ? output : `${output}
+`);
+}
+function skipped(check, reason) {
+  return { output: `${project_checks.skip_notice(check, reason)}
+`, exit_code: 0, elapsed_ms: 0 };
+}
+async function run_prettier(directory, prettier_args) {
+  if (prettier_args === void 0) return LEFT_TO_FORMATTING_SHARD;
+  const reason = project_checks.prettier_skip_reason(directory);
+  if (reason !== void 0) return skipped("prettier", reason);
+  return await buffered_process.run_buffered_direct(prettier_args);
+}
+async function run_checked_eslint(directory, eslint) {
+  const reason = project_checks.eslint_skip_reason(directory);
+  if (reason !== void 0) return skipped("eslint", reason);
+  return await run_eslint(eslint);
+}
+function is_silent_pass(result) {
+  return result.output === "" && !buffered_process.is_process_failed(result);
+}
+function with_ran_notice(check, result, sibling) {
+  if (!sibling.output.includes(SKIP_MARKER) || !is_silent_pass(result)) return result;
+  return { ...result, output: `${project_checks.ran_notice(check)}
+` };
+}
+function lint_exit_code(prettier, eslint) {
+  return buffered_process.is_process_failed(prettier) || buffered_process.is_process_failed(eslint) ? FAIL_EXIT_CODE : 0;
+}
+async function run_lint_pair(prettier_args, eslint_args, cache_file, options) {
+  const directory = process.cwd();
+  const [prettier, eslint] = await Promise.all([
+    run_prettier(directory, prettier_args),
+    run_checked_eslint(directory, { args: eslint_args, cache_file, ...options })
+  ]);
+  return { prettier, eslint };
+}
+function write_lint_pair({ prettier, eslint }) {
+  write_output(with_ran_notice("prettier", prettier, eslint));
+  write_output(with_ran_notice("eslint", eslint, prettier));
+  return lint_exit_code(prettier, eslint);
+}
+function timing_line(pair, label, facts) {
+  const { prettier, eslint } = pair;
+  return lint_timing.line({
+    label,
+    prettier_ms: prettier.elapsed_ms,
+    eslint_ms: eslint.elapsed_ms,
+    facts
+  });
+}
+function daemon_fact(eslint) {
+  return eslint.daemon ?? "cold process";
+}
+function drop_fact({ dropped, total }) {
+  return `${String(dropped)} of ${String(total)} cache entries dropped`;
+}
+function cache_fact(eslint) {
+  if (eslint.is_cached !== true) return "cache absent";
+  return eslint.drop === void 0 ? "cache present" : `cache present \xB7 ${drop_fact(eslint.drop)}`;
+}
+async function run_lint_checks(prettier_args, eslint_args, cache_file, options = COLD_RUN) {
+  const { timing } = options;
+  if (timing === void 0) {
+    return write_lint_pair(await run_lint_pair(prettier_args, eslint_args, cache_file, options));
+  }
+  const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, options);
+  const exit_code = write_lint_pair(pair);
+  const facts = [timing.targets, daemon_fact(pair.eslint), cache_fact(pair.eslint)];
+  process.stdout.write(timing_line(pair, timing.label, facts));
+  return exit_code;
+}
+async function run_timed_lint_checks(prettier_args, eslint_args, cache_file) {
+  const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, COLD_RUN);
+  const exit_code = write_lint_pair(pair);
+  process.stdout.write(timing_line(pair, GATE_TIMING_LABEL, [cache_fact(pair.eslint)]));
+  return exit_code;
+}
+async function run_lint_parallel_checks(options = COLD_RUN) {
+  return await run_lint_checks(project_prettier_args(), ESLINT_ARGS, ESLINT_CACHE_FILE, options);
+}
+async function run_whole_lint_checks(scope_line, shard) {
+  process.stdout.write(`${scope_line}${lint_shard.describe(shard)}
+`);
+  return await run_timed_lint_checks(
+    prettier_args_of(shard),
+    eslint_args_of(shard),
+    ESLINT_CACHE_FILE
+  );
+}
+async function run_changed_lint_checks(shard) {
+  const root = await changed_file_scope.repository_root_or_cwd();
+  const files = await changed_file_scope.read_changed_files(root);
+  const scope = lint_gate_scope.resolve_gate_scope(files, root, process.env);
+  const scope_line = lint_gate_scope.describe_scope(scope, root);
+  if (scope.mode === "all") return await run_whole_lint_checks(scope_line, shard);
+  process.stdout.write(`${scope_line}
+`);
+  const narrowed = lint_gate_scope.narrowed_run(scope.files);
+  return await run_timed_lint_checks(narrowed.prettier, narrowed.eslint, narrowed.eslint_cache_file);
+}
+async function run_lint_command(command_arguments) {
+  const shard = lint_shard.shard_of(command_arguments);
+  if (command_arguments.includes(lint_gate_scope.CHANGED_FLAG)) {
+    return await run_changed_lint_checks(shard);
+  }
+  return await run_lint_checks(prettier_args_of(shard), eslint_args_of(shard), ESLINT_CACHE_FILE);
+}
+var lint_parallel = {
+  run_eslint,
+  run_lint_checks,
+  run_lint_command,
+  run_lint_parallel_checks
+};
+
+export {
+  lint_parallel
+};