@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-ZJ5S4VFD.js

@@ -0,0 +1,258 @@
+import {
+  related_scope
+} from "./chunk-ZEUKX3RZ.js";
+import {
+  verification_tail
+} from "./chunk-VCWNMRH7.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+
+// scripts/test/test-pinned-stage.ts
+var WIDE_REACH = 100;
+var WIDE_RATIO = 3;
+var TYPE_RED = { verdict: "red", failed: [], pinned_by: "type-check" };
+function none() {
+  return { direct: 0, typed: 0, escalated: 0 };
+}
+function is_wide(reach, direct) {
+  if (direct === 0 || direct >= reach) return false;
+  return reach >= WIDE_REACH || reach >= WIDE_RATIO * direct;
+}
+function plan_over(file, direct, reach) {
+  return is_wide(reach, direct.length) ? { direct, reach: [file] } : { reach: [file] };
+}
+async function past_direct(plan, run, is_type_red, staged) {
+  if (await is_type_red()) {
+    staged.typed += 1;
+    return TYPE_RED;
+  }
+  staged.escalated += 1;
+  return await run(plan.reach);
+}
+async function staged_verdict(plan, run, is_type_red, staged) {
+  if (plan.direct === void 0) return await run(plan.reach);
+  const first = await run(plan.direct);
+  if (first.verdict !== "red") return await past_direct(plan, run, is_type_red, staged);
+  staged.direct += 1;
+  return first;
+}
+function counts_suffix(staged) {
+  if (staged === void 0 || staged.direct + staged.typed + staged.escalated === 0) return "";
+  const typed = staged.typed === 0 ? "" : ` \xB7 type check ${String(staged.typed)}`;
+  return ` \xB7 direct ${String(staged.direct)}${typed} \xB7 escalated ${String(staged.escalated)}`;
+}
+var test_pinned_stage = { WIDE_RATIO, WIDE_REACH, counts_suffix, none, plan_over, staged_verdict };
+
+// scripts/test/test-pinned-logic.ts
+var DEFAULT_MAX_HUNKS = 20;
+var MAX_TEST_FILES = 150;
+var HEADER = /^@@ -\d+(?:,\d+)? \+(?<start>\d+)(?:,(?<count>\d+))? @@/u;
+var FILE_HEADER = "+++ b/";
+var SECTION_HEADER = "diff --git ";
+var OLD_LINE = "-";
+var OLD_FILE_HEADER = "--- ";
+var NEW_LINE = "+";
+var FILE_HEADER_MARK = "+++ ";
+var OLD_FILE_PATH = "--- a/";
+var LINE_BREAK = "\n";
+var GREEN_REASON = "reverting it left every related test green";
+var NO_TEST_REASON = "no related test ran with it reverted";
+var STUB_GREEN_REASON = "replacing its body with a throw left every related test green";
+var STUB_NO_TEST_REASON = "no related test ran with its body replaced by a throw";
+var UNPARSED_REASON = "an added file, and typescript is not installed to read its functions";
+var NO_RUNNER_REASON = "vitest is not installed to run its related tests";
+var STOPPED_REASON = "vitest stopped before any test ran with it reverted";
+var CUT_REASON = "not probed: the run stopped at the first unpinned hunk";
+var OVER_CAP_REASON = `over the ${String(MAX_TEST_FILES)}-test-file cap`;
+var STOPPED_VERDICT = "stopped";
+var SETTLED_VERDICTS = /* @__PURE__ */ new Set(["red", STOPPED_VERDICT]);
+function is_target(file) {
+  return !test_declared_logic.is_test_file(file) && related_scope.is_relatable(file);
+}
+function count_of(group) {
+  return group === void 0 ? 1 : Number(group);
+}
+function hunk_from(file, line) {
+  const groups = HEADER.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  return {
+    file,
+    new_start: Number(groups["start"]),
+    new_count: count_of(groups["count"]),
+    old_lines: [],
+    new_lines: []
+  };
+}
+function is_old_line(line) {
+  return line.startsWith(OLD_LINE) && !line.startsWith(OLD_FILE_HEADER);
+}
+function is_new_line(line) {
+  return line.startsWith(NEW_LINE) && !line.startsWith(FILE_HEADER_MARK);
+}
+function record_line(hunk, line) {
+  if (hunk === void 0) return;
+  if (is_old_line(line)) hunk.old_lines.push(line.slice(OLD_LINE.length));
+  else if (is_new_line(line)) hunk.new_lines?.push(line.slice(NEW_LINE.length));
+}
+function file_after(file, line) {
+  if (line.startsWith(FILE_HEADER)) return line.slice(FILE_HEADER.length);
+  if (line.startsWith(OLD_FILE_PATH)) return line.slice(OLD_FILE_PATH.length);
+  return line.startsWith(SECTION_HEADER) ? "" : file;
+}
+function step(walk, line) {
+  walk.file = file_after(walk.file, line);
+  const hunk = hunk_from(walk.file, line);
+  if (hunk === void 0) record_line(walk.hunks.at(-1), line);
+  else walk.hunks.push(hunk);
+}
+function all_hunks(diff) {
+  const walk = { file: "", hunks: [] };
+  for (const line of diff.split(LINE_BREAK)) step(walk, line);
+  return walk.hunks;
+}
+function parse_hunks(diff) {
+  return all_hunks(diff).filter((hunk) => is_target(hunk.file));
+}
+function start_index(hunk) {
+  return hunk.new_count === 0 ? hunk.new_start : hunk.new_start - 1;
+}
+function revert(content, hunk) {
+  const lines = content.split(LINE_BREAK);
+  const parts = (hunk.parts ?? [hunk]).toSorted(
+    (left, right) => start_index(right) - start_index(left)
+  );
+  for (const part of parts) lines.splice(start_index(part), part.new_count, ...part.old_lines);
+  return lines.join(LINE_BREAK);
+}
+function split(hunks, max_hunks) {
+  return { checked: hunks.slice(0, max_hunks), unchecked: hunks.slice(max_hunks) };
+}
+function capped(hunks, reach, max_tests = MAX_TEST_FILES) {
+  function is_over(hunk) {
+    return (reach.get(hunk.file) ?? 0) > max_tests;
+  }
+  return {
+    checked: hunks.filter((hunk) => !is_over(hunk)),
+    unchecked: hunks.filter((hunk) => is_over(hunk))
+  };
+}
+function by_reach(probes, reach) {
+  function count(probe) {
+    return reach.get(probe.hunk.file) ?? 0;
+  }
+  return probes.toSorted((first, second) => count(first) - count(second));
+}
+function is_unpinned(probe) {
+  return !SETTLED_VERDICTS.has(probe.verdict);
+}
+function unpinned_of(hunk, probe) {
+  if (probe === void 0 || !is_unpinned(probe)) return [];
+  return [{ ...hunk, is_green: probe.verdict === "green" }];
+}
+function stopped_of(hunk, probe) {
+  return probe?.verdict === STOPPED_VERDICT ? [hunk] : [];
+}
+function outcome(hunks, verdicts) {
+  return {
+    unpinned: hunks.flatMap((hunk, index) => unpinned_of(hunk, verdicts[index])),
+    stopped: hunks.flatMap((hunk, index) => stopped_of(hunk, verdicts[index]))
+  };
+}
+function location(hunk) {
+  const line = `${hunk.file}:${String(Math.max(hunk.new_start, 1))}`;
+  return hunk.function_name === void 0 ? line : `${line} ${hunk.function_name}`;
+}
+function reason(hunk) {
+  if (hunk.function_name === void 0) return hunk.is_green ? GREEN_REASON : NO_TEST_REASON;
+  return hunk.is_green ? STUB_GREEN_REASON : STUB_NO_TEST_REASON;
+}
+function unchecked_reason(report) {
+  return report.has_runner ? `over the ${String(report.max_hunks)}-hunk cap` : NO_RUNNER_REASON;
+}
+function hint(hunk) {
+  const tests = hunk.related_tests;
+  if (tests === void 0) {
+    return "related tests unavailable; add or strengthen a regression test that fails when this change is reverted";
+  }
+  if (tests.length === 0) {
+    return "no related tests; add a related regression test that fails when this change is reverted";
+  }
+  return `related tests: ${tests.join(", ")}; strengthen a regression assertion that fails when this change is reverted`;
+}
+function unpinned_lines(report) {
+  return report.unpinned.map(
+    (hunk) => `unpinned ${location(hunk)} \u2014 ${reason(hunk)}; ${hint(hunk)}`
+  );
+}
+function place_of(hunk, why) {
+  return { place: location(hunk), why };
+}
+function unchecked_places(report) {
+  return [
+    ...report.unchecked.map((hunk) => place_of(hunk, unchecked_reason(report))),
+    ...(report.over_cap ?? []).map((hunk) => place_of(hunk, OVER_CAP_REASON)),
+    ...report.stopped.map((hunk) => place_of(hunk, STOPPED_REASON)),
+    ...(report.cut ?? []).map((hunk) => place_of(hunk, CUT_REASON)),
+    ...report.unparsed.map((file) => ({ place: file, why: UNPARSED_REASON }))
+  ];
+}
+function has_unchecked(report) {
+  return unchecked_places(report).length > 0;
+}
+function format(report) {
+  const unchecked = unchecked_places(report).map((item) => `unchecked ${item.place} \u2014 ${item.why}`);
+  return [...unpinned_lines(report), ...unchecked].join(LINE_BREAK);
+}
+function folded_unchecked(report) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const { why } of unchecked_places(report)) counts.set(why, (counts.get(why) ?? 0) + 1);
+  return [...counts].map(([why, count]) => `unchecked ${String(count)} \u2014 ${why}`);
+}
+function counts_line(report) {
+  const unchecked = String(unchecked_places(report).length);
+  const staged = test_pinned_stage.counts_suffix(report.staged);
+  return `unpinned ${String(report.unpinned.length)} \xB7 unchecked ${unchecked}${staged}`;
+}
+function report_parts(report) {
+  const lines = [...unpinned_lines(report), ...folded_unchecked(report)];
+  return {
+    text: lines.map((line) => `${line}${LINE_BREAK}`).join(""),
+    counts: counts_line(report),
+    ...report.tree_hash !== void 0 && {
+      tree_hash: report.tree_hash,
+      is_stale: report.is_stale
+    }
+  };
+}
+function report_text(parts, note = "") {
+  const stale = parts.is_stale === true ? " \xB7 stale" : "";
+  const snapshot = parts.tree_hash === void 0 ? "" : `snapshot ${parts.tree_hash}${stale}
+`;
+  const failures = `${snapshot}${parts.text}${note}`;
+  if (parts.counts === void 0) return failures;
+  return verification_tail.format_tail({ failures, log: parts.log, verdict: parts.counts });
+}
+var test_pinned_logic = {
+  all_hunks,
+  DEFAULT_MAX_HUNKS,
+  by_reach,
+  capped,
+  format,
+  has_unchecked,
+  is_target,
+  is_unpinned,
+  location,
+  MAX_TEST_FILES,
+  outcome,
+  parse_hunks,
+  report_parts,
+  report_text,
+  revert,
+  split
+};
+
+export {
+  test_pinned_stage,
+  test_pinned_logic
+};

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