@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-26JL4UU4.js

@@ -0,0 +1,365 @@
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+
+// scripts/run/event/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
+}
+function scope_of(read) {
+  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
+}
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
+}
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.RESTART,
+  KIND.WITHDRAW,
+  KIND.PARK,
+  KIND.HUMAN_REVIEW,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain_for("program", issue)} `);
+}
+function is_own_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue) {
+  return issue_named(event) === issue;
+}
+function is_lane_position(event, issue) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue);
+}
+function since_own_launch(events, issue) {
+  const launch = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue)
+  );
+  return events.slice(launch + 1);
+}
+function is_foreign_event(event, issue, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue);
+  return is_foreign_ship_event(event, issue);
+}
+function last_issue_event(events, scope, issue, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue) : events;
+  const own = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
+  return own.findLast((event) => is_own_ship_event(event, issue));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.HUMAN_REVIEW,
+  KIND.SPLIT,
+  KIND.WITHDRAW
+]);
+function is_merge_owed(events, scope, issue) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue)
+  );
+  return newest?.kind === KIND.CHILD_LAUNCH;
+}
+function is_launch_or_withdrawal(event, issue) {
+  const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.WITHDRAW;
+  return is_kind && names_issue(event, issue);
+}
+function is_withdrawn(events, issue) {
+  const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue));
+  return newest?.kind === KIND.WITHDRAW;
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  is_merge_owed,
+  is_withdrawn,
+  issue_named,
+  last_issue_event,
+  last_scoped_event,
+  moment_of,
+  scope_of,
+  scoped_events,
+  since_own_launch
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+import { statSync } from "node:fs";
+
+// scripts/lane/lane-spans.ts
+function next_start_ms(starts, issue, from_ms) {
+  const later = starts.filter((other) => other.issue === issue && other.at_ms > from_ms);
+  return Math.min(...later.map((other) => other.at_ms));
+}
+function issue_spans(pair) {
+  return pair.starts.map((start) => {
+    const until_ms = next_start_ms(pair.bounds, start.issue, start.at_ms);
+    return {
+      from_ms: start.at_ms,
+      end_ms: pair.ends.find(
+        (end) => end.issue === start.issue && end.at_ms >= start.at_ms && end.at_ms < until_ms
+      )?.at_ms
+    };
+  });
+}
+var lane_spans = { issue_spans };
+
+// scripts/run/board/run-board-lane-time.ts
+var KIND2 = run_event_stream.EVENT_KIND;
+var LAUNCH_KINDS = /* @__PURE__ */ new Set([KIND2.CHILD_LAUNCH, KIND2.RESTART]);
+var OFF_LANE_KINDS = /* @__PURE__ */ new Set([
+  KIND2.MERGE,
+  KIND2.PARK,
+  KIND2.HUMAN_REVIEW,
+  KIND2.WITHDRAW,
+  KIND2.OUTAGE,
+  KIND2.USAGE_LIMIT,
+  KIND2.SPLIT,
+  KIND2.STOP
+]);
+function moments_of(events, kinds) {
+  return events.filter((event) => kinds.has(event.kind)).map((event) => ({
+    issue: Number(run_event_scope.issue_named(event)),
+    at_ms: Date.parse(event.at)
+  }));
+}
+function spans_of(events) {
+  const launches = moments_of(events, LAUNCH_KINDS);
+  const ends = moments_of(events, OFF_LANE_KINDS);
+  const issues = new Set(launches.map((launch) => launch.issue));
+  return new Map(
+    [...issues].map((issue) => {
+      const starts = launches.filter((launch) => launch.issue === issue);
+      return [issue, lane_spans.issue_spans({ starts, bounds: starts, ends })];
+    })
+  );
+}
+function span_ms(span, until_ms, end_ms) {
+  return Math.max(0, Math.min(span.end_ms ?? until_ms, end_ms) - span.from_ms);
+}
+function in_lane_ms(spans, end_ms) {
+  return spans.reduce(
+    (total, span, index) => total + span_ms(span, spans[index + 1]?.from_ms ?? end_ms, end_ms),
+    0
+  );
+}
+function elapsed_of(spans, started_ms, ended_ms) {
+  return spans.length === 0 ? ended_ms - started_ms : in_lane_ms(spans, ended_ms);
+}
+function launched_ms(record) {
+  const launched_at = record?.launched_at;
+  return launched_at === void 0 ? void 0 : Date.parse(launched_at);
+}
+function counted_from(run, started_ms) {
+  return run === void 0 ? started_ms : Date.parse(run.started_at);
+}
+function is_ended(spans) {
+  return spans.at(-1)?.end_ms !== void 0;
+}
+function ending_elapsed(read) {
+  const started_ms = launched_ms(read.record);
+  if (started_ms === void 0) return void 0;
+  const from_ms = counted_from(read.record?.run, started_ms);
+  const spans = (spans_of(read.events).get(read.issue) ?? []).filter(
+    (span) => span.from_ms >= from_ms
+  );
+  return is_ended(spans) ? void 0 : elapsed_of(spans, started_ms, read.ended_ms);
+}
+var run_board_lane_time = {
+  LAUNCH_KINDS,
+  OFF_LANE_KINDS,
+  elapsed_of,
+  ending_elapsed,
+  in_lane_ms,
+  spans_of
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+var UNRESOLVED_STREAM = "Could not resolve the run event stream.";
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
+}
+async function lane_record(issue) {
+  try {
+    return await lane_state.read_state(issue);
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.lane_record", error);
+    return void 0;
+  }
+}
+async function ending_fields(target, event) {
+  const issue = run_event_scope.issue_named(event);
+  if (issue === void 0 || !run_board_lane_time.OFF_LANE_KINDS.has(event.kind)) return {};
+  const elapsed_ms = run_board_lane_time.ending_elapsed({
+    events: run_event_stream.read_events(target),
+    issue: Number(issue),
+    record: await lane_record(issue),
+    ended_ms: Date.parse(event.at)
+  });
+  return elapsed_ms === void 0 ? {} : { elapsed_ms };
+}
+async function append_with(target, event) {
+  return run_event_stream.append_event(target, {
+    ...event,
+    ...await ending_fields(target, event)
+  });
+}
+async function append_at(target, kind, text, at) {
+  return await append_with(target, { kind, text, at: at.toISOString() });
+}
+async function emit(kind, text, at = /* @__PURE__ */ new Date(), fields = {}) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    await append_with(target, { ...fields, kind, text, at: at.toISOString() });
+  } catch {
+  }
+}
+async function fresh_target(kind) {
+  const target = await stream_target();
+  if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return void 0;
+  return target;
+}
+async function emit_once(kind, text, before_append) {
+  try {
+    const target = await fresh_target(kind);
+    if (target === void 0) return false;
+    await before_append?.();
+    return run_event_stream.append(target, kind, text, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since_with(kind, reset_kind, compose) {
+  try {
+    const repository = await run_carry.repository_directory();
+    if (repository === void 0) return void 0;
+    const target = run_event_stream.target_of(repository);
+    if (run_event_stream.has_since(invocation_events(repository, target), kind, reset_kind)) {
+      return void 0;
+    }
+    const text = await compose();
+    return run_event_stream.append(target, kind, text, now_iso()).appended ? text : void 0;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
+    return void 0;
+  }
+}
+async function emit_once_since(kind, text, reset_kind) {
+  const appended = await emit_once_since_with(kind, reset_kind, async () => text);
+  return appended !== void 0;
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+function read_current_events(repository, is_required) {
+  if (repository === void 0) throw new Error(UNRESOLVED_STREAM);
+  const read = run_carry.read_carry(run_carry.carry_path(repository));
+  const scope = run_event_scope.scope_of(read);
+  const events = run_event_stream.read_events(run_event_stream.target_of(repository), is_required);
+  const scoped = run_event_scope.scoped_events(events, scope);
+  if (scoped === void 0) throw new Error("Could not determine the run event scope.");
+  return scoped;
+}
+async function current_events(is_required = false) {
+  try {
+    return read_current_events(await run_carry.repository_directory(), is_required);
+  } catch (error) {
+    if (is_required) throw error;
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
+  } catch {
+    return [];
+  }
+}
+function read_existing_events(target, is_required) {
+  if (is_required && statSync(target, { throwIfNoEntry: false }) === void 0) return [];
+  return run_event_stream.read_events(target, is_required);
+}
+function read_all_events(target, is_required) {
+  if (target === void 0 && is_required) throw new Error(UNRESOLVED_STREAM);
+  return target === void 0 ? [] : read_existing_events(target, is_required);
+}
+async function all_events(is_required = false) {
+  try {
+    const target = await stream_target();
+    return read_all_events(target, is_required);
+  } catch (error) {
+    if (is_required) throw error;
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  all_events,
+  append_at,
+  current_events,
+  emit,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  emit_once_since_with,
+  invocation_or_all_events,
+  stream_target
+};
+
+export {
+  lane_spans,
+  run_event_scope,
+  run_board_lane_time,
+  run_event_stream_emit
+};

package/dist/commands/chunk-2BIVHPCA.js

@@ -0,0 +1,85 @@
+import {
+  git_gh_etag_read
+} from "./chunk-IPS7EBE5.js";
+import {
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/epic/epic-label-age.ts
+import { z } from "zod";
+var STALE_MINUTES = 90;
+var TIMELINE_PAGE = 100;
+var LABELED_EVENT = "labeled";
+var UNPARSED_TIMELINE_MESSAGE = "timeline did not parse";
+var label_schema = z.object({ name: z.string() });
+var timeline_schema = z.array(
+  z.object({
+    event: z.string().nullish(),
+    created_at: z.string().nullish(),
+    label: label_schema.nullish()
+  })
+);
+function parse_events(raw) {
+  const events = json_value.parse_array(raw);
+  if (events === void 0) throw new Error(UNPARSED_TIMELINE_MESSAGE);
+  return events;
+}
+async function read_timeline(path) {
+  return parse_events(await git_gh_etag_read.read_listing(path, TIMELINE_PAGE));
+}
+function is_in_progress_labeling(event) {
+  return event.event === LABELED_EVENT && event.label?.name.toLowerCase() === IN_PROGRESS_LABEL;
+}
+async function read_labeled_at(issue, repo) {
+  try {
+    const path = `${git_gh_api_path.issue_api_path(String(issue), repo)}/timeline?per_page=${String(TIMELINE_PAGE)}`;
+    const events = timeline_schema.parse(await read_timeline(path));
+    const at = events.findLast((event) => is_in_progress_labeling(event))?.created_at;
+    return typeof at === "string" ? { kind: "at", at } : { kind: "absent" };
+  } catch {
+    return { kind: "unread" };
+  }
+}
+function minutes_since(at, now) {
+  return Math.floor((now.getTime() - Date.parse(at)) / MS_PER_MINUTE);
+}
+function is_stale(labeled_at, now) {
+  if (labeled_at.kind === "unread") return false;
+  if (labeled_at.kind === "absent") return true;
+  return minutes_since(labeled_at.at, now) > STALE_MINUTES;
+}
+function age_text(labeled_at, now) {
+  if (labeled_at.kind === "unread") return "label age unread";
+  if (labeled_at.kind === "absent") return `${IN_PROGRESS_LABEL} older than the timeline \u2014 stale`;
+  const stale = is_stale(labeled_at, now) ? " \u2014 stale" : "";
+  return `${IN_PROGRESS_LABEL} for ${String(minutes_since(labeled_at.at, now))} min${stale}`;
+}
+async function read_ages(issues, repo, now) {
+  const ages = await Promise.all(
+    issues.map(async (issue) => {
+      const labeled_at = await read_labeled_at(issue, repo);
+      return [issue, age_text(labeled_at, now)];
+    })
+  );
+  return new Map(ages);
+}
+var epic_label_age = {
+  STALE_MINUTES,
+  read_labeled_at,
+  is_stale,
+  age_text,
+  read_ages
+};
+
+export {
+  epic_label_age
+};

package/dist/commands/chunk-2CKJODCK.js

@@ -0,0 +1,245 @@
+import {
+  unit_worker_share
+} from "./chunk-B73IIRMS.js";
+import {
+  josh_verdict
+} from "./chunk-JTU5A4JI.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  core_weights
+} from "./chunk-ENFPR7J2.js";
+
+// scripts/gate/gate-plan.ts
+import { availableParallelism } from "node:os";
+
+// scripts/gate/gate-checks.ts
+var {
+  BEHAVIOR_LABEL,
+  EXPORTS_LABEL,
+  KEEP_WHOLE_SUITE_FLAG,
+  LINT_LABEL,
+  LOCKFILE_LABEL,
+  METRICS_LABEL,
+  SPELL_CHECK_LABEL,
+  SPELL_CHECK_TARGET,
+  TYPE_CHECK_LABEL,
+  TYPE_CHECK_TARGET,
+  UNIT_LABEL,
+  UNIT_TARGET
+} = gate_labels;
+var STATIC_CHECKS = [
+  // **The lint reads the branch's changed files, not the whole tree** (joshuafolkken/kit#4085), and
+  // falls back to the whole tree in CI and on a changed configuration (`lint-gate-scope.ts`).
+  {
+    label: LINT_LABEL,
+    target: "lint",
+    args: ["--changed"],
+    reserved_cores: core_weights.CORE_WEIGHTS.lint,
+    memory_mb: core_weights.MEMORY_MB.lint
+  },
+  {
+    label: TYPE_CHECK_LABEL,
+    target: TYPE_CHECK_TARGET,
+    reserved_cores: core_weights.CORE_WEIGHTS.type_check,
+    memory_mb: core_weights.MEMORY_MB.type_check
+  },
+  {
+    label: SPELL_CHECK_LABEL,
+    target: SPELL_CHECK_TARGET,
+    reserved_cores: core_weights.CORE_WEIGHTS.spell_check,
+    memory_mb: core_weights.MEMORY_MB.spell_check
+  },
+  { label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
+  // **The unused-member check builds one TypeScript program, as the type check does**, and reserves
+  // what the type check reserves: measured warm at 5.5s of wall for 9.0s of CPU, 1.6 cores rounded up.
+  {
+    label: EXPORTS_LABEL,
+    target: "exports:unused",
+    reserved_cores: core_weights.CORE_WEIGHTS.type_check,
+    is_whole_tree: true
+  },
+  // **The metrics ratchet is kit's own**: it holds kit's repository-wide
+  // totals to the merge-base's. It is the whole-tree eslint scan with only `max-lines` enabled, so it
+  // reserves that scan's weight. It times no startup here: beside the unit suite that reads the load, not josh.
+  {
+    label: METRICS_LABEL,
+    target: METRICS_LABEL,
+    args: ["--no-startup"],
+    reserved_cores: core_weights.CORE_WEIGHTS.eslint_scan,
+    memory_mb: core_weights.MEMORY_MB.metrics,
+    is_kit_only: true,
+    is_whole_tree: true
+  },
+  // The lockfile policy check is network-bound and usually instant: it verifies only when the
+  // lockfile or `pnpm-workspace.yaml` moved from the merge-base (joshuafolkken/kit#4090), so it
+  // reserves no core. Kit's own until a consumer's private-registry entries are known to verify.
+  { label: LOCKFILE_LABEL, target: "lockfile:policy", reserved_cores: 0, is_kit_only: true }
+];
+var GATE_CHECKS = [
+  ...STATIC_CHECKS,
+  { label: UNIT_LABEL, target: UNIT_TARGET, args: [KEEP_WHOLE_SUITE_FLAG], reserved_cores: 0 }
+];
+function select_gate_checks(is_unit_included, is_kit_repository = true, is_whole_tree_included = !is_unit_included) {
+  const checks = is_unit_included ? GATE_CHECKS : STATIC_CHECKS;
+  return checks.filter(
+    (check) => (is_kit_repository || check.is_kit_only !== true) && (is_whole_tree_included || check.is_whole_tree !== true)
+  );
+}
+var LANE_GATE_CHECKS = select_gate_checks(true, true, false);
+function selected_checks(selection) {
+  const { is_unit_included = true, is_kit_repository = true, is_whole_tree_included } = selection;
+  return select_gate_checks(is_unit_included, is_kit_repository, is_whole_tree_included);
+}
+function whole_tree_labels(is_kit_repository = true) {
+  return select_gate_checks(false, is_kit_repository, true).filter((check) => check.is_whole_tree === true).map((check) => check.label);
+}
+function has_unit_check(checks) {
+  return checks.some((check) => check.label === UNIT_LABEL);
+}
+var gate_checks = {
+  GATE_CHECKS,
+  LANE_GATE_CHECKS,
+  STATIC_CHECKS,
+  has_unit_check,
+  select_gate_checks,
+  selected_checks,
+  whole_tree_labels
+};
+
+// scripts/gate/gate-plan.ts
+var { GATE_CHECKS: GATE_CHECKS2, LANE_GATE_CHECKS: LANE_GATE_CHECKS2, STATIC_CHECKS: STATIC_CHECKS2, has_unit_check: has_unit_check2, select_gate_checks: select_gate_checks2 } = gate_checks;
+var { selected_checks: selected_checks2, whole_tree_labels: whole_tree_labels2 } = gate_checks;
+var { UNIT_LABEL: UNIT_LABEL2 } = gate_labels;
+var RESERVED_CORES = select_gate_checks2(false, true, false).reduce(
+  (total, check) => total + check.reserved_cores,
+  0
+);
+var MEASURED_CORES = 11;
+var MIN_CONCURRENCY = 1;
+var MIN_SHARED_CORES = 1;
+function lightest_first(items, reserved_cores_of) {
+  return items.toSorted((left, right) => reserved_cores_of(left) - reserved_cores_of(right));
+}
+function shared_cores(available_cores, concurrent_runs) {
+  const runs = Number.isFinite(concurrent_runs) ? Math.max(unit_worker_share.SOLO_RUNS, concurrent_runs) : unit_worker_share.SOLO_RUNS;
+  return Math.max(MIN_SHARED_CORES, Math.floor(available_cores / runs));
+}
+function resolve_concurrency(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS, checks = LANE_GATE_CHECKS2) {
+  const share = shared_cores(available_cores, concurrent_runs);
+  const ordered = lightest_first(checks, (check) => check.reserved_cores);
+  let admitted = 0;
+  let reserved = 0;
+  for (const check of ordered) {
+    reserved += check.reserved_cores;
+    if (reserved > share) break;
+    admitted += 1;
+  }
+  return Math.max(MIN_CONCURRENCY, admitted);
+}
+function resolve_unit_worker_cap(available_cores, concurrent_runs = unit_worker_share.SOLO_RUNS) {
+  const share = unit_worker_share.resolve_unit_workers(available_cores, concurrent_runs);
+  if (share !== void 0) return share;
+  if (available_cores < MEASURED_CORES) return void 0;
+  return available_cores - RESERVED_CORES;
+}
+function solo_unit_weight(available_cores) {
+  return Math.max(0, available_cores - RESERVED_CORES);
+}
+function check_weight(check, plan, available_cores) {
+  if (check.label !== UNIT_LABEL2) return check.reserved_cores;
+  return plan.unit_worker_cap ?? solo_unit_weight(available_cores);
+}
+function unit_memory(workers) {
+  return workers * core_weights.MEMORY_MB.unit_worker;
+}
+function check_memory(check, plan, available_cores) {
+  if (check.label !== UNIT_LABEL2) return check.memory_mb ?? 0;
+  return unit_memory(check_weight(check, plan, available_cores));
+}
+function direct_solo_workers(available_cores) {
+  const vitest_default = available_cores - unit_worker_share.MAIN_PROCESS_CORES;
+  const floor = Math.min(vitest_default, solo_unit_weight(MEASURED_CORES));
+  return Math.max(solo_unit_weight(available_cores), floor);
+}
+function direct_unit_weight(available_cores = availableParallelism(), live_runs = unit_worker_share.live_run_count(), live_lanes = unit_worker_share.live_lane_count()) {
+  const workers = unit_worker_share.current_share(available_cores, live_runs, void 0, live_lanes) ?? direct_solo_workers(available_cores);
+  return Math.max(unit_worker_share.MIN_WORKERS, workers) + unit_worker_share.MAIN_PROCESS_CORES;
+}
+var FILES_PER_WORKER = 285;
+function scoped_unit_weight(files, available_cores = availableParallelism(), live_runs = unit_worker_share.live_run_count(), live_lanes = unit_worker_share.live_lane_count()) {
+  const { MAIN_PROCESS_CORES, MIN_WORKERS } = unit_worker_share;
+  const share = direct_unit_weight(available_cores, live_runs, live_lanes) - MAIN_PROCESS_CORES;
+  const wanted = Math.max(MIN_WORKERS, Math.ceil(files / FILES_PER_WORKER));
+  return Math.min(wanted, share) + MAIN_PROCESS_CORES;
+}
+function direct_unit_memory() {
+  return unit_memory(direct_unit_weight());
+}
+var DIRECT_UNIT_CLAIM = {
+  core_weight: direct_unit_weight,
+  memory_mb: direct_unit_memory,
+  is_unit_claim: true
+};
+function unit_cap_for(checks, available_cores, concurrent_runs) {
+  if (!has_unit_check2(checks)) return void 0;
+  return resolve_unit_worker_cap(available_cores, concurrent_runs);
+}
+function plan_of(concurrency, unit_worker_cap, checks = LANE_GATE_CHECKS2) {
+  return { checks, concurrency, unit_worker_cap };
+}
+function resolve_gate_plan(available_cores = availableParallelism(), concurrent_runs = unit_worker_share.SOLO_RUNS, selection = {}) {
+  const checks = selected_checks2(selection);
+  return {
+    checks,
+    concurrency: resolve_concurrency(available_cores, concurrent_runs, checks),
+    unit_worker_cap: unit_cap_for(checks, available_cores, concurrent_runs)
+  };
+}
+function format_machine(available_cores, concurrent_runs) {
+  const cores = `${String(available_cores)} cores`;
+  if (concurrent_runs <= unit_worker_share.SOLO_RUNS) return cores;
+  return `${cores}, ${String(concurrent_runs)} unit runs or lanes`;
+}
+function format_unit_cap(plan) {
+  if (!has_unit_check2(plan.checks)) return `${UNIT_LABEL2} elsewhere`;
+  if (plan.unit_worker_cap === void 0) return `${UNIT_LABEL2} unrestricted`;
+  return `${UNIT_LABEL2} at ${String(plan.unit_worker_cap)} workers`;
+}
+function format_gate_plan(plan, available_cores = availableParallelism(), concurrent_runs = unit_worker_share.SOLO_RUNS) {
+  const cap = format_unit_cap(plan);
+  const count = `${String(plan.concurrency)} of ${String(plan.checks.length)}`;
+  const width = `${count}${josh_verdict.GATE_OPENING_MARK}`;
+  const machine = format_machine(available_cores, concurrent_runs);
+  return `${josh_verdict.GATE_OPENING_PREFIX}${width}, ${cap} (${machine})`;
+}
+var gate_plan = {
+  DIRECT_UNIT_CLAIM,
+  FILES_PER_WORKER,
+  GATE_CHECKS: GATE_CHECKS2,
+  LANE_GATE_CHECKS: LANE_GATE_CHECKS2,
+  MEASURED_CORES,
+  RESERVED_CORES,
+  STATIC_CHECKS: STATIC_CHECKS2,
+  check_memory,
+  check_weight,
+  direct_unit_weight,
+  format_gate_plan,
+  format_machine,
+  has_unit_check: has_unit_check2,
+  lightest_first,
+  plan_of,
+  resolve_concurrency,
+  resolve_gate_plan,
+  resolve_unit_worker_cap,
+  scoped_unit_weight,
+  select_gate_checks: select_gate_checks2,
+  unit_memory,
+  whole_tree_labels: whole_tree_labels2
+};
+
+export {
+  gate_checks,
+  gate_plan
+};