@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-KPMAJP6D.js

@@ -0,0 +1,145 @@
+import {
+  run_step_section_table
+} from "./chunk-JSJDIEGZ.js";
+import {
+  entry_read_set
+} from "./chunk-LNQOL2CL.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+
+// scripts/document/read-set-trim.ts
+function subtract(left, right) {
+  return { bytes: left.bytes - right.bytes, tokens: left.tokens - right.tokens };
+}
+function skill_text(root) {
+  const path = entry_read_set.document_path(root, entry_read_set.SKILL_FILE);
+  return document_section.read_optional(path) ?? "";
+}
+function section_cost(text, heading) {
+  return entry_read_set.cost_of(document_section.section(text, heading)?.text ?? "");
+}
+function unused_skill_cost(root, sections) {
+  const text = skill_text(root);
+  return entry_read_set.total(sections.map((heading) => section_cost(text, heading)));
+}
+function reduce_skill(file, saving) {
+  if (file.file !== entry_read_set.SKILL_FILE) return file;
+  return { file: file.file, cost: subtract(file.cost, saving) };
+}
+var HEADING_JOINER = '" + "';
+function printed_cost(root, row, printed) {
+  const printed_headings = printed.filter((one) => one.file === row.file).map((one) => one.heading);
+  if (printed_headings.length === 0) return row;
+  const named = row.heading === "" ? [] : row.heading.split(HEADING_JOINER);
+  const headings = [.../* @__PURE__ */ new Set([...named, ...printed_headings])];
+  const text = document_section.read_optional(entry_read_set.document_path(root, row.file)) ?? "";
+  return {
+    file: row.file,
+    heading: headings.join(HEADING_JOINER),
+    cost: entry_read_set.total(headings.map((heading) => section_cost(text, heading))),
+    is_resolved: headings.every((heading) => document_section.section(text, heading) !== void 0)
+  };
+}
+function point_of_use_rows(root, base, spec) {
+  return base.point_of_use.filter((one) => !spec.skipped_point_of_use.has(one.file)).map((one) => printed_cost(root, one, spec.printed_sections ?? []));
+}
+function costed(root, spec) {
+  const base = entry_read_set.costed(root, spec.base_entry, spec.reached_point_of_use);
+  const saving = unused_skill_cost(root, spec.unused_skill_sections);
+  return {
+    ...base,
+    entry: spec.label,
+    files: base.files.map((file) => reduce_skill(file, saving)),
+    point_of_use: point_of_use_rows(root, base, spec),
+    whole: subtract(base.whole, saving),
+    scoped: subtract(base.scoped, saving)
+  };
+}
+var read_set_trim = { costed };
+
+// scripts/document/lane-child-read-set.ts
+var LANE_CHILD = "lane-child";
+var SKIPPED_POINT_OF_USE = /* @__PURE__ */ new Set([
+  "backlogrun-child.md",
+  "backlogrun-lanes.md",
+  "backlogrun-progress.md",
+  "backlogrun-steps.md",
+  "delegation.md",
+  "issue-scout.md",
+  "latest-gate.md",
+  "progress-watcher.md",
+  "retrospective.md"
+]);
+var REACHED_POINT_OF_USE = /* @__PURE__ */ new Set(["backlogrun-park.md", "pre-gate-cut.md"]);
+function printed_sections() {
+  const rows = [
+    run_step_section_table.CUT,
+    run_step_section_table.RESUME,
+    run_step_section_table.ENTRY
+  ].map((key) => run_step_section_table.GOVERNING_SECTIONS.get(key));
+  return rows.filter((found) => found !== void 0).map((found) => ({ file: found.document, heading: found.heading }));
+}
+function costed2(root) {
+  return read_set_trim.costed(root, {
+    base_entry: LANE_CHILD,
+    label: LANE_CHILD,
+    unused_skill_sections: [],
+    skipped_point_of_use: SKIPPED_POINT_OF_USE,
+    reached_point_of_use: REACHED_POINT_OF_USE,
+    printed_sections: printed_sections()
+  });
+}
+var lane_child_read_set = {
+  LANE_CHILD,
+  REACHED_POINT_OF_USE,
+  SKIPPED_POINT_OF_USE,
+  costed: costed2
+};
+
+// scripts/document/backlogrun-parent-read-set.ts
+var BACKLOGRUN = "backlogrun";
+var UNUSED_SKILL_SECTIONS = [
+  "3. What stays resident, and what is read from here"
+];
+var SKIPPED_POINT_OF_USE2 = /* @__PURE__ */ new Set([
+  "background-commands.md",
+  "chain-rule.md",
+  "fullrun.md"
+]);
+var PARENT_STEP_KEYS = [
+  "backlog:next",
+  "run:merge",
+  "run:carry",
+  run_step_section_table.PROGRESS,
+  run_step_section_table.RETROSPECTIVE
+];
+function printed_sections2() {
+  return PARENT_STEP_KEYS.map((key) => run_step_section_table.GOVERNING_SECTIONS.get(key)).filter((found) => found !== void 0).map((found) => ({ file: found.document, heading: found.heading }));
+}
+var REACHED_POINT_OF_USE2 = /* @__PURE__ */ new Set([
+  "retrospective.md",
+  "backlogrun-recovery.md"
+]);
+function costed3(root) {
+  return read_set_trim.costed(root, {
+    base_entry: BACKLOGRUN,
+    label: BACKLOGRUN,
+    unused_skill_sections: UNUSED_SKILL_SECTIONS,
+    skipped_point_of_use: SKIPPED_POINT_OF_USE2,
+    reached_point_of_use: REACHED_POINT_OF_USE2,
+    printed_sections: printed_sections2()
+  });
+}
+var backlogrun_parent_read_set = {
+  BACKLOGRUN,
+  REACHED_POINT_OF_USE: REACHED_POINT_OF_USE2,
+  UNUSED_SKILL_SECTIONS,
+  costed: costed3,
+  printed_sections: printed_sections2
+};
+
+export {
+  lane_child_read_set,
+  backlogrun_parent_read_set
+};

