@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-ZJJLROJY.js

@@ -0,0 +1,269 @@
+import {
+  lane_plan_wait,
+  lane_plan_wait_until
+} from "./chunk-G3BBCAAH.js";
+import {
+  lane_plan_probe,
+  lane_plan_size
+} from "./chunk-7K5ITPHR.js";
+import {
+  trusted_measure
+} from "./chunk-GNTTGRCX.js";
+import {
+  run_hold_cli
+} from "./chunk-YD7XK2TX.js";
+import {
+  backlog_plan_comment
+} from "./chunk-MRW2WYJS.js";
+import {
+  auto_ok_cli
+} from "./chunk-RFIOZTXY.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  lane_plan_wait_event
+} from "./chunk-DDOS32JU.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  backlog_overlap,
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  line_budget
+} from "./chunk-QFIKPGMC.js";
+
+// scripts/lane/lane-plan-check.ts
+import path from "node:path";
+
+// scripts/lane/lane-plan-premise.ts
+function listed_premises(issue, issues) {
+  const listed = issues?.find((candidate) => candidate.number === issue);
+  return listed === void 0 ? void 0 : measure_declaration.premises(listed.body ?? "").length;
+}
+function measured(declaration, run) {
+  if (run.kind === "failed") return { holds: false, value: `failed (${run.message})` };
+  const verdict = measure_declaration.judge(declaration, run.output);
+  const value = "value" in verdict ? String(verdict.value) : verdict.kind;
+  return { holds: verdict.kind === "pass", value };
+}
+function checked(declaration, source) {
+  const result = measured(declaration, trusted_measure.run_command(declaration.command, source));
+  const line = `${measure_declaration.format(declaration)} measured ${result.value}`;
+  console.error(`premise: ${line}`);
+  return result.holds ? void 0 : line;
+}
+async function failed_premises(issue, issues) {
+  const listed = listed_premises(issue, issues);
+  if (listed === 0) return [];
+  const read = await trusted_measure.read_trusted_body(String(issue));
+  if (read.kind === "refused") return listed === void 0 ? [] : [`not re-run: ${read.reason}`];
+  return measure_declaration.premises(read.body).flatMap((declaration) => checked(declaration, read) ?? []);
+}
+async function stop_text(issue, issues) {
+  const failed = await failed_premises(issue, issues);
+  if (failed.length === 0) return void 0;
+  return `premise: ${session_cite.issue(issue)}'s premises do not hold (${failed.join("; ")}), so the lane stops before implementing: park it with these values (backlogrun-park.md \u2192 "park and continue").`;
+}
+var lane_plan_premise = { stop_text };
+
+// scripts/lane/lane-plan-check.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var YIELD_EXIT_CODE = 2;
+var SPLIT_EXIT_CODE = 3;
+var PREMISE_EXIT_CODE = 4;
+var RELEASE_FLAG = "--release";
+var NEAR_CAP_HEADROOM = 20;
+function plan_of(argv, now) {
+  const [issue = "", ...paths] = argv;
+  const claims = [...backlog_overlap.path_claims(paths)];
+  if (!issue_number_shape.is_issue_number(issue) || claims.length === 0) return void 0;
+  return { issue: Number(issue), paths: claims, planned_at: now.toISOString() };
+}
+async function give_back(plan, clash, directory, at) {
+  const overlap = lane_plan_probe.overlap_text(plan.issue, clash);
+  lane_plan.record({ ...plan, yielded: true, waits_until: void 0 }, directory);
+  await lane_yield.record_yield(plan.issue, overlap, at);
+  await run_hold_cli.run([RELEASE_FLAG, String(plan.issue)]);
+  console.error(
+    `${overlap}, so it gives its lane back: end the session now, with no edit \u2014 \`run:merge\` closes the lane, and the issue is offered again once that lane ends.`
+  );
+  console.info("yield");
+  return YIELD_EXIT_CODE;
+}
+function clear_answer() {
+  console.info("clear");
+  return SUCCESS_EXIT_CODE;
+}
+function clear(plan, directory) {
+  lane_plan_probe.record_cleared(plan, directory);
+  return clear_answer();
+}
+function unread() {
+  console.error(auto_ok_cli.UNREADABLE_MESSAGE);
+  console.info("wait");
+  return FAILURE_EXIT_CODE;
+}
+function split(plan, over) {
+  console.error(lane_plan_size.refusal_text(plan.issue, over));
+  console.info("split");
+  return SPLIT_EXIT_CODE;
+}
+async function note(plan, over) {
+  const files = plan.paths.filter((file) => !test_declared_logic.is_test_file(file)).length;
+  const lines = over.reason === "lines" ? over.measured : 0;
+  await lane_ledger_write.record_split_notice({
+    issue: plan.issue,
+    files,
+    lines,
+    reason: over.reason
+  });
+}
+function is_dispatched(plan) {
+  return lane_child_marker.marked_issue() === String(plan.issue);
+}
+function is_split(plan, over) {
+  return over !== void 0 && !is_dispatched(plan) && !lane_plan_size.is_waived(plan, over);
+}
+function is_repeat(plan, directory) {
+  return is_dispatched(plan) && lane_plan.read(plan.issue, directory) !== void 0;
+}
+async function refusal(plan, over, directory) {
+  if (over === void 0 || is_repeat(plan, directory)) return void 0;
+  if (!is_dispatched(plan)) await note(plan, over);
+  if (is_split(plan, over)) return split(plan, over);
+  console.error(lane_plan_size.waiver_text(plan.issue, over));
+  return void 0;
+}
+async function warn_near_cap(plan, directory) {
+  const paths = plan.paths.map((file) => path.resolve(directory, file));
+  const budgets = await line_budget.budgets_for(paths, directory);
+  for (const { file_path, budget } of budgets) {
+    if (budget === void 0 || budget.headroom > NEAR_CAP_HEADROOM) continue;
+    console.error(
+      `near cap: ${path.relative(directory, file_path)} (${String(budget.headroom)} lines left)`
+    );
+  }
+}
+function sized_of(plan, issues) {
+  const is_judged = issues !== void 0 && lane_plan_size.declares(plan.issue, issues);
+  return is_judged ? { ...plan, sized: true } : plan;
+}
+function held(plan, clash, until) {
+  console.error(
+    `${lane_plan_probe.overlap_text(plan.issue, clash)}; this lane was dispatched first and holds commits, so it keeps its seat until ${until}: run this \`lane:plan\` again now \u2014 it waits inside, and answers \`clear\` once that lane ends, or \`yield\` past the deadline.`
+  );
+  console.info("wait");
+  return FAILURE_EXIT_CODE;
+}
+async function is_free(plan, directory) {
+  const issues = await lane_plan_probe.opted_in();
+  const running = issues === void 0 ? void 0 : lane_plan_probe.running_of(issues);
+  return running !== void 0 && lane_plan_probe.clash_among(plan, running, directory) === void 0;
+}
+async function settle(plan, clash, directory) {
+  const until = await lane_plan_wait_until.until(plan, clash.holder);
+  if (until === void 0) return await give_back(plan, clash, directory, "summary");
+  const waiting = { ...plan, waits_until: until };
+  lane_plan.record(waiting, directory);
+  const until_ms = Date.parse(until);
+  const end = await lane_plan_wait_event.timed(
+    { issue: plan.issue, holder: clash.holder },
+    async () => await lane_plan_wait.hold(until_ms, async () => await is_free(waiting, directory))
+  );
+  if (end === "free") return clear(waiting, directory);
+  return end === "expired" ? await give_back(waiting, clash, directory, "summary") : held(waiting, clash, until);
+}
+async function premise_stop(plan, issues, directory) {
+  if (lane_plan.read(plan.issue, directory) !== void 0) return void 0;
+  const stop = await lane_plan_premise.stop_text(plan.issue, issues);
+  if (stop === void 0) return void 0;
+  console.error(stop);
+  console.info("premise");
+  return PREMISE_EXIT_CODE;
+}
+async function check_plan(plan, directory) {
+  await warn_near_cap(plan, directory);
+  const issues = await lane_plan_probe.opted_in();
+  const refused = await refusal(plan, await lane_plan_probe.oversize_of(plan, issues, directory), directory) ?? await premise_stop(plan, issues, directory);
+  if (refused !== void 0) return refused;
+  const sized = sized_of(plan, issues);
+  lane_plan.record(sized, directory);
+  const found = lane_plan_probe.probe(sized, issues, directory);
+  if (lane_plan_probe.is_unread(found)) return unread();
+  return found === void 0 ? clear(sized, directory) : await settle(sized, found, directory);
+}
+async function probe_answer(plan, directory) {
+  const issues = await lane_plan_probe.opted_in();
+  const over = await lane_plan_probe.oversize_of(plan, issues, directory);
+  if (is_split(plan, over)) return split(plan, over);
+  const found = lane_plan_probe.probe(plan, issues, directory);
+  if (lane_plan_probe.is_unread(found)) return unread();
+  if (found === void 0) return clear_answer();
+  console.error(`${lane_plan_probe.overlap_text(plan.issue, found)}.`);
+  console.info("yield");
+  return YIELD_EXIT_CODE;
+}
+function placed(plan, directory) {
+  const recorded = lane_plan.read(plan.issue, directory);
+  if (recorded === void 0) return plan;
+  return {
+    ...plan,
+    size_approval: recorded.size_approval,
+    single: plan.single ?? recorded.single,
+    planned_at: recorded.planned_at,
+    yielded: recorded.yielded,
+    waits_until: recorded.waits_until,
+    sized: lane_plan.is_sized(recorded)
+  };
+}
+async function entry_plan(issue, issues, directory) {
+  const own = issues.filter((candidate) => candidate.number === issue);
+  const declared = await backlog_plan_comment.declared_of(own, directory);
+  const plan = plan_of([String(issue), ...declared.get(issue) ?? []], /* @__PURE__ */ new Date());
+  return plan === void 0 ? void 0 : placed(plan, directory);
+}
+async function entry_yield(issue, issues, directory) {
+  const plan = await entry_plan(issue, issues, directory);
+  const running = lane_plan_probe.running_of(issues);
+  const found = plan === void 0 ? void 0 : lane_plan_probe.clash_among(plan, running, directory);
+  if (plan === void 0 || found === void 0) return false;
+  await give_back(plan, found, directory, "entry");
+  return true;
+}
+async function yield_at_entry(issue, directory = process.cwd()) {
+  const issues = await lane_plan_probe.opted_in();
+  return issues === void 0 ? false : await entry_yield(issue, issues, directory);
+}
+var lane_plan_check = {
+  PREMISE_EXIT_CODE,
+  SPLIT_EXIT_CODE,
+  YIELD_EXIT_CODE,
+  check_plan,
+  placed,
+  plan_of,
+  probe_answer,
+  yield_at_entry
+};
+
+export {
+  lane_plan_check
+};

