@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-7K5ITPHR.js

@@ -1,338 +0,0 @@
-import {
-  split_resolution
-} from "./chunk-MRAEJLXL.js";
-import {
-  auto_ok_cli
-} from "./chunk-RFIOZTXY.js";
-import {
-  size_estimate
-} from "./chunk-2VY7CJ2R.js";
-import {
-  lane_implement_rate_read
-} from "./chunk-PJYTUUTH.js";
-import {
-  declared_growth,
-  split_assess
-} from "./chunk-ZGEUWHFF.js";
-import {
-  lane_stage_budget
-} from "./chunk-AXXEMVRJ.js";
-import {
-  lane_implement_rate,
-  lane_size_stats
-} from "./chunk-KP2BVAS5.js";
-import {
-  run_ship_planned
-} from "./chunk-PKXTISWR.js";
-import {
-  backlog_overlap,
-  lane_plan,
-  lane_plan_approval
-} from "./chunk-MDGPJOLK.js";
-import {
-  test_related_cap
-} from "./chunk-HQZ65PJE.js";
-import {
-  test_pinned_logic
-} from "./chunk-RAQ3E6OT.js";
-import {
-  lane_stats
-} from "./chunk-2XLR7R6E.js";
-import {
-  lane_ledger
-} from "./chunk-2O64H5UJ.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-import {
-  IN_PROGRESS_LABEL,
-  has_any_label
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  change_base
-} from "./chunk-LBVYFW3I.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-
-// scripts/lane/lane-plan-size.ts
-function declared_of(issue, issues) {
-  const body = issues.find((candidate) => candidate.number === issue)?.body;
-  const size = body === void 0 ? void 0 : size_estimate.declared_size(body);
-  return size === void 0 || size.files === 0 ? void 0 : size;
-}
-function declares(issue, issues) {
-  return declared_of(issue, issues) !== void 0;
-}
-function ratios_of(signals) {
-  return { files: signals.files_ratio, lines: signals.lines_ratio };
-}
-function guide_of(signals) {
-  return split_assess.guide_for(
-    lane_stage_budget.BUDGET_MINUTES.implement,
-    signals.implement_rate,
-    ratios_of(signals)
-  );
-}
-function ordered(counted, recorded) {
-  const held = new Set(recorded);
-  return [...counted.filter((file) => held.has(file)), ...counted.filter((file) => !held.has(file))];
-}
-function units_of(files, signals) {
-  const base = signals.base_files ?? new Set(files);
-  return split_assess.units_of(files, new Set(files.filter((file) => !base.has(file))));
-}
-function files_approved(plan, declared, recorded, measured) {
-  const approval = plan.size_approval ?? recorded?.size_approval;
-  return approval !== void 0 && lane_plan_approval.allows(approval, plan, { reason: "files", declared, measured });
-}
-function is_counted(file) {
-  return split_assess.is_deliverable({ path: file, changed_lines: 0 });
-}
-function files_over(plan, declared, recorded, signals) {
-  const limit = declared * declared_growth.factor(ratios_of(signals), "files");
-  const counted = plan.paths.filter((file) => is_counted(file));
-  const units = units_of(ordered(counted, recorded?.paths ?? []), signals);
-  if (units.length <= limit || files_approved(plan, declared, recorded, units.length)) {
-    return void 0;
-  }
-  const tests = plan.paths.filter((file) => test_declared_logic.is_test_file(file));
-  const kept = counted.filter((file) => units.slice(0, limit).flat().includes(file));
-  const split_off = counted.filter((file) => units.slice(limit).flat().includes(file));
-  return { reason: "files", declared, limit, kept, split_off, tests };
-}
-function earlier_cleared(recorded, signals) {
-  if (recorded?.cleared_paths !== void 0) return recorded.cleared_paths;
-  return recorded?.cleared === true ? signals.committed_files : [];
-}
-function unplanned_hunks(signals, plan, recorded) {
-  const listed = plan.paths.filter((path) => !path.endsWith("/"));
-  const planned = [...listed, ...recorded?.paths ?? [], ...earlier_cleared(recorded, signals)];
-  return run_ship_planned.unplanned_of(planned, signals.hunk_files).length;
-}
-function hunks_over(declared, hunks, signals) {
-  const limit = declared * declared_growth.factor(ratios_of(signals), "files");
-  return hunks > limit ? { reason: "hunks", declared, limit, measured: hunks } : void 0;
-}
-function lines_limit(signals) {
-  const growth = ratios_of(signals);
-  const bar = size_estimate.declared_lines_bar(signals.implement_rate, growth);
-  return bar ?? Math.floor(guide_of(signals).lines / declared_growth.factor(growth, "lines"));
-}
-function lines_over(declared, signals) {
-  const limit = lines_limit(signals);
-  if (declared <= limit) return void 0;
-  const measured = Math.round(declared * declared_growth.factor(ratios_of(signals), "lines"));
-  return { reason: "lines", declared, limit, measured };
-}
-function unapproved(over, plan, approval) {
-  if (over === void 0 || approval === void 0) return over;
-  if (over.reason !== "lines") return over;
-  const is_within = lane_plan_approval.allows(approval, plan, { ...over, reason: over.reason });
-  return is_within ? void 0 : over;
-}
-function planned_lines(declared, signals, plan, recorded) {
-  const approval = plan.size_approval ?? recorded?.size_approval;
-  if (approval === void 0 && lane_plan.is_sized(recorded)) return void 0;
-  return unapproved(lines_over(declared, signals), plan, approval);
-}
-function measure_over(declared, signals, plan, recorded) {
-  if (signals.split_filed) return void 0;
-  const estimated = Math.max(declared.lines, plan.estimated_size?.lines ?? 0);
-  return hunks_over(declared.files, unplanned_hunks(signals, plan, recorded), signals) ?? planned_lines(estimated, signals, plan, recorded);
-}
-function is_waived(plan, over) {
-  return over !== void 0 && (plan.single === true || plan.sized === true);
-}
-function hub_over(signals) {
-  const hubs = signals.hubs ?? [];
-  return hubs.length === 0 ? void 0 : { reason: "hub", limit: test_pinned_logic.MAX_TEST_FILES, hubs };
-}
-function first_over(plan, declared, recorded, signals) {
-  const files = files_over(plan, declared.files, recorded, signals);
-  if (files !== void 0 && !is_waived(plan, files)) return files;
-  return hub_over(signals) ?? measure_over(declared, signals, plan, recorded) ?? files;
-}
-function oversize(plan, issues, recorded, signals) {
-  const declared = declared_of(plan.issue, issues);
-  if (declared === void 0) return void 0;
-  const over = first_over(plan, declared, recorded, signals);
-  return over === void 0 ? void 0 : { ...over, guide: guide_of(signals) };
-}
-function bar_tail() {
-  return `A \`${split_assess.REASON_PREFIX}\` comment does not pass this bar \u2014 split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}".`;
-}
-var SIZE_PREFIX = issue_body_keys.prefix("size");
-function files_text(issue, over) {
-  const planned = [...over.kept, ...over.split_off];
-  const counted = split_assess.units_of(planned, /* @__PURE__ */ new Set()).length;
-  const bar = `${String(counted)} files (tests and generated artifacts excluded), over ${String(over.limit)} \u2014 ${String(over.limit / over.declared)} times the ${String(over.declared)} its \`${SIZE_PREFIX}\` declares`;
-  const replan = ["pnpm josh lane:plan", String(issue), ...over.kept, ...over.tests].join(" ");
-  return `split (files): ${session_cite.issue(issue)}'s plan holds ${bar}, so it is not recorded. Keep in this Issue: ${over.kept.join(", ")}. Split off: ${over.split_off.join(", ")} \u2014 file them as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to them here, run \`${replan}\`, and ship this Issue on the kept files. One deliverable with no separately-mergeable part instead \u2192 run this \`lane:plan\` again with \`--single\`. ${bar_tail()}`;
-}
-function waiver_text(issue, over) {
-  return `size warning (${over.reason}): ${session_cite.issue(issue)}'s plan is past its ${String(over.limit)} bar, recorded and noted on the ledger \u2014 a warning, not a stop; finish this Issue, never split it \u2014 an overrun at the merge is recorded as a pre-split miss (split-assessment.md \u2192 "${split_assess.NOTICE_SECTION}").`;
-}
-function measure_bar(over) {
-  if (over.reason === "hunks") {
-    return `change holds ${String(over.measured)} hunks outside the plan's files (tests excluded), over ${String(over.limit)} \u2014 ${String(over.limit / over.declared)} times the ${String(over.declared)} files its \`${SIZE_PREFIX}\` declares`;
-  }
-  return `\`${SIZE_PREFIX}\` declares ${String(over.declared)} lines, about ${String(over.measured)} at the lines lanes ran over their declaration \u2014 over the ${String(over.limit)} declared lines the size bar allows`;
-}
-function measure_text(issue, over) {
-  return `split (${over.reason}): ${session_cite.issue(issue)}'s ${measure_bar(over)}, so the plan is not recorded. Carve a separately-mergeable part off as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to it here, and run \`pnpm josh lane:plan ${String(issue)} <paths>\` again on what stays. ${bar_tail()}`;
-}
-function hub_text(issue, over) {
-  return `split (hub): ${session_cite.issue(issue)}'s plan edits ${over.hubs.join(", ")}, whose \`test:related\` reach passes the ${String(over.limit)}-test-file cap, so the plan is not recorded. Carve the hub edit off as a follow-up Issue with \`pnpm josh issue:file "<title>" --body-file <body.md> --route split\`, revert any edit to it here, and run \`pnpm josh lane:plan ${String(issue)} <paths>\` again on what stays. The hub edit is the one deliverable instead \u2192 run this \`lane:plan\` again with \`--single\`. ${bar_tail()}`;
-}
-function over_text(issue, over) {
-  if (over.reason === "files") return files_text(issue, over);
-  return over.reason === "hub" ? hub_text(issue, over) : measure_text(issue, over);
-}
-function refusal_text(issue, over) {
-  const text = over_text(issue, over);
-  const guide = over.guide ?? split_assess.guide_for(lane_stage_budget.BUDGET_MINUTES.implement);
-  return `${text} ${split_assess.policy_text(guide)}`;
-}
-var lane_plan_size = { declares, is_waived, oversize, refusal_text, waiver_text };
-
-// scripts/lane/lane-plan-signals.ts
-var RATIO_PERIOD_DAYS = lane_implement_rate_read.PERIOD_DAYS;
-var NAME_ONLY = "--name-only";
-var DIFF_ARGUMENTS = [
-  "diff",
-  "-U0",
-  "--no-color",
-  "--no-ext-diff",
-  "--diff-filter=M",
-  "--src-prefix=a/",
-  "--dst-prefix=b/"
-];
-function hunk_files(diff) {
-  return test_pinned_logic.parse_hunks(diff).map((hunk) => hunk.file);
-}
-var NO_PROBE = { hunk_files: [], committed_files: [] };
-async function read_or_empty(arguments_) {
-  try {
-    return await git_spawn.read(arguments_);
-  } catch {
-    return "";
-  }
-}
-function names_of(output) {
-  return output.split("\n").filter((name) => name !== "");
-}
-async function base_files_of(base) {
-  try {
-    return new Set(names_of(await git_spawn.read(["ls-tree", "-r", NAME_ONLY, base])));
-  } catch {
-    return void 0;
-  }
-}
-async function probe_of(base) {
-  const [diff, committed, base_files] = await Promise.all([
-    read_or_empty([...DIFF_ARGUMENTS, base]),
-    read_or_empty(["diff", NAME_ONLY, `${base}...HEAD`]),
-    base_files_of(base)
-  ]);
-  return { hunk_files: hunk_files(diff), committed_files: names_of(committed), base_files };
-}
-async function tree_of() {
-  const base = await change_base.resolved_through_merge();
-  return base === void 0 ? NO_PROBE : await probe_of(base);
-}
-async function entries_of() {
-  const ledger = await lane_ledger.target();
-  return ledger === void 0 ? [] : lane_ledger.read_entries(ledger);
-}
-function signals_from(issue, tree, entries, now_ms) {
-  const window = lane_stats.window_of(RATIO_PERIOD_DAYS, now_ms);
-  const ratios = lane_size_stats.ratios(entries, window);
-  return {
-    ...tree,
-    files_ratio: ratios.files,
-    lines_ratio: ratios.lines,
-    implement_rate: lane_implement_rate.rate(entries, window),
-    split_filed: split_resolution.split_issues(entries).has(issue)
-  };
-}
-async function hubs_of(paths) {
-  return paths.length === 0 ? [] : await test_related_cap.hubs_of(process.cwd(), paths);
-}
-async function signals_of(issue, paths = []) {
-  const [tree, entries, hubs] = await Promise.all([tree_of(), entries_of(), hubs_of(paths)]);
-  return { ...signals_from(issue, tree, entries, Date.now()), hubs };
-}
-var lane_plan_signals = { hunk_files, signals_from, signals_of };
-
-// scripts/lane/lane-plan-probe.ts
-var RUNNING = /* @__PURE__ */ new Set([IN_PROGRESS_LABEL]);
-var UNREAD = "unread";
-var OVERSIZE = "oversize";
-async function opted_in() {
-  const read = await auto_ok_cli.fetch_opted_in();
-  return read.kind === "read" ? read.issues : void 0;
-}
-function running_of(issues) {
-  return issues.filter((issue) => has_any_label(issue.labels, RUNNING));
-}
-function clash_among(plan, issues, directory) {
-  const declared = lane_plan.with_plans(backlog_overlap.declared_of(issues), directory);
-  return lane_plan.clash_of(plan, declared, directory);
-}
-function overlap_text(issue, clash) {
-  const holder = session_cite.issue(clash.holder);
-  return `${session_cite.issue(issue)}'s planned \`${clash.path}\` overlaps \`${clash.claimed}\`, which ${holder} declares or plans`;
-}
-function probe(plan, issues, directory) {
-  return issues === void 0 ? UNREAD : clash_among(plan, running_of(issues), directory);
-}
-function is_unread(found) {
-  return found === UNREAD;
-}
-function record_cleared(plan, directory) {
-  lane_plan.record(
-    { ...plan, cleared: true, yielded: void 0, waits_until: void 0 },
-    directory
-  );
-}
-async function oversize_of(plan, issues, directory) {
-  if (issues === void 0 || !lane_plan_size.declares(plan.issue, issues)) return void 0;
-  const signals = await lane_plan_signals.signals_of(plan.issue, plan.paths);
-  return lane_plan_size.oversize(plan, issues, lane_plan.read(plan.issue, directory), signals);
-}
-function is_oversize(found) {
-  return found === OVERSIZE;
-}
-async function extend(plan, directory) {
-  const issues = await opted_in();
-  const over = await oversize_of(plan, issues, directory);
-  if (over !== void 0 && !lane_plan_size.is_waived(plan, over)) return OVERSIZE;
-  const found = probe(plan, issues, directory);
-  if (found === void 0) record_cleared(plan, directory);
-  return found;
-}
-var lane_plan_probe = {
-  clash_among,
-  extend,
-  is_oversize,
-  is_unread,
-  opted_in,
-  overlap_text,
-  oversize_of,
-  probe,
-  record_cleared,
-  running_of
-};
-
-export {
-  lane_plan_signals,
-  lane_plan_size,
-  lane_plan_probe
-};