package/dist/commands/chunk-KR6WUAJM.js

@@ -0,0 +1,122 @@
+import {
+  backlog_drive_restore
+} from "./chunk-SQZZHK6X.js";
+import {
+  lane_await
+} from "./chunk-5Y7FOJLX.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN
+} from "./chunk-DHJRFBKO.js";
+import {
+  issue_state
+} from "./chunk-WXXLJQBO.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/lane/lane-spent.ts
+var STATE_FIELD = "state";
+var CLOSED_STATE = "CLOSED";
+async function read_issue_state(issue) {
+  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELD);
+  return json === void 0 ? void 0 : issue_state.parse_issue_state(json)?.state;
+}
+async function read_unpushed_commits(branch) {
+  try {
+    return await git_command.commit_count_unpushed(branch);
+  } catch {
+    return void 0;
+  }
+}
+async function read_in_flight() {
+  return backlog_drive_restore.active_issues(await run_event_stream_emit.current_events());
+}
+var LIVE_PROBES = {
+  process_trace: lane_await.process_trace_default,
+  issue_state: read_issue_state,
+  in_flight: read_in_flight,
+  is_tree_dirty: run_hold.is_tree_dirty,
+  unpushed_commits: read_unpushed_commits
+};
+function trace_of(lane, probes) {
+  return lane.is_stranded ? PROCESS_NONE : probes.process_trace(lane.issue);
+}
+async function child_reason(lane, probes) {
+  const trace = probes.process_trace(lane.issue);
+  if (trace === PROCESS_NONE) return void 0;
+  return trace === PROCESS_ALIVE ? "a child is still working in it" : "whether a child is working in it could not be read";
+}
+async function issue_reason(lane, probes) {
+  const state = await probes.issue_state(lane.issue);
+  if (state === CLOSED_STATE) return void 0;
+  return state === void 0 ? "its issue could not be read" : "its issue is still open";
+}
+async function run_reason(lane, probes) {
+  const in_flight = await probes.in_flight();
+  return in_flight.has(lane.issue) ? "the running backlogrun has not collected it yet (`pnpm josh run:merge` does)" : void 0;
+}
+async function tree_reason(lane, probes) {
+  return await probes.is_tree_dirty(lane.directory) ? "it has uncommitted changes" : void 0;
+}
+async function commit_reason(lane, probes) {
+  const count = await probes.unpushed_commits(lane.branch);
+  if (count === 0) return void 0;
+  return count === void 0 ? "its commits could not be counted" : `it has ${String(count)} commit(s) that are on no remote`;
+}
+var CHECKS = [
+  child_reason,
+  issue_reason,
+  run_reason,
+  tree_reason,
+  commit_reason
+];
+async function kept_reason(lane, probes = LIVE_PROBES) {
+  const reasons = await Promise.all(CHECKS.map(async (check) => await check(lane, probes)));
+  return reasons.find((reason) => reason !== void 0);
+}
+async function sort_lanes(lanes, probes = LIVE_PROBES) {
+  const live = lanes.filter((lane) => !lane.is_stranded);
+  const reasons = await Promise.all(live.map(async (lane) => await kept_reason(lane, probes)));
+  const sorted = { spent: [], kept: [] };
+  for (const [index, lane] of live.entries()) {
+    const reason = reasons[index];
+    if (reason === void 0) sorted.spent.push(lane);
+    else sorted.kept.push({ issue: lane.issue, reason });
+  }
+  return sorted;
+}
+function issues_traced(traced, trace) {
+  return traced.filter(([, answer]) => answer === trace).map(([issue]) => issue);
+}
+function traced_of(lanes, probes) {
+  return lanes.map((lane) => [lane.issue, trace_of(lane, probes)]);
+}
+async function lanes_in_use(probes = LIVE_PROBES) {
+  const traced = traced_of(await lane_registry.list_lanes(), probes);
+  return {
+    working: issues_traced(traced, PROCESS_ALIVE),
+    unread: issues_traced(traced, PROCESS_UNKNOWN)
+  };
+}
+function idle_lanes(lanes, probes = LIVE_PROBES) {
+  return issues_traced(traced_of(lanes, probes), PROCESS_NONE);
+}
+var lane_spent = { idle_lanes, kept_reason, lanes_in_use, read_unpushed_commits, sort_lanes };
+
+export {
+  lane_spent
+};