package/dist/commands/chunk-ZNIIA275.js

@@ -0,0 +1,59 @@
+import {
+  npm_acquisition
+} from "./chunk-NOSODWWK.js";
+import {
+  KIT_PACKAGE_NAME
+} from "./chunk-PBOS7MTW.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  PACKAGE_DIR
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/version/upgrade-shell-command.ts
+import path from "node:path";
+var STEP_SEPARATOR = " && ";
+function update_scope_flag(is_local) {
+  return is_local ? "-D" : "-g";
+}
+function update_argv(latest, is_local, config) {
+  const registry = !is_local && config.package_name === KIT_PACKAGE_NAME ? ["--config.@joshuafolkken:registry=https://registry.npmjs.org/"] : [];
+  return [
+    "pnpm",
+    "add",
+    update_scope_flag(is_local),
+    ...registry,
+    `${config.package_name}@${latest}`
+  ];
+}
+function format_update_command(latest, is_local, config) {
+  return update_argv(latest, is_local, config).join(" ");
+}
+function needs_migration(is_local, package_name, root) {
+  return is_local && package_name === KIT_PACKAGE_NAME && !npm_acquisition.is_project_npm(root);
+}
+function build_upgrade_command(latest, is_local, config, root = process.cwd()) {
+  const steps = [update_argv(latest, is_local, config)];
+  if (needs_migration(is_local, config.package_name, root)) {
+    steps.unshift(["node", path.join(PACKAGE_DIR, "dist/registry-migrate.mjs"), latest]);
+  }
+  if (is_local) steps.push(["node_modules/.bin/tsx", config.fix_gh_packages_path]);
+  return {
+    text: steps.map((step) => step.map((argument) => shell_quote.word(argument)).join(" ")).join(STEP_SEPARATOR),
+    steps
+  };
+}
+function shell_upgrade_command(command) {
+  return { text: command, steps: [["sh", "-c", command]] };
+}
+function build_upgrade_shell_command(latest, is_local, config) {
+  return build_upgrade_command(latest, is_local, config).text;
+}
+
+export {
+  format_update_command,
+  build_upgrade_command,
+  shell_upgrade_command,
+  build_upgrade_shell_command
+};