package/dist/commands/chunk-7OEBSPPU.js

@@ -1,321 +0,0 @@
-import {
-  backlog_hold_codes
-} from "./chunk-MXPCEZL5.js";
-import {
-  backlog_next_shared
-} from "./chunk-A3LCN4KA.js";
-import {
-  backlog_wait_cause
-} from "./chunk-N2ZF6T4E.js";
-import {
-  lane_room
-} from "./chunk-AUTD5FV2.js";
-import {
-  lane_capacity
-} from "./chunk-WR73HTRG.js";
-import {
-  epic_triage
-} from "./chunk-VQRT32JB.js";
-import {
-  backlog_drive_restore,
-  backlog_offer_exclude
-} from "./chunk-SQZZHK6X.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  lane_ledger
-} from "./chunk-2O64H5UJ.js";
-import {
-  run_headless
-} from "./chunk-Q4ULMZAS.js";
-import {
-  lane_registry
-} from "./chunk-NEOCCN6D.js";
-import {
-  run_event_scope,
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  run_invocation
-} from "./chunk-DS53UUDH.js";
-import {
-  issue_number_shape
-} from "./chunk-G75GWNNY.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/backlog/backlog-hold-text.ts
-var {
-  DRAINED_REASON,
-  DRIVERLESS_PREFIX,
-  HAND_BACK_PREFIX,
-  MEMORY_REASON,
-  OFFER_PREFIX,
-  REASON_SEPARATOR,
-  USAGE_LIMIT_REASON
-} = backlog_hold_codes;
-var NOT_FOUND = -1;
-var AWAIT_TRIAGE = "open issues await your triage";
-var HAND_BACK_TEXT = /* @__PURE__ */ new Map([
-  ["judge", AWAIT_TRIAGE],
-  ["triage", "a parked issue awaits your triage"],
-  ["merge", "the driver paused after a merge; the session restarts it"],
-  ["launch", "a lane launch failed; the session restarts the driver"],
-  ["offer", "the backlog offer failed; the session restarts the driver"],
-  ["window", "the run's time window closed; the session restarts the driver"],
-  [DRAINED_REASON, "the backlog had nothing to start; the session restarts the driver"]
-]);
-var PERSON_HAND_BACKS = /* @__PURE__ */ new Set(["judge", "triage"]);
-var OFFER_TEXT = /* @__PURE__ */ new Map([
-  ["solo", "a run:solo issue must finish first"],
-  ["blocked", "every queued issue is blocked"],
-  ["exhausted", "the backlog has nothing left to start"],
-  ["untriaged", AWAIT_TRIAGE],
-  ["parked", "parked issues await your decision"],
-  ["unreadable", "the backlog could not be read"]
-]);
-var CAUSE_TEXT = {
-  chain: "other issues",
-  gate: "a start condition",
-  lane: "a running lane"
-};
-var CAUSE_JOINER = " or ";
-var MEMORY_TEXT = "memory pressure is high; lanes resume when it eases";
-var USAGE_LIMIT_TEXT = "the usage limit is reached; lanes resume when it resets";
-var DRIVERLESS_TEXT = "no driver is running";
-function rest_after(code, prefix) {
-  const head = `${prefix}${REASON_SEPARATOR}`;
-  return code.startsWith(head) ? code.slice(head.length) : void 0;
-}
-function hand_back_text(reason) {
-  return HAND_BACK_TEXT.get(reason) ?? `the driver paused (${reason}); the session restarts it`;
-}
-function cause_text(detail) {
-  const causes = backlog_wait_cause.causes_of_tag(detail);
-  if (causes === void 0) return void 0;
-  return `queued issues wait on ${causes.map((cause) => CAUSE_TEXT[cause]).join(CAUSE_JOINER)}`;
-}
-function offer_text(rest) {
-  const index = rest.indexOf(REASON_SEPARATOR);
-  const detail = index === NOT_FOUND ? "" : rest.slice(index + REASON_SEPARATOR.length);
-  return OFFER_TEXT.get(detail) ?? cause_text(detail) ?? `the backlog is waiting (${rest})`;
-}
-function prefixed_text(code) {
-  const hand_back = rest_after(code, HAND_BACK_PREFIX);
-  if (hand_back !== void 0) return hand_back_text(hand_back);
-  const offer = rest_after(code, OFFER_PREFIX);
-  return offer === void 0 ? void 0 : offer_text(offer);
-}
-function whole_text(code) {
-  if (code === MEMORY_REASON) return MEMORY_TEXT;
-  return code === USAGE_LIMIT_REASON ? USAGE_LIMIT_TEXT : void 0;
-}
-function text_of(code) {
-  if (code.startsWith(DRIVERLESS_PREFIX)) {
-    return `${DRIVERLESS_TEXT}; ${text_of(code.slice(DRIVERLESS_PREFIX.length))}`;
-  }
-  return prefixed_text(code) ?? whole_text(code) ?? code;
-}
-function is_driver_restart(code) {
-  const own = code.startsWith(DRIVERLESS_PREFIX) ? code.slice(DRIVERLESS_PREFIX.length) : code;
-  const reason = rest_after(own, HAND_BACK_PREFIX);
-  return reason !== void 0 && !PERSON_HAND_BACKS.has(reason);
-}
-var backlog_hold_text = { is_driver_restart, text_of };
-
-// scripts/backlog/backlog-stalled.ts
-var STALL_THRESHOLD_MINUTES = 10;
-var STALL_THRESHOLD_MS = STALL_THRESHOLD_MINUTES * MS_PER_MINUTE;
-var NONE = 0;
-var STALLED = "stalled";
-var OK = "ok";
-var UNREADABLE = "unreadable";
-function is_stalled(reading, threshold_ms) {
-  return reading.ready_count > NONE && reading.free_lanes > NONE && reading.waiting_ms > threshold_ms;
-}
-function assess(reading, threshold_ms) {
-  if (reading === void 0) return UNREADABLE;
-  if (is_stalled(reading, threshold_ms)) return STALLED;
-  return OK;
-}
-function dispatch_reference_iso(events) {
-  const last_launch = events.findLast(
-    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH
-  );
-  return last_launch?.at ?? events[0]?.at;
-}
-function dispatch_reference_ms(events) {
-  const iso = dispatch_reference_iso(events);
-  const at = iso === void 0 ? NaN : Date.parse(iso);
-  return Number.isNaN(at) ? void 0 : at;
-}
-function dispatch_age_ms(events, now_ms) {
-  const at = dispatch_reference_ms(events);
-  return at === void 0 ? void 0 : now_ms - at;
-}
-function open_offerable_ms(entries, reference_ms) {
-  const newest = entries.findLast(
-    (entry) => entry.kind === lane_ledger.KIND.OFFERABLE && Date.parse(entry.at) >= reference_ms
-  );
-  if (newest?.kind !== lane_ledger.KIND.OFFERABLE || !newest.is_offerable) return void 0;
-  return Date.parse(newest.at);
-}
-function open_hold(entries) {
-  const { HELD, RELEASED, DISPATCH } = lane_ledger.KIND;
-  const hold_kinds = /* @__PURE__ */ new Set([HELD, RELEASED, DISPATCH]);
-  const newest = entries.findLast((entry) => hold_kinds.has(entry.kind));
-  return newest?.kind === lane_ledger.KIND.HELD ? newest.reason : void 0;
-}
-function describe(reading) {
-  const minutes = Math.floor(reading.waiting_ms / MS_PER_MINUTE);
-  const held = reading.hold === void 0 ? "" : ` (${backlog_hold_text.text_of(reading.hold)})`;
-  return `${String(reading.ready_count)} ready, ${String(reading.free_lanes)} free lane(s), ${String(minutes)}m waiting with both${held}`;
-}
-function ready_tokens(out) {
-  return out.split("\n").map((token) => token.trim()).filter((token) => issue_number_shape.is_issue_number(token));
-}
-function count_ready_tokens(out) {
-  return ready_tokens(out).length;
-}
-function needs_triage(out) {
-  return out.split("\n").some((token) => token.trim() === epic_triage.TRIAGE_VERDICT);
-}
-var backlog_stalled = {
-  STALLED,
-  OK,
-  UNREADABLE,
-  STALL_THRESHOLD_MS,
-  assess,
-  count_ready_tokens,
-  describe,
-  dispatch_age_ms,
-  needs_triage,
-  open_hold,
-  open_offerable_ms,
-  ready_tokens
-};
-
-// scripts/backlog/backlog-ready.ts
-var NO_FREE = 0;
-var NONE2 = 0;
-var lane_room2 = lane_room.read;
-async function lane_use(lanes) {
-  const room = await lane_room2(lanes);
-  return room.use;
-}
-function free_of(limit, use) {
-  return lane_capacity.free_lanes(limit, use.occupied, use.seated);
-}
-async function count_in(room) {
-  const limit = await lane_capacity.lane_limit();
-  if (limit.kind !== "limit") return void 0;
-  return { limit: limit.limit, free: free_of(limit.limit, room.use) };
-}
-async function free_lanes_beside(lanes) {
-  const count = await count_in(await lane_room2(lanes));
-  return count?.free;
-}
-async function free_under(limit) {
-  return free_of(limit, await lane_use());
-}
-async function free_lane_count() {
-  return await free_lanes_beside(await lane_registry.list_lanes()) ?? NO_FREE;
-}
-async function drive_limit() {
-  const limit = await lane_capacity.lane_limit();
-  if (limit.kind !== "limit") throw new Error(limit.problem);
-  return limit.limit;
-}
-async function drive_free_lane_count() {
-  return await free_under(await drive_limit());
-}
-async function drive_limit_room() {
-  const limit = await drive_limit();
-  const use = await lane_use();
-  return lane_capacity.limit_room(limit, use.occupied);
-}
-function drains_pool(carry) {
-  return carry === void 0 || !run_invocation.has_only(carry.invocation);
-}
-async function stream_exclude(carry) {
-  const target = await run_event_stream_emit.stream_target();
-  if (target === void 0 || carry === void 0) return [];
-  const scope = run_event_scope.scope_of({ kind: "carried", carry });
-  const events = run_event_scope.scoped_events(run_event_stream.read_events(target), scope) ?? [];
-  return backlog_drive_restore.offer_exclude(events);
-}
-async function read_backlog_next(timeout_ms) {
-  const carry = await run_headless.current_carry();
-  if (!drains_pool(carry)) return void 0;
-  const argv = ["backlog:next", ...backlog_offer_exclude.exclude_argv(await stream_exclude(carry))];
-  return await backlog_next_shared.read(argv, timeout_ms === void 0, timeout_ms);
-}
-async function ready_issues() {
-  const result = await read_backlog_next();
-  return result === void 0 ? [] : backlog_stalled.ready_tokens(result.out);
-}
-var DEFAULT_PORTS = { free_lane_count, ready_issues };
-async function read_ready(ports = DEFAULT_PORTS) {
-  const free_lanes = await ports.free_lane_count();
-  if (free_lanes <= NO_FREE) return { issues: [], free_lanes };
-  return { issues: await ports.ready_issues(), free_lanes };
-}
-function ready_line(reading, slug) {
-  if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
-  const cite = issue_cite.citer(slug, /* @__PURE__ */ new Map());
-  const issues = reading.issues.map((issue) => cite(issue)).join(" ");
-  return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
-}
-async function parent_ready_line(ports, is_parent, read_repo) {
-  if (!await is_parent()) return void 0;
-  const reading = await read_ready(ports);
-  return reading.issues.length === NONE2 ? void 0 : ready_line(reading, await read_repo());
-}
-function print_line(line) {
-  if (line !== void 0) console.info(line);
-}
-async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent, read_repo = git_gh_command.repo_get_name_with_owner) {
-  try {
-    print_line(await parent_ready_line(ports, is_parent, read_repo));
-  } catch {
-  }
-}
-var OFFER_HINT = "\u21BB backlogrun parent: a child just entered an epic \u2014 run `pnpm josh backlog:offer` next, so a runnable filing is dispatched now rather than on the next wake.";
-async function print_offer_hint(is_parent = run_headless.is_backlog_parent) {
-  try {
-    if (await is_parent()) console.info(OFFER_HINT);
-  } catch {
-  }
-}
-var backlog_ready = {
-  DEFAULT_PORTS,
-  OFFER_HINT,
-  read_backlog_next,
-  print_offer_hint,
-  free_lane_count,
-  free_lanes_beside,
-  count_in,
-  lane_room: lane_room2,
-  lane_use,
-  drive_free_lane_count,
-  drive_limit_room,
-  drains_pool,
-  print_ready_line,
-  read_ready,
-  ready_issues,
-  ready_line
-};
-
-export {
-  backlog_hold_text,
-  backlog_stalled,
-  backlog_ready
-};