@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-B545ENGY.js

@@ -0,0 +1,214 @@
+import {
+  lane_vacant
+} from "./chunk-YOZTZMAT.js";
+import {
+  lane_dispatch_dependency
+} from "./chunk-NDQIJBRQ.js";
+import {
+  josh_command
+} from "./chunk-47J4KOZP.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  core_budget,
+  core_wait
+} from "./chunk-ZCHZU6NX.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  INSTALL_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-launch-cli.ts
+import { execa } from "execa";
+
+// scripts/lane/lane-launch-admission.ts
+var LANE_MEMORY_MB = 470;
+function checkout_of(issue) {
+  const cwd = process.cwd();
+  const root = core_wait.where_of(cwd).lanes_root ?? lane_paths.lane_root(cwd);
+  return lane_paths.lane_directory(root, issue);
+}
+function options_of(issue) {
+  return {
+    memory_mb: LANE_MEMORY_MB,
+    is_strict_admission: true,
+    is_memory_pending: true,
+    command: "lane:launch",
+    checkout: checkout_of(issue)
+  };
+}
+async function run_reserved(context, run2, handle) {
+  let is_retained = false;
+  try {
+    const outcome = await run2(context);
+    if (outcome.kind === "launched") {
+      core_budget.transfer(handle, Number(outcome.pid));
+      is_retained = true;
+    }
+    return outcome;
+  } finally {
+    if (!is_retained) core_budget.release(handle);
+  }
+}
+async function launch(context, run2) {
+  const handle = await core_budget.reserve(0, options_of(context.issue));
+  return await run_reserved(context, run2, handle);
+}
+var lane_launch_admission = { launch, options_of, run_reserved };
+
+// scripts/lane/lane-launch-pending.ts
+var pending = /* @__PURE__ */ new Map();
+function keep(issues) {
+  for (const [issue, claim] of pending) {
+    if (issues.includes(issue)) continue;
+    core_budget.release(claim);
+    pending.delete(issue);
+  }
+}
+function claim_for(issue) {
+  const claim = pending.get(issue) ?? core_budget.claim(0, lane_launch_admission.options_of(issue));
+  pending.set(issue, claim);
+  return claim;
+}
+async function launch2(context, run2) {
+  const handle = await core_budget.poll_claim(claim_for(context.issue));
+  if (handle === void 0) return { kind: "waiting" };
+  pending.delete(context.issue);
+  return await lane_launch_admission.run_reserved(context, run2, handle);
+}
+var lane_launch_pending = { keep, launch: launch2 };
+
+// scripts/lane/lane-launch-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var should_forward_stderr = true;
+var PNPM = "pnpm";
+var USAGE = "Usage: josh lane:launch <issue-number> [--stash <message>]";
+var OPTIONS = { stash: { type: "string" } };
+var PREPARED = { code: SUCCESS_EXIT_CODE, out: "" };
+function read_context(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const [issue, ...rest] = parsed.positionals;
+  if (issue === void 0 || rest.length > 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) {
+    return void 0;
+  }
+  return { issue, stash: parsed.values.stash };
+}
+function failure_detail(result) {
+  const detail = (result.err ?? "").trim() || result.out.trim();
+  return detail === "" ? void 0 : detail;
+}
+function refused(kind, result) {
+  const detail = failure_detail(result);
+  return detail === void 0 ? { kind } : { kind, detail };
+}
+async function install(directory) {
+  const result = await execa(PNPM, ["--dir", directory, "install", "--frozen-lockfile"], {
+    reject: false,
+    timeout: INSTALL_TIMEOUT_MS
+  });
+  const installed = {
+    code: result.exitCode ?? FAILURE_EXIT_CODE,
+    out: result.stdout,
+    err: result.stderr
+  };
+  if (installed.code !== SUCCESS_EXIT_CODE) console.error(failure_detail(installed) ?? "");
+  return installed;
+}
+async function prepare(context, directory) {
+  const { issue, stash } = context;
+  if (stash === void 0) return PREPARED;
+  const popped = await josh_command.josh_run(
+    ["stash:pop", stash, "--dir", directory],
+    should_forward_stderr
+  );
+  if (popped.code !== SUCCESS_EXIT_CODE) return popped;
+  await run_event_setup.emit(run_event_setup.installing(issue));
+  return await run_startup.phase("dependency reinstall", async () => await install(directory), {
+    edge_of: (value) => value.code === SUCCESS_EXIT_CODE ? "done" : "failed"
+  });
+}
+async function close_if_vacant(lane) {
+  if (lane === void 0 || !await lane_vacant.is_vacant(lane)) return;
+  await josh_command.josh_run(["lane:close", lane.issue], should_forward_stderr);
+}
+async function lane_directory(issue) {
+  const kept = await lane_registry.find_open_lane(issue);
+  if (kept?.output !== void 0) return { code: SUCCESS_EXIT_CODE, out: kept.directory };
+  await close_if_vacant(kept);
+  return await josh_command.josh_run(["lane:open", issue], should_forward_stderr);
+}
+function dispatch_edge(value) {
+  if (value.code === lane_dispatch_dependency.WAIT_EXIT_CODE) return "waiting";
+  return value.code === SUCCESS_EXIT_CODE ? "done" : "failed";
+}
+async function dispatch(context) {
+  await run_event_setup.emit(run_event_setup.dispatching(context.issue));
+  const dispatched = await run_startup.phase(
+    "worker dispatch",
+    async () => await josh_command.josh_run(["lane:dispatch", context.issue], should_forward_stderr),
+    { edge_of: dispatch_edge }
+  );
+  if (dispatched.code === lane_dispatch_dependency.WAIT_EXIT_CODE) {
+    await close_if_vacant(await lane_registry.find_open_lane(context.issue));
+    return { kind: "waiting" };
+  }
+  if (dispatched.code !== SUCCESS_EXIT_CODE) return refused("failed", dispatched);
+  return { kind: "launched", pid: dispatched.out };
+}
+async function launch_admitted(context) {
+  const opened = await run_startup.phase(
+    "lane creation",
+    async () => await lane_directory(context.issue),
+    { edge_of: (value) => value.code === SUCCESS_EXIT_CODE ? "done" : "failed" }
+  );
+  if (opened.code !== SUCCESS_EXIT_CODE) return refused("unopened", opened);
+  const prepared = await prepare(context, opened.out);
+  if (prepared.code !== SUCCESS_EXIT_CODE) return refused("failed", prepared);
+  return await dispatch(context);
+}
+async function launch_lane(context) {
+  return await lane_launch_admission.launch(context, launch_admitted);
+}
+async function launch_ready_lane(context) {
+  return await lane_launch_pending.launch(context, launch_admitted);
+}
+async function launch3(context) {
+  const outcome = await launch_lane(context);
+  if (outcome.kind !== "launched") return FAILURE_EXIT_CODE;
+  console.info(outcome.pid);
+  return SUCCESS_EXIT_CODE;
+}
+async function run(argv) {
+  const context = read_context(argv);
+  if (context === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await launch3(context);
+}
+var lane_launch_cli = {
+  keep_pending: lane_launch_pending.keep,
+  launch_lane,
+  launch_ready_lane,
+  read_context,
+  run
+};
+
+export {
+  lane_launch_cli
+};

package/dist/commands/chunk-B5HP6T4L.js

@@ -0,0 +1,170 @@
+import {
+  git_utilities
+} from "./chunk-B5GXZK3E.js";
+import {
+  GIT_TIMEOUT_MS,
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/git/git-spawn.ts
+import { execa as execa3 } from "execa";
+
+// scripts/git/git-execa-error.ts
+function get_exit_code(error) {
+  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
+  const { exitCode: exit_code } = error;
+  return typeof exit_code === "number" ? exit_code : void 0;
+}
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+var TIMEOUT_EXIT_CODE = "timeout";
+function create_spawn_error(command, exit_code) {
+  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
+  const error_message = `git ${command} exited with code ${exit_code_string}`;
+  return new Error(error_message, { cause: { exit_code: exit_code_string } });
+}
+
+// scripts/git/git-push-transport.ts
+import { execa as execa2 } from "execa";
+
+// scripts/git/git-ssh-keepalive.ts
+import { execa } from "execa";
+var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
+var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
+var SSH_LEGACY_VARIABLE = "GIT_SSH";
+var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
+var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
+var CONFIG_PROBE_ARGUMENTS = ["config", "--get", SSH_COMMAND_CONFIG_KEY];
+var PROBE_OPTIONS = { timeout: PROBE_TIMEOUT_MS };
+function to_environment_value(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function to_configured_ssh_command() {
+  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
+  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
+}
+async function has_configured_ssh_command() {
+  if (to_configured_ssh_command() !== "") return true;
+  try {
+    const git_command_bin = git_utilities.get_git_command_for_spawn();
+    const { stdout } = await execa(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
+    return stdout.trim() !== "";
+  } catch (error) {
+    return has_timed_out(error);
+  }
+}
+async function to_environment() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
+}
+var git_ssh_keepalive = {
+  to_environment
+};
+
+// scripts/git/git-push-transport.ts
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_SUBCOMMAND = "push";
+async function to_push_options() {
+  return {
+    stdio: "inherit",
+    timeout: PUSH_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  };
+}
+async function did_push_time_out(arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const options = await to_push_options();
+  try {
+    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    return false;
+  } catch (error) {
+    if (has_timed_out(error)) return true;
+    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
+  }
+}
+function to_manual_command(arguments_list) {
+  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
+}
+function to_retry_notice(arguments_list) {
+  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
+}
+function create_timeout_error(arguments_list) {
+  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
+  return new Error(message, { cause: { exit_code: TIMEOUT_EXIT_CODE } });
+}
+async function push(arguments_list) {
+  if (!await did_push_time_out(arguments_list)) return;
+  console.warn(to_retry_notice(arguments_list));
+  if (!await did_push_time_out(arguments_list)) return;
+  throw create_timeout_error(arguments_list);
+}
+var git_push_transport = {
+  push
+};
+
+// scripts/git/git-spawn.ts
+async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
+  return stdout.trimEnd();
+}
+var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
+function to_budget_error(command, error, timeout_ms) {
+  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
+  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND));
+  return new Error(`git ${command} timed out after ${seconds}s`, {
+    cause: { exit_code: TIMEOUT_EXIT_CODE }
+  });
+}
+async function spawn_remote(arguments_, options) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  try {
+    const { stdout } = await execa3(git_cmd, arguments_, options);
+    return typeof stdout === "string" ? stdout.trimEnd() : "";
+  } catch (error) {
+    throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
+  }
+}
+async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
+  return await spawn_remote(arguments_, {
+    timeout: timeout_ms,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output_remote(command, arguments_list) {
+  await spawn_remote([command, ...arguments_list], {
+    stdio: "inherit",
+    timeout: REMOTE_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output(command, arguments_list, options = {}) {
+  const { config_options = [], timeout_ms = GIT_TIMEOUT_MS } = options;
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const spawn_arguments = [...config_options, command, ...arguments_list];
+  try {
+    await execa3(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
+  } catch (error) {
+    throw to_budget_error(command, error, timeout_ms);
+  }
+}
+var git_spawn = {
+  read,
+  read_remote,
+  with_output,
+  with_output_remote
+};
+
+export {
+  get_exit_code,
+  has_timed_out,
+  create_spawn_error,
+  git_push_transport,
+  git_spawn
+};

package/dist/commands/chunk-B5XYAWNN.js

@@ -0,0 +1,37 @@
+import {
+  lane_plan_check
+} from "./chunk-TTTZZN7F.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
+};

package/dist/commands/chunk-B73IIRMS.js

@@ -0,0 +1,207 @@
+import {
+  lane_state_record
+} from "./chunk-UUH3DE77.js";
+import {
+  git_directory
+} from "./chunk-3NWAGIA6.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  durable_state_root
+} from "./chunk-5VQCL33M.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  platform_temporary,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/unit-worker-share.ts
+import { availableParallelism } from "node:os";
+
+// scripts/test/unit-lane-count.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+function is_idle_lane(lanes_root, issue, environment) {
+  const common = git_directory.resolve_git_directory(path.join(lanes_root, issue));
+  if (common === void 0) return false;
+  const override = environment[platform_temporary.TEMP_ROOT_KEY];
+  const state_root = durable_state_root.state_root(override, () => common);
+  return lane_state_record.is_idle(state_root, common, issue);
+}
+function own_lane(checkout, environment) {
+  return lane_paths.lane_issue_of(lane_paths.checkout_of(path.resolve(checkout)), environment);
+}
+function live_lane_count(checkout = process.cwd(), environment = process.env) {
+  try {
+    const lanes_root = lane_paths.lanes_root_of(checkout, environment);
+    const own = own_lane(checkout, environment);
+    const issues = readdirSync(lanes_root).filter(
+      (name) => issue_number_shape.ISSUE_NUMBER_PATTERN.test(name)
+    );
+    return issues.filter((issue) => issue === own || !is_idle_lane(lanes_root, issue, environment)).length;
+  } catch {
+    return 0;
+  }
+}
+var unit_lane_count = { live_lane_count };
+
+// scripts/test/unit-run-marker.ts
+import { readdirSync as readdirSync2 } from "node:fs";
+import path2 from "node:path";
+var RUN_PREFIX = "josh-unit-running-";
+var MIN_WORKERS = 1;
+var SOLO_RUNS = 1;
+function marker_path(pid = process.pid) {
+  return stamp_file.stamp_path(RUN_PREFIX, String(pid));
+}
+function is_running(marker) {
+  return process_identity.is_same_process(marker.pid, marker.process_start) !== false;
+}
+function read_marker(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function marker_files(directory = PLATFORM_TEMP_ROOT) {
+  try {
+    return readdirSync2(directory).filter((name) => name.startsWith(RUN_PREFIX));
+  } catch {
+    return [];
+  }
+}
+function sweep_marker(source) {
+  try {
+    stamp_file.remove_stamp(source);
+  } catch {
+  }
+}
+function is_marker_live(source) {
+  const marker = read_marker(source);
+  if (marker === void 0) return false;
+  if (is_running(marker)) return true;
+  sweep_marker(source);
+  return false;
+}
+function live_run_count(directory = PLATFORM_TEMP_ROOT) {
+  return marker_files(directory).filter((name) => is_marker_live(path2.join(directory, name))).length;
+}
+var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
+var NESTED_VALUE = "1";
+function is_nested_run() {
+  return process.env[NESTED_KEY] === NESTED_VALUE;
+}
+function resolve_unit_workers(available_cores, runs) {
+  if (runs <= SOLO_RUNS) return void 0;
+  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs));
+}
+function sharing_runs(runs, lanes) {
+  return Math.max(runs, lanes);
+}
+function mark_run_started(target) {
+  try {
+    stamp_file.write_stamp(target, process_identity.own_fields());
+  } catch {
+  }
+}
+var unit_run_marker = {
+  MIN_WORKERS,
+  NESTED_KEY,
+  NESTED_VALUE,
+  RUN_PREFIX,
+  SOLO_RUNS,
+  is_nested_run,
+  live_run_count,
+  mark_run_started,
+  marker_path,
+  read_marker,
+  resolve_unit_workers,
+  sharing_runs
+};
+
+// scripts/test/unit-worker-share.ts
+var { MIN_WORKERS: MIN_WORKERS2, NESTED_KEY: NESTED_KEY2, NESTED_VALUE: NESTED_VALUE2, SOLO_RUNS: SOLO_RUNS2 } = unit_run_marker;
+var {
+  is_nested_run: is_nested_run2,
+  live_run_count: live_run_count2,
+  mark_run_started: mark_run_started2,
+  marker_path: marker_path2,
+  resolve_unit_workers: resolve_unit_workers2,
+  sharing_runs: sharing_runs2
+} = unit_run_marker;
+var WORKER_FLAG = "--maxWorkers";
+var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
+var MAIN_PROCESS_CORES = 1;
+function cap_to_free(workers, free_cores, available_cores) {
+  if (free_cores === void 0 || free_cores >= (workers ?? available_cores)) return workers;
+  return Math.max(MIN_WORKERS2, Math.floor(free_cores));
+}
+var UNREAD_CAPACITY = { cores: void 0, memory_workers: void 0 };
+function cap_to_capacity(workers, free, available_cores) {
+  const core_capped = cap_to_free(workers, free.cores, available_cores);
+  return cap_to_free(core_capped, free.memory_workers, available_cores);
+}
+function cap_to_claim(share, claim) {
+  if (claim === void 0) return share;
+  const bound = Math.max(MIN_WORKERS2, (claim.granted ?? claim.weight) - MAIN_PROCESS_CORES);
+  return Math.min(share ?? bound, bound);
+}
+function own_run() {
+  return is_nested_run2() ? 0 : SOLO_RUNS2;
+}
+function current_share(available_cores = availableParallelism(), live_runs = live_run_count2(), free = UNREAD_CAPACITY, live_lanes = SOLO_RUNS2) {
+  const share = resolve_unit_workers2(
+    available_cores,
+    sharing_runs2(live_runs + own_run(), live_lanes)
+  );
+  return cap_to_capacity(share, free, available_cores);
+}
+function is_worker_flag(argument) {
+  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
+}
+function has_worker_flag(vitest_arguments) {
+  return vitest_arguments.some((argument) => is_worker_flag(argument));
+}
+function worker_arguments(vitest_arguments, share) {
+  if (share === void 0 || has_worker_flag(vitest_arguments)) return [];
+  return [`${WORKER_FLAG}=${String(share)}`];
+}
+async function with_run_marker(run) {
+  if (is_nested_run2()) return await run();
+  const target = marker_path2();
+  mark_run_started2(target);
+  process.env[NESTED_KEY2] = NESTED_VALUE2;
+  try {
+    return await run();
+  } finally {
+    process.env[NESTED_KEY2] = "";
+    stamp_file.remove_stamp(target);
+  }
+}
+var unit_worker_share = {
+  ...unit_run_marker,
+  ...unit_lane_count,
+  MAIN_PROCESS_CORES,
+  cap_to_capacity,
+  cap_to_claim,
+  cap_to_free,
+  current_share,
+  has_worker_flag,
+  with_run_marker,
+  worker_arguments
+};
+
+export {
+  unit_worker_share
+};