package/dist/commands/chunk-KWLNK2NJ.js

@@ -0,0 +1,391 @@
+import {
+  vitest_failure_summary
+} from "./chunk-GDP7QXYE.js";
+import {
+  test_read_map,
+  test_read_trace
+} from "./chunk-B2PJEV3S.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  changed_file_scope
+} from "./chunk-QX2EMUXV.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  core_admission,
+  core_budget,
+  held_mark
+} from "./chunk-ZCHZU6NX.js";
+import {
+  machine_capacity
+} from "./chunk-XDR2BRDL.js";
+import {
+  unit_worker_share
+} from "./chunk-B73IIRMS.js";
+import {
+  PROJECT_ENVIRONMENT_KEYS
+} from "./chunk-IGD6QJPH.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  core_weights
+} from "./chunk-ENFPR7J2.js";
+import {
+  direct_launch
+} from "./chunk-SVV4U5AR.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/test-unit-guard.ts
+import { existsSync, globSync } from "node:fs";
+import { availableParallelism as availableParallelism2 } from "node:os";
+import path2 from "node:path";
+
+// scripts/gate/free-cores.ts
+import { availableParallelism } from "node:os";
+function running_claims(directory) {
+  const own = held_mark.held_reservation();
+  return core_budget.live_reservations(directory).filter((entry) => entry.key !== own);
+}
+function free_of(reading, options) {
+  if (reading.busy_cores === void 0) return void 0;
+  const ledger = core_admission.ledger_load(running_claims(options.directory), Date.now());
+  return machine_capacity.machine_budget(
+    options.available_cores ?? availableParallelism(),
+    reading,
+    ledger
+  ).cores;
+}
+function workers_in_memory(available_mb) {
+  if (available_mb === void 0) return void 0;
+  return available_mb / core_weights.MEMORY_MB.unit_worker;
+}
+async function read(options = {}) {
+  const reading = await (options.read_machine ?? machine_capacity.read_machine)();
+  return {
+    cores: free_of(reading, options),
+    memory_workers: workers_in_memory(reading.available_mb)
+  };
+}
+var free_cores = { read };
+
+// scripts/test/test-unit-guard.ts
+import { execa as execa2 } from "execa";
+
+// scripts/test/project-test-script.ts
+import { execa } from "execa";
+var PNPM = "pnpm";
+var SCRIPT_NAME = "test";
+var FAIL_EXIT_CODE = 1;
+var INIT_PLACEHOLDER = 'echo "Error: no test specified" && exit 1';
+var REENTRY_KEY = "JOSH_PROJECT_TEST_SCRIPT";
+var REENTRY_VALUE = "1";
+var EMPTY_COMMANDS = /* @__PURE__ */ new Set(["", INIT_PLACEHOLDER]);
+function field_of(value, key) {
+  return json_value.is_record(value) ? value[key] : void 0;
+}
+function declared_script(project_directory) {
+  const manifest = project_checks.read_manifest(project_directory);
+  const script = field_of(field_of(manifest, "scripts"), SCRIPT_NAME);
+  if (typeof script !== "string") return void 0;
+  const command = script.trim();
+  return EMPTY_COMMANDS.has(command) ? void 0 : command;
+}
+function state(project_directory, environment = process.env) {
+  if (declared_script(project_directory) === void 0) return "absent";
+  return environment[REENTRY_KEY] === REENTRY_VALUE ? "reentrant" : "declared";
+}
+async function run(project_directory, command_label) {
+  console.info(
+    `josh ${command_label}: vitest is not installed \u2014 running the project's own test script (${PNPM} run ${SCRIPT_NAME}).`
+  );
+  const result = await execa(PNPM, ["run", SCRIPT_NAME], {
+    cwd: project_checks.project_root(project_directory),
+    env: { [REENTRY_KEY]: REENTRY_VALUE },
+    stdio: "inherit",
+    reject: false
+  });
+  return result.exitCode ?? FAIL_EXIT_CODE;
+}
+var project_test_script = { INIT_PLACEHOLDER, REENTRY_KEY, declared_script, state, run };
+
+// scripts/test/test-read-recording.ts
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var RUN_SUBCOMMAND = "run";
+var WORKER_FLAG_PREFIX = "--maxWorkers";
+var RECORD_DIRECTORY_PREFIX = "josh-test-reads-";
+function is_recordable(vitest_arguments) {
+  const [subcommand, ...flags] = vitest_arguments;
+  return subcommand === RUN_SUBCOMMAND && flags.every((flag) => flag.startsWith(WORKER_FLAG_PREFIX));
+}
+async function commit_directories(commit) {
+  const output = await git_spawn.read(["ls-tree", "-r", "-d", "--name-only", "-z", commit]);
+  return output.split("\0").filter((listed) => listed.length > 0);
+}
+async function own_change() {
+  try {
+    return await changed_paths.read_changed_paths(false);
+  } catch {
+    return [];
+  }
+}
+async function tree_snapshot(root) {
+  const commit = await git_command.head_commit();
+  const dirty = input_fingerprint.of_files(root, await changed_paths.read_changed_since(commit));
+  const change = await own_change();
+  return { commit, dirty, change, directories: await commit_directories(commit) };
+}
+function save_map(root, directory, snapshot) {
+  try {
+    const readers = test_read_map.merge_records(test_read_map.collect_records(directory));
+    test_read_map.write_map(root, { version: test_read_map.MAP_VERSION, ...snapshot, readers });
+  } catch {
+  }
+}
+async function with_read_recording(root, vitest_arguments, run2) {
+  if (!is_recordable(vitest_arguments)) return await run2({});
+  const directory = mkdtempSync(path.join(tmpdir(), RECORD_DIRECTORY_PREFIX));
+  try {
+    const [tree] = await Promise.allSettled([tree_snapshot(root)]);
+    const exit_code = await run2({
+      [test_read_trace.RECORD_DIRECTORY_KEY]: directory,
+      [test_read_trace.ROOT_KEY]: root
+    });
+    if (exit_code === 0 && tree.status === "fulfilled") save_map(root, directory, tree.value);
+    return exit_code;
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+var test_read_recording = { is_recordable, with_read_recording };
+
+// scripts/test/unit-update-arguments.ts
+var UPDATE_VALUES = {
+  all: true,
+  new: true,
+  none: true,
+  true: true,
+  false: true
+};
+var UPDATE_FLAGS = /* @__PURE__ */ new Set(["-u", "--update"]);
+var OPTION_PREFIX = "-";
+var NOT_FOUND = -1;
+function is_filter_word(value) {
+  if (value === void 0 || value.startsWith(OPTION_PREFIX)) return false;
+  return !Object.hasOwn(UPDATE_VALUES, value);
+}
+function filter_words(vitest_arguments) {
+  const next_option = vitest_arguments.findIndex((argument) => argument.startsWith(OPTION_PREFIX));
+  return next_option === NOT_FOUND ? vitest_arguments : vitest_arguments.slice(0, next_option);
+}
+function filter_flag(vitest_arguments) {
+  const delimiter = vitest_arguments.indexOf("--");
+  const options = delimiter === NOT_FOUND ? vitest_arguments : vitest_arguments.slice(0, delimiter);
+  return options.findIndex(
+    (argument, index) => UPDATE_FLAGS.has(argument) && is_filter_word(options[index + 1])
+  );
+}
+function reorder(vitest_arguments) {
+  const flag_index = filter_flag(vitest_arguments);
+  const value = flag_index === NOT_FOUND ? void 0 : vitest_arguments[flag_index + 1];
+  if (!is_filter_word(value)) return { arguments: vitest_arguments };
+  const filters = filter_words(vitest_arguments.slice(flag_index + 1));
+  const ordered = vitest_arguments.toSpliced(flag_index + 1, filters.length);
+  return {
+    arguments: reorder(ordered.toSpliced(flag_index, 0, ...filters)).arguments,
+    filter: value
+  };
+}
+function notice(filter) {
+  return `moved "${filter}" in front of the update flag \u2014 vitest reads the word after it as the update type, not a file filter.`;
+}
+var unit_update_arguments = {
+  notice,
+  reorder
+};
+
+// scripts/test/test-unit-guard.ts
+var FAIL_EXIT_CODE2 = 1;
+var VITEST_PACKAGE = path2.join("node_modules", "vitest");
+var UNIT_GLOB = "**/*.{test,spec}.{ts,js}";
+var NODE_MODULES = "node_modules";
+var SKIP_ACTION = "skip-missing-package";
+var SKIP_NO_TESTS_ACTION = "skip-no-tests";
+var SKIP_NO_SCRIPT_ACTION = "skip-no-test-script";
+var SKIP_REENTRANT_ACTION = "skip-reentrant";
+var RUN_SCRIPT_ACTION = "run-project-script";
+var FAIL_ACTION = "fail-no-tests";
+var VITEST_SUBJECT = "vitest unit tests";
+var UNIT_SUBJECT = "unit tests";
+var SKIP_NOTICES = {
+  [SKIP_ACTION]: { reason: "vitest is not installed", subject: VITEST_SUBJECT },
+  [SKIP_NO_TESTS_ACTION]: {
+    reason: "no unit test files were found in this basic project",
+    subject: VITEST_SUBJECT
+  },
+  [SKIP_NO_SCRIPT_ACTION]: {
+    reason: "vitest is not installed and package.json declares no test script",
+    subject: UNIT_SUBJECT
+  },
+  [SKIP_REENTRANT_ACTION]: {
+    reason: "the project's test script called back into this check",
+    subject: UNIT_SUBJECT
+  }
+};
+var FAIL_REASON = "vitest is installed but no *.{test,spec}.{ts,js} test file was found \u2014 refusing to report a unit check that ran nothing";
+var BASIC_MISSING_PACKAGE_ACTIONS = {
+  declared: RUN_SCRIPT_ACTION,
+  absent: SKIP_NO_SCRIPT_ACTION,
+  reentrant: SKIP_REENTRANT_ACTION
+};
+function resolve_installed_action(has_tests, is_basic) {
+  if (has_tests) return "run";
+  return is_basic ? SKIP_NO_TESTS_ACTION : FAIL_ACTION;
+}
+function resolve_guard_action(is_installed, has_tests, is_basic = false, script_state = "absent") {
+  if (is_installed) return resolve_installed_action(has_tests, is_basic);
+  return is_basic ? BASIC_MISSING_PACKAGE_ACTIONS[script_state] : SKIP_ACTION;
+}
+function is_vitest_installed(project_directory) {
+  return existsSync(path2.join(project_directory, VITEST_PACKAGE));
+}
+function is_in_node_modules(entry) {
+  return entry.split(/[/\\]/u).includes(NODE_MODULES);
+}
+function has_unit_tests(project_directory) {
+  const matches = globSync(UNIT_GLOB, {
+    cwd: project_directory,
+    exclude: is_in_node_modules
+  });
+  return matches.length > 0;
+}
+function guard_action(project_directory) {
+  return resolve_guard_action(
+    is_vitest_installed(project_directory),
+    has_unit_tests(project_directory),
+    project_checks.is_basic(project_directory),
+    project_test_script.state(project_directory)
+  );
+}
+function is_skip_action(action) {
+  return Object.hasOwn(SKIP_NOTICES, action);
+}
+function is_skipping(project_directory) {
+  return is_skip_action(guard_action(project_directory));
+}
+function is_running(project_directory) {
+  const action = guard_action(project_directory);
+  return action === "run" || action === RUN_SCRIPT_ACTION;
+}
+function isolated_unit_environment(environment = process.env) {
+  const isolated = { ...environment };
+  for (const key of PROJECT_ENVIRONMENT_KEYS) Reflect.deleteProperty(isolated, key);
+  return isolated;
+}
+async function vitest_share(vitest_arguments) {
+  if (unit_worker_share.has_worker_flag(vitest_arguments)) return void 0;
+  const available_cores = availableParallelism2();
+  const free = await free_cores.read({ available_cores });
+  const share = unit_worker_share.current_share(
+    available_cores,
+    unit_worker_share.live_run_count(),
+    free,
+    unit_worker_share.live_lane_count()
+  );
+  return unit_worker_share.cap_to_claim(share, core_budget.held_unit_claim());
+}
+async function execute_vitest(vitest_arguments, recording, directory) {
+  const launch = direct_launch(directory, ["exec", "vitest", ...vitest_arguments]);
+  const result = await execa2(launch.file, [...launch.args], {
+    cwd: directory,
+    env: { ...isolated_unit_environment(), ...recording },
+    extendEnv: false,
+    stdin: "inherit",
+    stdout: ["inherit", "pipe"],
+    stderr: ["inherit", "pipe"],
+    all: true,
+    reject: false
+  });
+  const exit_code = result.exitCode ?? FAIL_EXIT_CODE2;
+  vitest_failure_summary.report(vitest_arguments, result.all, exit_code);
+  return exit_code;
+}
+async function run_vitest(vitest_arguments, directory = process.cwd()) {
+  return await unit_worker_share.with_run_marker(async () => {
+    const sized = [
+      ...vitest_arguments,
+      ...unit_worker_share.worker_arguments(vitest_arguments, await vitest_share(vitest_arguments))
+    ];
+    const root = await changed_file_scope.repository_root_or_cwd();
+    return await test_read_recording.with_read_recording(
+      root,
+      sized,
+      async (recording) => await execute_vitest(sized, recording, directory)
+    );
+  });
+}
+async function run_vitest_in(directory, vitest_arguments) {
+  return await run_vitest(vitest_arguments, directory);
+}
+var UNIT_COMMAND_LABEL = "test:unit";
+function report_no_run(action, command_label) {
+  if (action === FAIL_ACTION) {
+    console.error(`josh ${command_label}: ${FAIL_REASON}.`);
+    return FAIL_EXIT_CODE2;
+  }
+  const { reason, subject } = SKIP_NOTICES[action];
+  console.info(`josh ${command_label}: ${reason} ${SKIP_MARKER} ${subject}.`);
+  return 0;
+}
+async function run_guarded_vitest(project_directory, vitest_arguments, command_label = UNIT_COMMAND_LABEL, announcement) {
+  const action = guard_action(project_directory);
+  if (action === RUN_SCRIPT_ACTION) {
+    return await project_test_script.run(project_directory, command_label);
+  }
+  if (action !== "run") return report_no_run(action, command_label);
+  if (announcement !== void 0) process.stdout.write(`${announcement}
+`);
+  return await run_vitest(vitest_arguments);
+}
+async function run_guarded_unit(project_directory, extra_arguments) {
+  const { arguments: ordered, filter } = unit_update_arguments.reorder(extra_arguments);
+  if (filter !== void 0) {
+    console.info(`josh ${UNIT_COMMAND_LABEL}: ${unit_update_arguments.notice(filter)}`);
+  }
+  return await run_guarded_vitest(project_directory, ["run", ...ordered]);
+}
+var test_unit_guard = {
+  SKIP_MARKER,
+  guard_action,
+  is_skipping,
+  is_running,
+  resolve_guard_action,
+  is_vitest_installed,
+  has_unit_tests,
+  isolated_unit_environment,
+  run_guarded_unit,
+  run_guarded_vitest,
+  run_vitest_in,
+  vitest_share
+};
+
+export {
+  free_cores,
+  test_unit_guard
+};