package/dist/commands/chunk-ZV6BZZJ2.js

@@ -0,0 +1,271 @@
+import {
+  lane_dispatch_dependency
+} from "./chunk-NDQIJBRQ.js";
+import {
+  lane_seed_policy
+} from "./chunk-6NGNMIMT.js";
+import {
+  agent_argv
+} from "./chunk-L7MDU6D7.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  lane_registry,
+  lane_seat_ownership
+} from "./chunk-NEOCCN6D.js";
+import {
+  lane_environment
+} from "./chunk-CVRDJCOE.js";
+import {
+  run_ship_detach
+} from "./chunk-FJM2HWKW.js";
+import {
+  detached_launch
+} from "./chunk-HDVSZ6CZ.js";
+import {
+  lane_child_invocation
+} from "./chunk-ON4IKRGS.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  ENV_FILE_NAME,
+  LANE_SEAT_KEY,
+  PORT_SEED_KEY
+} from "./chunk-IGD6QJPH.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/lane/lane-dispatch-log.ts
+var LOG_PREFIX = durable_state.PREFIX.LANE_DISPATCH;
+var LOG_SUFFIX = ".log";
+function default_log_path(lane) {
+  return durable_state.path(`${LOG_PREFIX}${lane.issue}-`, lane.directory, LOG_SUFFIX);
+}
+var lane_dispatch_log = { default_log_path };
+
+// scripts/lane/lane-seat.ts
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import path from "node:path";
+var SEAT_LOCK_PREFIX = "seat-";
+function lock_path(root, name) {
+  return path.join(root, lane_paths.SEAT_LOCK_DIR, name);
+}
+function release_lock(lock) {
+  rmSync(lock, { recursive: true, force: true });
+}
+function release(reservation) {
+  release_lock(reservation.lock);
+  release_lock(reservation.issue_lock);
+}
+function open_in_flight_count(root) {
+  try {
+    return readdirSync(path.join(root, lane_paths.SEAT_LOCK_DIR)).filter(
+      (entry) => entry.startsWith(SEAT_LOCK_PREFIX)
+    ).length;
+  } catch {
+    return 0;
+  }
+}
+function claim(lock) {
+  mkdirSync(path.dirname(lock), { recursive: true });
+  try {
+    mkdirSync(lock);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unreadable_description(lane) {
+  return `${session_cite.issue(lane.issue)} (${lane.directory}): ${lane.seat_problem ?? "unreadable .env"}`;
+}
+function guard_readable(lanes) {
+  const unknown = lanes.filter((lane) => lane.seat_problem !== void 0);
+  if (unknown.length === 0) return;
+  throw new Error(
+    `Cannot read lane port ownership: ${unknown.map((lane) => unreadable_description(lane)).join(", ")}`
+  );
+}
+function report_quarantined(root, lanes) {
+  const unknown = lane_registry.unreadable_lanes(lanes).filter((lane) => !existsSync(lock_path(root, `lane-${lane.issue}`)));
+  for (const lane of unknown) {
+    console.error(
+      `Quarantined lane ${unreadable_description(lane)}; checking candidate ports before allocation.`
+    );
+  }
+}
+function candidates(lanes, issue) {
+  const own = lane_registry.find_lane(lanes, issue);
+  if (own?.seat_owned === true && own.seat !== void 0) return [own.seat];
+  return lane_seed_policy.free_seats(lane_registry.used_seats(lanes));
+}
+async function ports_available(seat, lane) {
+  const root = lane?.directory ?? await lane_registry.main_repository_root();
+  const content = file_reader.read_file_or_empty(path.join(root, ENV_FILE_NAME));
+  const ports = lane_environment.read_lane_ports(lane_environment.lane_file_content(content, seat));
+  const reading = await lane_seat_ownership.snapshot();
+  if (reading === void 0) throw new Error(lane_seat_ownership.UNREADABLE);
+  return !lane_seat_ownership.ports_held(
+    { development_port: ports.development, preview_port: ports.preview },
+    reading.ports
+  );
+}
+async function available(issue, seat) {
+  const lanes = await lane_registry.list_lanes();
+  guard_readable(lanes);
+  if (lane_registry.used_seats(lanes.filter((lane) => lane.issue !== issue)).includes(seat)) {
+    return false;
+  }
+  if (lane_registry.find_lane(lanes, issue)?.seat_owned === true) return true;
+  return await ports_available(seat, lane_registry.find_lane(lanes, issue));
+}
+async function try_seat(root, issue, seat) {
+  const lock = lock_path(root, `${SEAT_LOCK_PREFIX}${String(seat)}`);
+  if (!claim(lock)) return void 0;
+  let is_held = false;
+  try {
+    is_held = await available(issue, seat);
+    return is_held ? lock : void 0;
+  } finally {
+    if (!is_held) release_lock(lock);
+  }
+}
+async function first_available(root, issue, seats) {
+  const [seat, ...rest] = seats;
+  if (seat === void 0) return void 0;
+  const lock = await try_seat(root, issue, seat);
+  return lock === void 0 ? await first_available(root, issue, rest) : { seat, lock };
+}
+async function reserve_locked(root, issue, issue_lock) {
+  const lanes = await lane_registry.list_lanes();
+  guard_readable(lanes);
+  const selected = await first_available(root, issue, candidates(lanes, issue));
+  return selected === void 0 ? void 0 : { ...selected, issue_lock };
+}
+async function reserve(root, issue) {
+  const issue_lock = lock_path(root, `lane-${issue}`);
+  if (!claim(issue_lock)) throw new Error(`Lane ${issue} is already acquiring a port seat.`);
+  try {
+    const reservation = await reserve_locked(root, issue, issue_lock);
+    if (reservation !== void 0) return reservation;
+  } catch (error) {
+    release_lock(issue_lock);
+    throw error;
+  }
+  release_lock(issue_lock);
+  return void 0;
+}
+var lane_seat = { guard_readable, open_in_flight_count, release, report_quarantined, reserve };
+
+// scripts/lane/lane-seat-start.ts
+function update(lane, seat) {
+  const content = lane_registry.read_environment(lane.directory);
+  if (content === void 0) throw new Error(`Cannot read lane environment: ${lane.directory}`);
+  const updated = lane_environment.lane_file_content(content, seat);
+  const ports = lane_environment.read_lane_ports(updated);
+  lane_registry.write_environment(lane.directory, updated);
+  return {
+    ...lane,
+    seat,
+    development_port: ports.development,
+    preview_port: ports.preview,
+    seat_held: true
+  };
+}
+async function start(lane, launch2) {
+  const root = lane_paths.lane_root(await lane_registry.main_repository_root());
+  const reservation = await lane_seat.reserve(root, lane.issue);
+  if (reservation === void 0) throw new Error("No free port seat is available for this lane.");
+  try {
+    return await launch2(update(lane, reservation.seat));
+  } finally {
+    lane_seat.release(reservation);
+  }
+}
+function environment(lane) {
+  if (lane.seat === void 0) {
+    throw new Error("Cannot launch a lane without an allocated port seat.");
+  }
+  const content = lane_registry.read_environment(lane.directory);
+  if (content === void 0) throw new Error(`Cannot read lane environment: ${lane.directory}`);
+  return {
+    [LANE_SEAT_KEY]: String(lane.seat),
+    [PORT_SEED_KEY]: String(lane_environment.read_root_seed(content))
+  };
+}
+var lane_seat_start = { environment, start };
+
+// scripts/lane/lane-relaunch.ts
+var { SUPERVISED_KEY } = run_ship_detach;
+var OPENAI_PROVIDER = "openai";
+function launch_ready(lane, built, on_note) {
+  return detached_launch.launch(
+    {
+      argv: built.argv,
+      cwd: lane.directory,
+      log_path: lane_dispatch_log.default_log_path(lane),
+      profile: built.profile,
+      // The relaunch keeps the mark, so the resumed child is still a dispatched child to every rule
+      // that reads it; the inherited environment cannot be relied on here,
+      // since the parent-session strip runs on the way in. **The ship supervisor's mark is dropped**:
+      // a detached supervisor is what relaunches after a stopped stage, and an
+      // agent that inherited its mark would read its own in-turn `josh ship` failure as a supervisor's —
+      // relaunching a second child into the lane beside itself.
+      env: {
+        ...lane_child_marker.env_for(lane.issue),
+        ...lane_seat_start.environment(lane),
+        [SUPERVISED_KEY]: void 0
+      }
+    },
+    on_note
+  );
+}
+async function launch(lane, built, on_note) {
+  const wait = await lane_dispatch_dependency.check(lane.issue);
+  if (wait !== void 0) {
+    await lane_dispatch_dependency.defer(lane.issue);
+    return { kind: "rejected", note: wait.reason };
+  }
+  await lane_dispatch_dependency.begin(lane.issue);
+  return launch_ready(lane, built, on_note);
+}
+async function relaunch(lane, invocation, phase, on_note) {
+  try {
+    const built = await agent_argv.resume_argv(invocation, lane.profile, phase, {
+      cwd: lane.directory,
+      labels: async () => await git_gh_issue_write.read_label_names(lane.issue)
+    });
+    if (built.kind === "rejected") return built;
+    return await lane_seat_start.start(lane, async (seated) => await launch(seated, built, on_note));
+  } catch (error) {
+    return { kind: "failed", note: error_text.message_of(error) };
+  }
+}
+function is_openai_lane(lane) {
+  return lane.profile?.provider === OPENAI_PROVIDER;
+}
+async function resume(lane, phase, on_note) {
+  return await relaunch(lane, lane_child_invocation.resume_invocation(lane.issue), phase, on_note);
+}
+var lane_relaunch = { is_openai_lane, relaunch, resume };
+
+export {
+  lane_dispatch_log,
+  lane_seat,
+  lane_seat_start,
+  lane_relaunch
+};

package/dist/commands/ci-timing-cli.js

@@ -2,19 +2,38 @@
 import {
   ci_timing,
   ci_timing_table
-} from "./chunk-LWAXXZPS.js";
+} from "./chunk-BQLKWGGC.js";
 import "./chunk-RDRN56E4.js";
-import "./chunk-XDF25GSU.js";
+import "./chunk-43DU7DYZ.js";
 import "./chunk-EBVS2LKX.js";
+import "./chunk-RV7EQIE4.js";
+import "./chunk-5OF2B4BF.js";
 import "./chunk-AQ3PMSXK.js";
 import "./chunk-QVOFWFWC.js";
 import "./chunk-G6BXCWPH.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
+import "./chunk-KIS7JFNP.js";
+import "./chunk-DS53UUDH.js";
+import "./chunk-DDZVMXZD.js";
 import "./chunk-HHBC6QZE.js";
-import "./chunk-VJE3RJAX.js";
+import "./chunk-XXPDFJRI.js";
+import "./chunk-G75GWNNY.js";
+import "./chunk-2FE3C4PH.js";
+import "./chunk-F2RDEF2J.js";
+import "./chunk-JPMAW2VZ.js";
+import "./chunk-5VQCL33M.js";
+import "./chunk-VLN6TSPJ.js";
+import "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import "./chunk-IXZZSST7.js";
+import "./chunk-B5HP6T4L.js";
+import "./chunk-B77ZMVHS.js";
+import "./chunk-B5GXZK3E.js";
+import "./chunk-KTLR4Y32.js";
 import "./chunk-WPAQUMHC.js";
+import "./chunk-ZNX2LJCQ.js";
 import "./chunk-HIU2WXB6.js";
 
 // scripts/ci/ci-timing-cli.ts

package/dist/commands/code-symbol-cli.js

@@ -1,31 +1,45 @@
 #!/usr/bin/env tsx
 import {
   capped_output
-} from "./chunk-2CXT6MBR.js";
+} from "./chunk-7HP3FQGQ.js";
 import {
   working_tree
-} from "./chunk-V4Z7G4UH.js";
-import "./chunk-RH6ZWJOA.js";
+} from "./chunk-ZCD4AV2P.js";
+import "./chunk-5KSJEWXR.js";
 import "./chunk-MY3RSOS5.js";
 import "./chunk-JFLFGLE4.js";
 import {
   document_section
 } from "./chunk-NDWZTWXV.js";
 import "./chunk-3WWQFCGX.js";
