@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/chunk-EK327QOS.js

@@ -0,0 +1,260 @@
+import {
+  lint_timing
+} from "./chunk-WN7NK3NY.js";
+import {
+  lane_cache_run
+} from "./chunk-UZAU6UI6.js";
+import {
+  eslint_cache_dependencies
+} from "./chunk-4DVM57T7.js";
+import {
+  eslint_daemon
+} from "./chunk-VFJYOAOQ.js";
+import {
+  verification_inputs
+} from "./chunk-REMKUFAC.js";
+import {
+  lint_related_scope
+} from "./chunk-VGHSZLYQ.js";
+import {
+  changed_file_scope
+} from "./chunk-7LJQMM2K.js";
+import {
+  lint_shard
+} from "./chunk-ZECFKW7D.js";
+import {
+  project_checks
+} from "./chunk-RK4HE5NW.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-UIWAMLQH.js";
+import {
+  FAIL_EXIT_CODE,
+  buffered_process
+} from "./chunk-D5TAR6TV.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
+};

package/dist/commands/chunk-EKCKCX5S.js

@@ -0,0 +1,291 @@
+import {
+  lane_yield
+} from "./chunk-EH3LVYOX.js";
+import {
+  lane_stage_stats
+} from "./chunk-HOSZITJM.js";
+import {
+  run_ship_planned
+} from "./chunk-ESQEEL4O.js";
+import {
+  lane_sleep,
+  lane_stats
+} from "./chunk-QS5USD4T.js";
+import {
+  lane_ledger
+} from "./chunk-XYAK53TK.js";
+import {
+  lane_spans
+} from "./chunk-34LAULSC.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import {
+  run_ship_stage
+} from "./chunk-OHNP3QL2.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-stop-stats.ts
+var COLUMNS = [
+  "stop",
+  "wait median (min)",
+  "wait max (min)",
+  "wait total (min)",
+  "runs",
+  "not resumed",
+  "causes"
+];
+var { STAGE } = run_ship_stage;
+var { is_dispatch, is_number, is_stage } = lane_stage_stats;
+var REASONS = [
+  STAGE.PREFLIGHT,
+  STAGE.REVIEW,
+  STAGE.SYNC,
+  run_ship_stage.CONFLICT,
+  STAGE.GATE,
+  STAGE.COMMIT,
+  STAGE.ROUND_TWO,
+  STAGE.FOLLOWUP,
+  STAGE.REPORT
+];
+var EVENT_ISSUE = /#([1-9]\d*)\b/u;
+var UNRECORDED_CAUSE = "unrecorded";
+var NO_CAUSES = "-";
+var NOTICED = " (noticed)";
+function is_stop(entry) {
+  return entry.kind === lane_ledger.KIND.STOP;
+}
+function issue_of(event) {
+  return Number(EVENT_ISSUE.exec(event.text)?.[1]);
+}
+function events_of(events, kind) {
+  return events.filter((event) => event.kind === kind).map((event) => ({ issue: issue_of(event), at_ms: Date.parse(event.at) }));
+}
+function parks_of(events) {
+  return events_of(events, run_event_stream.EVENT_KIND.PARK);
+}
+function dispatches_of(entries) {
+  return entries.filter((entry) => is_dispatch(entry)).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+}
+function ends_of(entries, parks) {
+  const resumes = entries.filter((entry) => is_stage(entry)).map((stage) => ({ issue: stage.issue, at_ms: lane_stage_stats.started_ms(stage) }));
+  return [...resumes, ...dispatches_of(entries), ...parks];
+}
+function wait_ms(stop, ends) {
+  const later = ends.filter((end) => end.issue === stop.issue && end.at_ms >= stop.at_ms).map((end) => end.at_ms - stop.at_ms);
+  return later.length === 0 ? void 0 : Math.min(...later);
+}
+function instant_of(stop) {
+  return { issue: stop.issue, at_ms: Date.parse(stop.at) };
+}
+function notices_of(entries) {
+  return entries.filter((entry) => entry.kind === lane_ledger.KIND.UNPLANNED_NOTICE).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+}
+function noticed(cause, stop, notices) {
+  if (cause !== run_ship_planned.PRECONDITION) return cause;
+  const is_noticed = notices.some(
+    (notice) => notice.issue === stop.issue && notice.at_ms <= stop.at_ms
+  );
+  return is_noticed ? `${cause}${NOTICED}` : cause;
+}
+function causes_of(stop, notices) {
+  const { preconditions = [], findings = [] } = stop;
+  const kinds = [...preconditions, ...findings];
+  if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE];
+  return kinds.map((kind) => noticed(kind, instant_of(stop), notices));
+}
+function waits_of(entries, ends, notices) {
+  return entries.filter(is_stop).map((stop) => ({
+    reason: stop.reason,
+    causes: causes_of(stop, notices),
+    wait_ms: wait_ms(instant_of(stop), ends)
+  }));
+}
+function total(values) {
+  return values.length === 0 ? void 0 : values.reduce((sum, value) => sum + value, 0);
+}
+function causes_cell(waits2) {
+  const all = waits2.flatMap((wait) => wait.causes);
+  const counted = [...new Set(all)].map((cause) => ({
+    cause,
+    count: all.filter((each) => each === cause).length
+  }));
+  const ranked = counted.toSorted((left, right) => right.count - left.count);
+  return ranked.length === 0 ? NO_CAUSES : ranked.map(({ cause, count }) => `${cause} ${String(count)}`).join(", ");
+}
+function reason_row(reason, waits2) {
+  const of_reason = waits2.filter((wait) => wait.reason === reason);
+  const ended = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value));
+  return lane_stats.to_row([
+    reason,
+    lane_stage_stats.cell(lane_stats.median(ended)),
+    lane_stage_stats.cell(lane_stats.peak(ended)),
+    lane_stage_stats.cell(total(ended)),
+    String(ended.length),
+    String(of_reason.length - ended.length),
+    causes_cell(of_reason)
+  ]);
+}
+function table(entries, window, events = []) {
+  const ends = ends_of(entries, parks_of(events));
+  const waits2 = waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries));
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...REASONS.map((reason) => reason_row(reason, waits2))
+  ].join("\n");
+}
+var lane_stop_stats = { REASONS, dispatches_of, ends_of, events_of, issue_of, table, wait_ms };
+
+// scripts/lane/lane-net-time.ts
+var { EVENT_KIND } = run_event_stream;
+var { PHASE, STAGE: STAGE2 } = run_ship_stage;
+function entries_of(entries, issue) {
+  return entries.filter((entry) => "issue" in entry && entry.issue === issue);
+}
+function span_of(entries, issue) {
+  const of_issue = entries_of(entries, issue);
+  const from = of_issue.find((entry) => lane_stage_stats.is_dispatch(entry));
+  const to = of_issue.findLast((entry) => lane_stage_stats.is_merge(entry));
+  if (from === void 0 || to === void 0) return void 0;
+  const span = { from_ms: Date.parse(from.at), to_ms: Date.parse(to.at) };
+  return span.to_ms < span.from_ms ? void 0 : span;
+}
+function holds_of(events) {
+  return [
+    ...lane_stop_stats.events_of(events, EVENT_KIND.PARK),
+    ...lane_stop_stats.events_of(events, EVENT_KIND.OUTAGE),
+    ...lane_stop_stats.events_of(events, EVENT_KIND.USAGE_LIMIT)
+  ];
+}
+function held_ms(hold, ends, to_ms) {
+  const left_ms = to_ms - hold.at_ms;
+  return Math.min(lane_stop_stats.wait_ms(hold, ends) ?? left_ms, left_ms);
+}
+function hold_waits(entries, events, issue, span) {
+  const holds = holds_of(events);
+  const inside = holds.filter(
+    (hold) => hold.issue === issue && hold.at_ms >= span.from_ms && hold.at_ms < span.to_ms
+  );
+  return inside.map((hold) => {
+    const ends = lane_stop_stats.ends_of(
+      entries,
+      holds.filter((other) => other.at_ms > hold.at_ms)
+    );
+    return { from_ms: hold.at_ms, to_ms: hold.at_ms + held_ms(hold, ends, span.to_ms) };
+  });
+}
+function joined(spans) {
+  const sorted = spans.toSorted((left, right) => left.from_ms - right.from_ms);
+  const kept = [];
+  for (const next of sorted) {
+    const last = kept.at(-1);
+    if (last === void 0 || next.from_ms > last.to_ms) kept.push({ ...next });
+    else last.to_ms = Math.max(last.to_ms, next.to_ms);
+  }
+  return kept;
+}
+function slept(events, span) {
+  const cut = lane_sleep.spans(events).map((sleep) => ({
+    from_ms: Math.max(sleep.from_ms, span.from_ms),
+    to_ms: Math.min(sleep.to_ms, span.to_ms)
+  }));
+  return joined(cut.filter((sleep) => sleep.to_ms > sleep.from_ms));
+}
+function yield_spans(entries, events) {
+  const yields = lane_stop_stats.events_of(
+    events.filter((event) => lane_yield.is_yield_note(event)),
+    EVENT_KIND.NOTE
+  );
+  return lane_spans.issue_spans({
+    starts: yields,
+    bounds: yields,
+    ends: lane_stop_stats.dispatches_of(entries)
+  });
+}
+function run_start_ms(dispatches, split) {
+  const start = dispatches.findLast(
+    (entry) => entry.issue === split.issue && entry.at_ms <= split.at_ms
+  );
+  return start?.at_ms ?? split.at_ms;
+}
+function split_spans(entries, events) {
+  const splits = lane_stop_stats.events_of(events, EVENT_KIND.SPLIT);
+  const dispatches = lane_stop_stats.dispatches_of(entries);
+  const spans = lane_spans.issue_spans({ starts: splits, bounds: splits, ends: dispatches });
+  return splits.map((split, index) => ({
+    from_ms: run_start_ms(dispatches, split),
+    end_ms: spans[index]?.end_ms
+  })).filter((wait) => wait.end_ms !== void 0);
+}
+function cut_inside(spans, span) {
+  const inside = spans.filter((wait) => wait.from_ms >= span.from_ms && wait.from_ms < span.to_ms);
+  return inside.map((wait) => ({
+    from_ms: wait.from_ms,
+    to_ms: Math.min(wait.end_ms ?? span.to_ms, span.to_ms)
+  }));
+}
+function events_of_issue(events, issue) {
+  return events.filter((event) => lane_stop_stats.issue_of(event) === issue);
+}
+function yielded(entries, events, issue, span) {
+  return cut_inside(yield_spans(entries, events_of_issue(events, issue)), span);
+}
+function split_waits(entries, events, issue, span) {
+  return cut_inside(split_spans(entries, events_of_issue(events, issue)), span);
+}
+function waits(entries, events, issue, span) {
+  return joined([
+    ...hold_waits(entries, events, issue, span),
+    ...yielded(entries, events, issue, span),
+    ...split_waits(entries, events, issue, span),
+    ...slept(events, span)
+  ]);
+}
+function is_followup_start(event) {
+  const { stage, phase } = run_ship_stage.words_of(event.text);
+  return stage === STAGE2.FOLLOWUP && phase === PHASE.START;
+}
+function followed(events, issue, span) {
+  const lines = events.filter((event) => event.kind === EVENT_KIND.SHIP_STAGE).filter((event) => lane_stop_stats.issue_of(event) === issue).map((event) => ({ event, at_ms: Date.parse(event.at) })).filter((line) => line.at_ms >= span.from_ms && line.at_ms < span.to_ms).toSorted((left, right) => left.at_ms - right.at_ms);
+  return lines.map((line, index) => ({ line, to_ms: lines[index + 1]?.at_ms ?? span.to_ms })).filter(({ line }) => is_followup_start(line.event)).map(({ line, to_ms }) => ({ from_ms: line.at_ms, to_ms }));
+}
+function outside(entries, events, issue, span) {
+  return joined([...waits(entries, events, issue, span), ...followed(events, issue, span)]);
+}
+function net_ms(entries, events, issue) {
+  const span = span_of(entries, issue);
+  if (span === void 0) return void 0;
+  return outside(entries, events, issue, span).reduce(
+    (left, wait) => left - (wait.to_ms - wait.from_ms),
+    span.to_ms - span.from_ms
+  );
+}
+function net_minutes(entries, events, issue) {
+  const net = net_ms(entries, events, issue);
+  return net === void 0 ? void 0 : Math.ceil(net / MS_PER_MINUTE);
+}
+function missing_reason(entries, issue) {
+  const of_issue = entries_of(entries, issue);
+  if (of_issue.every((entry) => !lane_stage_stats.is_dispatch(entry))) return "no dispatch";
+  if (of_issue.every((entry) => !lane_stage_stats.is_merge(entry))) return "no merge";
+  return "cause unknown";
+}
+var lane_net_time = {
+  missing_reason,
+  net_minutes,
+  net_ms,
+  outside,
+  slept,
+  span_of,
+  waits,
+  yield_spans,
+  yielded
+};
+
+export {
+  lane_stop_stats,
+  lane_net_time
+};

