@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-TXXEXJAV.js

@@ -0,0 +1,390 @@
+import {
+  vitest_failure_summary
+} from "./chunk-GDP7QXYE.js";
+import {
+  test_read_map,
+  test_read_trace
+} from "./chunk-ZDP6SKBK.js";
+import {
+  changed_file_scope
+} from "./chunk-MEJ2CQK2.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  project_checks
+} from "./chunk-23TWJOAI.js";
+import {
+  SKIP_MARKER
+} from "./chunk-IW6NWCSN.js";
+import {
+  core_admission,
+  core_budget,
+  held_mark
+} from "./chunk-TWI7UTVE.js";
+import {
+  machine_capacity
+} from "./chunk-XDR2BRDL.js";
+import {
+  unit_worker_share
+} from "./chunk-MTPFNRYF.js";
+import {
+  PROJECT_ENVIRONMENT_KEYS
+} from "./chunk-IGD6QJPH.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  core_weights
+} from "./chunk-ENFPR7J2.js";
+import {
+  direct_launch
+} from "./chunk-SVV4U5AR.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.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 live_runs = unit_worker_share.live_run_count();
+  const live_lanes = unit_worker_share.live_lane_count();
+  const claim = core_budget.held_unit_claim();
+  const reading = await free_cores.read({ available_cores });
+  const free = unit_worker_share.admitted_capacity(reading, claim, live_runs, live_lanes);
+  const share = unit_worker_share.current_share(available_cores, live_runs, free, live_lanes);
+  return unit_worker_share.cap_to_claim(share, 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
+};