-import "./chunk-XDF25GSU.js";
+import "./chunk-43DU7DYZ.js";
 import "./chunk-EBVS2LKX.js";
+import "./chunk-RV7EQIE4.js";
+import "./chunk-5OF2B4BF.js";
 import "./chunk-AQ3PMSXK.js";
 import "./chunk-QVOFWFWC.js";
 import "./chunk-G6BXCWPH.js";
 import "./chunk-CDY4NFQG.js";
+import "./chunk-KIS7JFNP.js";
+import "./chunk-DS53UUDH.js";
+import "./chunk-DDZVMXZD.js";
 import "./chunk-HHBC6QZE.js";
-import "./chunk-ILGPZ47M.js";
+import "./chunk-XXPDFJRI.js";
+import "./chunk-G75GWNNY.js";
+import "./chunk-2FE3C4PH.js";
+import "./chunk-F2RDEF2J.js";
+import "./chunk-JPMAW2VZ.js";
+import "./chunk-5VQCL33M.js";
+import "./chunk-VLN6TSPJ.js";
+import "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import "./chunk-IXZZSST7.js";
+import "./chunk-B5HP6T4L.js";
 import "./chunk-B77ZMVHS.js";
 import "./chunk-B5GXZK3E.js";
 import "./chunk-KTLR4Y32.js";
-import "./chunk-ZNX2LJCQ.js";
-import "./chunk-VJE3RJAX.js";
 import "./chunk-WPAQUMHC.js";
+import "./chunk-ZNX2LJCQ.js";
 import "./chunk-HIU2WXB6.js";
 
 // scripts/code/code-symbol-cli.ts