package/dist/commands/chunk-ELWNRE6E.js

@@ -0,0 +1,93 @@
+import {
+  issue_rank
+} from "./chunk-HLKAFSN4.js";
+import {
+  size_estimate
+} from "./chunk-7ZECP3J6.js";
+import {
+  expected_effect_lint
+} from "./chunk-IZVM2TTH.js";
+import {
+  issue_priority
+} from "./chunk-BPSJSHYD.js";
+import {
+  git_gh_command
+} from "./chunk-RX5JSPPH.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  NOT_DIRECTLY_RUNNABLE_LABELS,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-X7PN54LZ.js";
+import {
+  parse_json_array_safe
+} from "./chunk-XDF25GSU.js";
+
+// scripts/issue/git-next-issues.ts
+var FETCH_LIMIT = 20;
+var DISPLAY_LIMIT = 5;
+var HEADER = "\u{1F5D2} Next issues (oldest first on ties):";
+function has_excluded_label(issue) {
+  return has_any_label(issue.labels, NOT_DIRECTLY_RUNNABLE_LABELS);
+}
+function is_candidate(issue, completed_issue_number) {
+  return issue.number !== completed_issue_number && !has_excluded_label(issue);
+}
+function compare_oldest_first(first, second) {
+  if (first.createdAt === second.createdAt) return first.number - second.number;
+  return first.createdAt < second.createdAt ? -1 : 1;
+}
+function dependency_row(issue) {
+  return {
+    key: String(issue.number),
+    blockers: (issue.blockedBy?.nodes ?? []).map((blocker) => String(blocker.number))
+  };
+}
+function order(issues, completed_issue_number) {
+  const candidates = issues.filter((issue) => is_candidate(issue, completed_issue_number)).toSorted(compare_oldest_first);
+  const dependents = issue_rank.count_dependents(candidates.map((issue) => dependency_row(issue)));
+  return issue_rank.rank(candidates, (issue) => ({
+    is_last: issue_priority.is_last(issue.body),
+    labels: (issue.labels ?? []).map((label) => label.name),
+    lost_minutes: issue_priority.lost_minutes(issue.body),
+    gain_minutes: expected_effect_lint.weekly_minutes(issue.body),
+    dependents: dependents.get(String(issue.number)) ?? 0,
+    estimated_lines: size_estimate.declared_size(issue.body ?? "")?.lines
+  }));
+}
+function prioritize(issues, completed_issue_number) {
+  return order(issues, completed_issue_number).slice(0, DISPLAY_LIMIT);
+}
+function format_lines(issues) {
+  if (issues.length === 0) return [];
+  const rows = issues.map(
+    (issue, index) => `  ${String(index + 1)}. ${session_cite.issue(issue.number, issue.title)}`
+  );
+  return [HEADER, ...rows];
+}
+async function fetch_next_issue_lines(completed_issue_number) {
+  try {
+    const { json } = await git_gh_command.issue_list_recent(FETCH_LIMIT);
+    if (json === void 0) return [];
+    return format_lines(
+      prioritize(parse_json_array_safe(json, open_issue_schema), completed_issue_number)
+    );
+  } catch {
+    return [];
+  }
+}
+var git_next_issues = {
+  DISPLAY_LIMIT,
+  order,
+  prioritize,
+  format_lines,
+  fetch_next_issue_lines
+};
+
+export {
+  git_next_issues
+};

package/dist/commands/chunk-ENFPR7J2.js

@@ -0,0 +1,53 @@
+// scripts/gate/core-weights.ts
+var MEASURED = {
+  lint: { cpu_s: 16.9, wall_s: 14 },
+  type_check: { cpu_s: 31.2, wall_s: 27.3 },
+  spell_check: { cpu_s: 5.7, wall_s: 6.2 },
+  eslint_scan: { cpu_s: 113, wall_s: 98 },
+  format: { cpu_s: 2.1, wall_s: 1.7 },
+  retrospective: { cpu_s: 16.5, wall_s: 19.8 },
+  install: { cpu_s: 1.9, wall_s: 6.1 }
+};
+function rounded_up(measurement) {
+  return Math.ceil(measurement.cpu_s / measurement.wall_s);
+}
+var CORE_WEIGHTS = {
+  lint: rounded_up(MEASURED.lint),
+  type_check: rounded_up(MEASURED.type_check),
+  spell_check: rounded_up(MEASURED.spell_check),
+  eslint_scan: rounded_up(MEASURED.eslint_scan),
+  format: rounded_up(MEASURED.format),
+  retrospective: rounded_up(MEASURED.retrospective),
+  install: rounded_up(MEASURED.install),
+  e2e: 2
+};
+var ESLINT_HEAP_MIB = 8192;
+var BYTES_PER_MIB = 1048576;
+var BYTES_PER_MB = 1e6;
+var ESLINT_PEAK_MB = Math.ceil(ESLINT_HEAP_MIB * BYTES_PER_MIB / BYTES_PER_MB);
+var MEMORY_MB = {
+  lint: ESLINT_PEAK_MB,
+  metrics: 1900,
+  type_check: 2900,
+  spell_check: 350,
+  eslint_scan: ESLINT_PEAK_MB,
+  unit_worker: 400,
+  format: 300,
+  retrospective: 900,
+  install: 100,
+  e2e: 1800
+};
+var TOOL_MEMORY = {
+  eslint: "lint",
+  tsc: "type_check",
+  cspell: "spell_check",
+  vitest: "unit_worker",
+  prettier: "format",
+  install: "install",
+  playwright: "e2e"
+};
+var core_weights = { CORE_WEIGHTS, ESLINT_HEAP_MIB, MEASURED, MEMORY_MB, TOOL_MEMORY };
+
+export {
+  core_weights
+};