@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-HQZ65PJE.js

@@ -1,167 +0,0 @@
-import {
-  test_related_pins
-} from "./chunk-HE5S4XRE.js";
-import {
-  direct_importers
-} from "./chunk-N4EMFHQ6.js";
-import {
-  test_pinned_logic
-} from "./chunk-RAQ3E6OT.js";
-import {
-  test_pinned_reach
-} from "./chunk-6FN37DER.js";
-import {
-  related_scope
-} from "./chunk-KJPZPTS4.js";
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  change_base
-} from "./chunk-LBVYFW3I.js";
-import {
-  git_spawn
-} from "./chunk-B5HP6T4L.js";
-
-// scripts/test/test-related-cap.ts
-import { existsSync } from "node:fs";
-import path2 from "node:path";
-
-// scripts/test/test-related-imports.ts
-import { readFileSync } from "node:fs";
-import path from "node:path";
-function is_loading(typescript, node, source) {
-  if (!typescript.isCallExpression(node)) return false;
-  return node.expression.kind === typescript.SyntaxKind.ImportKeyword || node.expression.getText(source) === "require";
-}
-function signature(typescript, file, content) {
-  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
-  const declarations = [];
-  function visit(node) {
-    if (typescript.isImportDeclaration(node) || typescript.isExportDeclaration(node) || is_loading(typescript, node, source)) {
-      declarations.push(node.getText(source));
-    }
-    typescript.forEachChild(node, visit);
-  }
-  visit(source);
-  return JSON.stringify(declarations);
-}
-async function is_stable(root, file, comparison) {
-  if (path.extname(file) === ".svelte") return false;
-  try {
-    const before = await git_spawn.read(["-C", root, "show", `${comparison.base}:${file}`]);
-    const current = readFileSync(path.join(root, file), "utf8");
-    return signature(comparison.typescript, file, before) === signature(comparison.typescript, file, current);
-  } catch {
-    return false;
-  }
-}
-async function compare(root, files) {
-  try {
-    const base = await change_base.resolved_through_merge();
-    if (base === void 0) return files.map(() => false);
-    const { default: typescript } = await import("typescript");
-    return await Promise.all(
-      files.map(async (file) => await is_stable(root, file, { base, typescript }))
-    );
-  } catch {
-    return files.map(() => false);
-  }
-}
-async function stable_files(root, files) {
-  if (files.length === 0) return [];
-  const stable = await compare(root, files);
-  const retained = files.filter((_file, index) => stable[index] !== true);
-  if (retained.length > 0) {
-    process.stdout.write(
-      `josh test:related: keeping full reach (imports changed or unknown): ${retained.join(", ")}
-`
-    );
-  }
-  return files.filter((_file, index) => stable[index] === true);
-}
-var test_related_imports = { stable_files };
-
-// scripts/test/test-related-cap.ts
-var NO_CAP = { importers: /* @__PURE__ */ new Map(), over_cap: [] };
-function reach_sum(counts) {
-  return counts.reduce((sum, reached) => sum + reached.count, 0);
-}
-function over_cap_of(counts, max_tests = test_pinned_logic.MAX_TEST_FILES) {
-  const widest = counts.toSorted((first, second) => second.count - first.count);
-  const fits = widest.findIndex((_, index) => reach_sum(widest.slice(index)) <= max_tests);
-  const narrowed = fits === -1 ? widest : widest.slice(0, fits);
-  return narrowed.map((reached) => reached.file);
-}
-function candidates_of(root, files, narrowed) {
-  return files.filter(
-    (file) => related_scope.is_relatable(file) && !test_declared_logic.is_test_file(file) && !narrowed.has(file) && existsSync(path2.join(root, file))
-  );
-}
-async function relative_counts(root, files, read_counts) {
-  if (files.length === 0) return [];
-  const counts = await read_counts(files.map((file) => path2.join(root, file)));
-  return (counts ?? []).map((reached) => ({ ...reached, file: path2.relative(root, reached.file) }));
-}
-async function read_over_cap(root, files, read_counts) {
-  return over_cap_of(await relative_counts(root, files, read_counts));
-}
-async function direct_of(root, over_cap) {
-  const stable = await test_related_imports.stable_files(root, over_cap);
-  const importers = await direct_importers.importers_of(root, stable);
-  const narrowed = [...importers].filter(([, tests]) => tests.length > 0);
-  return narrowed.map(([file, tests]) => [file, test_related_pins.with_pins(file, tests)]);
-}
-async function split_of(root, files) {
-  const shared = direct_importers.every_test_imports_of(files);
-  const stable = await test_related_imports.stable_files(root, shared);
-  const every_test = await direct_importers.every_test_importers(root, stable);
-  return [every_test, candidates_of(root, files, every_test)];
-}
-async function capped_importers(root, files, is_whole, read_counts = test_pinned_reach.reached_test_counts) {
-  if (is_whole) return NO_CAP;
-  const [every_test, candidates] = await split_of(root, files);
-  const over_cap = await read_over_cap(root, candidates, read_counts);
-  const capped = await direct_of(root, over_cap);
-  return { importers: new Map([...every_test, ...capped]), over_cap: capped.map(([file]) => file) };
-}
-async function hubs_of(root, files, read_counts = test_pinned_reach.reached_test_counts) {
-  const [, candidates] = await split_of(root, files);
-  const counts = await relative_counts(root, candidates, read_counts);
-  return counts.flatMap((reached) => over_cap_of([reached]));
-}
-function capped_test_count(capped) {
-  const tests = capped.over_cap.flatMap((file) => capped.importers.get(file) ?? []);
-  return new Set(tests).size;
-}
-function hub_of(over_cap, own) {
-  return over_cap.find((file) => own.includes(file));
-}
-function over_cap_line(capped, own) {
-  const { over_cap } = capped;
-  if (over_cap.length === 0) return void 0;
-  const { COMMAND_LABEL } = related_scope;
-  const cap = String(test_pinned_logic.MAX_TEST_FILES);
-  const ran = String(capped_test_count(capped));
-  const hub = hub_of(over_cap, own);
-  const hub_part = hub === void 0 ? "" : `, hub ${hub}`;
-  return `${COMMAND_LABEL}: ${String(over_cap.length)} over cap (${cap} test files)${hub_part} \u2014 ${ran} test files run, the rest unchecked: ${over_cap.join(", ")}`;
-}
-function report_over_cap(capped, own) {
-  const line = over_cap_line(capped, own);
-  if (line !== void 0) process.stdout.write(`${line}
-`);
-}
-var test_related_cap = {
-  NO_CAP,
-  capped_importers,
-  hub_of,
-  hubs_of,
-  over_cap_line,
-  over_cap_of,
-  report_over_cap
-};
-
-export {
-  test_related_cap
-};

package/dist/commands/chunk-HRN73FQJ.js

@@ -1,77 +0,0 @@
-import {
-  inherited_scope
-} from "./chunk-5OF2B4BF.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-
-// scripts/run/ship/run-ship-lap.ts
-import { z } from "zod";
-var ENVIRONMENT_KEY = "JOSH_SHIP_LAP_SCOPE";
-var PARENT_SEPARATOR = " \u203A ";
-var STARTUP_STEP = "startup";
-var lap_scope_schema = z.object({
-  issue: z.number(),
-  stage: z.string(),
-  parent: z.string().optional()
-});
-var STEP = {
-  PRECONDITIONS: "preconditions",
-  SCOPED_PAIR: "scoped pair",
-  GATE: "josh gate",
-  OVERLAP_WAIT: "overlap wait",
-  LOCAL_COMMIT: "local commit",
-  MERGE: "merge",
-  PUSH: "push",
-  COMMIT: "josh git"
-};
-var scope = inherited_scope.create(ENVIRONMENT_KEY, lap_scope_schema);
-async function to_ledger(lap) {
-  await lane_ledger_write.record_ship_lap(lap);
-}
-async function within(issue, stage, run, parent) {
-  return await scope.within({ issue: Number(issue), stage, parent }, run);
-}
-function current_scope() {
-  return scope.current();
-}
-function environment(parent) {
-  const current = current_scope();
-  if (current === void 0) return {};
-  return {
-    [ENVIRONMENT_KEY]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
-  };
-}
-function lap_of(current, step, started_ms, note) {
-  const { parent, ...place } = current;
-  const name = parent === void 0 ? step : `${parent}${PARENT_SEPARATOR}${step}`;
-  return { ...place, step: name, elapsed_ms: performance.now() - started_ms, ...note };
-}
-function no_note() {
-  return {};
-}
-var startup = { recorded: false };
-async function record_startup(current, sink, is_wanted) {
-  if (!is_wanted || startup.recorded || scope.local() !== void 0) return;
-  startup.recorded = true;
-  await sink(lap_of(current, STARTUP_STEP, 0, {}));
-}
-async function timed(step, run, { sink = to_ledger, note_of = no_note, startup: with_startup } = {}) {
-  const current = current_scope();
-  if (current === void 0) return await run();
-  await record_startup(current, sink, with_startup !== false);
-  const started_ms = performance.now();
-  const noted = { note: {} };
-  try {
-    const result = await run();
-    noted.note = note_of(result);
-    return result;
-  } finally {
-    await sink(lap_of(current, step, started_ms, noted.note));
-  }
-}
-var run_ship_lap = { ENVIRONMENT_KEY, STARTUP_STEP, STEP, environment, timed, within };
-
-export {
-  run_ship_lap
-};

package/dist/commands/chunk-HSZECERZ.js

@@ -1,271 +0,0 @@
-import {
-  test_related
-} from "./chunk-JU2MAYQ3.js";
-import {
-  test_unit_guard
-} from "./chunk-KWLNK2NJ.js";
-import {
-  gate_log,
-  verification_tail
-} from "./chunk-VCWNMRH7.js";
-import {
-  moved_paths
-} from "./chunk-PBAEJ5PT.js";
-import {
-  review_tree
-} from "./chunk-R36VZIKU.js";
-import {
-  file_map_stamp
-} from "./chunk-M32UPB2D.js";
-import {
-  verification_inputs
-} from "./chunk-EHPTXSAT.js";
-import {
-  NOTHING_TO_CHECK_MARKER,
-  NOT_USED_MARKER
-} from "./chunk-IW6NWCSN.js";
-import {
-  josh_verdict
-} from "./chunk-JTU5A4JI.js";
-import {
-  status_icons
-} from "./chunk-65E4OZJ7.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  GATE_COMMAND
-} from "./chunk-TBIX5FRN.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-import {
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/gate/gate-report.ts
-var { FAIL_ICON, PASS_ICON, WARN_ICON } = status_icons;
-function is_gate_step_failed(result) {
-  return buffered_process.is_process_failed(result);
-}
-function is_skip_notice(result) {
-  return result.output.includes(test_unit_guard.SKIP_MARKER);
-}
-var WARNING_MARKERS = ["warning", "Warning", "\u26A0"];
-function has_warnings(result) {
-  return WARNING_MARKERS.some((marker) => result.output.includes(marker));
-}
-var SAFE_CHAIN_BANNER = "safe-chain is not available";
-var PNPM_SCRIPT_HEADER = "$ ";
-var LINT_FILE_PREFIX = "  - ";
-function checker_lines(result) {
-  return result.output.split("\n").filter((line) => !line.includes(SAFE_CHAIN_BANNER) && !line.startsWith(PNPM_SCRIPT_HEADER));
-}
-function has_checker_warning(result) {
-  if (!gate_labels.WARNING_CHECKER_LABELS.includes(result.label)) return false;
-  return checker_lines(result).filter((line) => result.label !== gate_labels.LINT_LABEL || !line.startsWith(LINT_FILE_PREFIX)).some((line) => WARNING_MARKERS.some((marker) => line.includes(marker)));
-}
-function is_unverified_skip(result) {
-  return checker_lines(result).some(
-    (line) => line.includes(test_unit_guard.SKIP_MARKER) && !line.includes(NOT_USED_MARKER)
-  );
-}
-function has_nothing_to_say(result) {
-  return !is_unverified_skip(result) && !has_checker_warning(result);
-}
-var IDLE_MARKERS = [test_unit_guard.SKIP_MARKER, NOTHING_TO_CHECK_MARKER];
-function is_idle_line(line) {
-  return IDLE_MARKERS.some((marker) => line.includes(marker));
-}
-function is_tool_line(line) {
-  return line.trim() !== "";
-}
-function is_idle(result) {
-  const lines = checker_lines(result).filter((line) => is_tool_line(line));
-  return lines.length > 0 && lines.every((line) => is_idle_line(line));
-}
-function should_print_body(result, is_verbose) {
-  if (is_verbose || is_gate_step_failed(result)) return true;
-  return is_skip_notice(result) || has_warnings(result);
-}
-var SECONDS_DECIMALS = 1;
-function format_seconds(elapsed_ms) {
-  return `${(elapsed_ms / MS_PER_SECOND).toFixed(SECONDS_DECIMALS)}s`;
-}
-function gate_step_header(result) {
-  const icon = is_gate_step_failed(result) ? FAIL_ICON : PASS_ICON;
-  const timing = result.reused_at === void 0 ? format_seconds(result.elapsed_ms) : `reused \u2014 inputs unchanged since it passed at ${result.reused_at}`;
-  return `${icon} ${result.label} (pnpm ${result.command}) ${timing}`;
-}
-function print_gate_step(result, is_verbose) {
-  process.stdout.write(`
-${gate_step_header(result)}
-`);
-  if (should_print_body(result, is_verbose) && result.output) {
-    process.stdout.write(`${result.output}
-`);
-  }
-}
-function format_failure_actions(failed) {
-  if (failed.length === 0) return "";
-  const lines = failed.map(
-    (result) => verification_tail.format_rerun(result.label, `pnpm ${result.command}`)
-  );
-  return `${GATE_COMMAND} \u2014 next:
-${lines.join("\n")}
-`;
-}
-function format_budget_notes(results) {
-  const lines = results.flatMap(
-    (result) => result.budget_note === void 0 ? [] : `  ${WARN_ICON} ${result.label} \u2014 ${result.budget_note}`
-  );
-  return lines.length === 0 ? "" : `${lines.join("\n")}
-`;
-}
-function format_green_verdict(results, total) {
-  const has_skip = results.some((result) => is_skip_notice(result));
-  const skipped = has_skip ? results.filter((result) => is_idle(result)).length : 0;
-  const ran = results.length - skipped;
-  if (ran === 0) return josh_verdict.format_gate_unverified(skipped, total);
-  return josh_verdict.format_gate_passed({ ran, skipped }, total);
-}
-function print_gate_summary(results, report, log_path) {
-  const failed = results.filter((result) => is_gate_step_failed(result));
-  const total = format_seconds(report.elapsed_ms);
-  const verdict = failed.length === 0 ? format_green_verdict(results, total) : josh_verdict.format_gate_failed(failed.map((result) => result.label).join(", "), total);
-  const failures = `${format_budget_notes(results)}${format_failure_actions(failed)}`;
-  process.stdout.write(
-    `
-${verification_tail.format_tail({ failures, log: { path: log_path }, verdict })}`
-  );
-}
-function report_gate_steps(results, report) {
-  for (const result of results) print_gate_step(result, report.is_verbose);
-  const entries = results.map((result) => ({
-    header: gate_step_header(result),
-    output: result.output
-  }));
-  const written_log = gate_log.write_gate_log(entries, report.log_path);
-  print_gate_summary(results, report, written_log);
-  return results.filter((result) => is_gate_step_failed(result)).map((result) => result.label);
-}
-var gate_report = {
-  format_budget_notes,
-  format_failure_actions,
-  has_checker_warning,
-  has_nothing_to_say,
-  is_gate_step_failed,
-  report_gate_steps
-};
-
-// scripts/gate/check-inputs.ts
-import path from "node:path";
-function prettier_ignored(root) {
-  const ignore_path = verification_inputs.PRETTIER_IGNORE_FILES.map((name) => path.join(root, name));
-  return async function is_ignored(relative) {
-    try {
-      const prettier = await import("prettier");
-      const info = await prettier.getFileInfo(path.join(root, relative), {
-        ignorePath: ignore_path
-      });
-      return info.ignored;
-    } catch {
-      return false;
-    }
-  };
-}
-async function reads_any(declaration, paths, is_ignored, root) {
-  if (declaration.reads === "recorded") return await test_related.reaches_tests(root, paths);
-  const { is_input } = declaration;
-  if (is_input === void 0) return true;
-  const answers = await Promise.all(
-    paths.map(async (relative) => await is_input(relative, is_ignored))
-  );
-  return answers.includes(true);
-}
-async function touches_inputs(label, paths, is_ignored, root = PROJECT_ROOT) {
-  const declaration = verification_inputs.declaration_of(label);
-  if (declaration === void 0 || verification_inputs.configures(label, paths, root)) return true;
-  return await reads_any(declaration, paths, is_ignored, root);
-}
-var check_inputs = { prettier_ignored, touches_inputs };
-
-// scripts/gate/check-reuse.ts
-var CHECK_PREFIX = "josh-gate-check-";
-function declared_inputs(label) {
-  if (!verification_inputs.is_declared(label)) return void 0;
-  return {
-    fingerprint: () => verification_inputs.fingerprint([label]),
-    touches: async (moved, context) => await check_inputs.touches_inputs(label, moved, context.is_ignored, context.root)
-  };
-}
-function check_stamp(inputs) {
-  return file_map_stamp.create(CHECK_PREFIX, PROJECT_ROOT, inputs.fingerprint);
-}
-function default_records(label) {
-  return stamp_file.stamp_path(`${CHECK_PREFIX}${label}-`, PROJECT_ROOT);
-}
-async function is_stamp_reusable(inputs, stamp, context) {
-  const moved = await moved_paths.moved_since(stamp, context.tree);
-  if (moved === void 0 || !check_stamp(inputs).describes_inputs(stamp)) return false;
-  return !await inputs.touches(moved, context);
-}
-async function reused_at(label, inputs, context) {
-  if (inputs === void 0) return void 0;
-  const stamp = check_stamp(inputs).read(context.records(label));
-  if (stamp === void 0) return void 0;
-  return await is_stamp_reusable(inputs, stamp, context) ? stamp.taken_at : void 0;
-}
-async function read_root() {
-  try {
-    return await git_command.repository_root();
-  } catch {
-    return void 0;
-  }
-}
-async function reusable_checks(labels, tree, records = default_records, inputs_of = declared_inputs) {
-  const root = await read_root();
-  if (root === void 0) return /* @__PURE__ */ new Map();
-  const context = { tree, records, root, is_ignored: check_inputs.prettier_ignored(root) };
-  const answers = await Promise.all(
-    labels.map(
-      async (label) => [label, await reused_at(label, inputs_of(label), context)]
-    )
-  );
-  return new Map(answers.flatMap(([label, at]) => at === void 0 ? [] : [[label, at]]));
-}
-function recordable_inputs(result, inputs_of) {
-  const is_quiet_pass = !gate_report.is_gate_step_failed(result) && gate_report.has_nothing_to_say(result);
-  return is_quiet_pass ? inputs_of(result.label) : void 0;
-}
-function write_records(results, tree, records, inputs_of) {
-  for (const result of results) {
-    const inputs = recordable_inputs(result, inputs_of);
-    if (inputs !== void 0) {
-      check_stamp(inputs).write(tree.files, records(result.label), tree.base);
-    }
-  }
-}
-async function record_green_checks(results, tree, records = default_records, inputs_of = declared_inputs) {
-  try {
-    const after = await review_tree.read_changed_tree();
-    if (JSON.stringify(after) !== JSON.stringify(tree.files)) return;
-    write_records(results, { files: after, base: tree.base }, records, inputs_of);
-  } catch {
-  }
-}
-var check_reuse = { DEFAULT_RECORDS: default_records, record_green_checks, reusable_checks };
-
-export {
-  gate_report,
-  check_reuse
-};

package/dist/commands/chunk-HYE3MBAN.js

@@ -1,113 +0,0 @@
-import {
-  git_gh_blocked_by_graphql
-} from "./chunk-LS7P324N.js";
-import {
-  ISSUE_FIELDS,
-  STATE_AND_RELATIONS_FIELDS,
-  git_gh_issue_graphql,
-  git_gh_issue_rest,
-  issue_fields_schema
-} from "./chunk-TFYYXETQ.js";
-import {
-  git_gh_transport
-} from "./chunk-LX2ENXHZ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-issue-batch-graphql.ts
-import { z } from "zod";
-var ALIAS_PREFIX = "issue";
-var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
-var repository_schema = z.record(z.string(), z.unknown());
-var data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
-var response_schema = z.looseObject({ data: data_schema });
-function alias_of(issue_number) {
-  return `${ALIAS_PREFIX}${String(issue_number)}`;
-}
-function query_of(issue_numbers) {
-  const aliases = issue_numbers.map(
-    (issue_number) => `${alias_of(issue_number)}: issueOrPullRequest(number: ${String(issue_number)}) { ... on Issue { ${ISSUE_FIELDS} } }`
-  );
-  return `query($owner: String!, $name: String!) {
-	rateLimit { cost remaining }
-	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
-}`;
-}
-function answered(json) {
-  return { kind: "read", json };
-}
-function to_read(issue, fields) {
-  const issue_json = git_gh_issue_rest.to_gh_issue(
-    git_gh_issue_graphql.to_rest_issue(issue),
-    git_gh_issue_rest.split_fields(fields),
-    git_gh_issue_graphql.to_blocked_by(issue)
-  );
-  return answered(JSON.stringify(issue_json));
-}
-async function query_chunk(issue_numbers, variables) {
-  const json = await git_gh_transport.query_partial({ query: query_of(issue_numbers), variables });
-  if (json === void 0) return void 0;
-  return json_value.parse_with(json, response_schema)?.data;
-}
-function answered_reads(request, data) {
-  return request.issue_numbers.flatMap((issue_number) => {
-    const issue = issue_fields_schema.safeParse(data.repository[alias_of(issue_number)]);
-    return issue.success ? [[issue_number, to_read(issue.data, request.fields)]] : [];
-  });
-}
-function with_chunk(batch, request, data) {
-  if (data === void 0) return batch;
-  return {
-    reads: new Map([...batch.reads, ...answered_reads(request, data)]),
-    cost: batch.cost + data.rateLimit.cost,
-    remaining: data.rateLimit.remaining
-  };
-}
-function empty_batch() {
-  return { reads: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
-}
-async function read_many(issue_numbers, repo, fields = STATE_AND_RELATIONS_FIELDS) {
-  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
-  let batch = empty_batch();
-  if (variables === void 0) return batch;
-  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
-  for (const chunk of chunks) {
-    const request = { issue_numbers: chunk, fields };
-    batch = with_chunk(batch, request, await query_chunk(chunk, variables));
-  }
-  return batch;
-}
-var git_gh_issue_batch_graphql = { answered, empty_batch, read_many };
-
-// scripts/gh/git-gh-issue-batch-read.ts
-async function read_each(issue_numbers, reader) {
-  const { reads } = await git_gh_issue_batch_graphql.read_many(
-    issue_numbers,
-    reader.repo,
-    reader.fields
-  );
-  return await Promise.all(
-    issue_numbers.map(async (issue_number) => {
-      const read = reads.get(issue_number);
-      const value = read?.kind === "read" ? reader.from_json(read.json) : await reader.read_rest(issue_number);
-      return [issue_number, value];
-    })
-  );
-}
-async function read_across(issues, reader_for) {
-  const repos = [...new Set(issues.map((issue) => issue.repo))];
-  const reads = await Promise.all(
-    repos.map(async (repo) => {
-      const numbers = issues.filter((issue) => issue.repo === repo).map((issue) => issue.number);
-      return new Map(await read_each(numbers, reader_for(repo)));
-    })
-  );
-  return issues.map((issue) => reads[repos.indexOf(issue.repo)]?.get(issue.number));
-}
-var git_gh_issue_batch_read = { read_across, read_each };
-
-export {
-  git_gh_issue_batch_graphql,
-  git_gh_issue_batch_read
-};

package/dist/commands/chunk-IAB6LCJL.js

@@ -1,18 +0,0 @@
-import {
-  hook_decision
-} from "./chunk-GB2BRQVL.js";
-
-// scripts/run/run-retrospective.ts
-var RETROSPECTIVE_ENV_KEY = "JOSH_RETROSPECTIVE";
-function is_enabled() {
-  return hook_decision.is_switch_opt_in(RETROSPECTIVE_ENV_KEY);
-}
-function is_owed(facts) {
-  if (!facts.is_retrospective_enabled) return false;
-  return !facts.is_lane_child && !facts.is_retrospective_done && !facts.is_consumer;
-}
-var run_retrospective = { is_enabled, is_owed };
-
-export {
-  run_retrospective
-};

package/dist/commands/chunk-IAGENI2U.js

@@ -1,42 +0,0 @@
-import {
-  has_stderr_field
-} from "./chunk-43DU7DYZ.js";
-
-// scripts/gh/git-gh-helpers.ts
-function parse_pr_state_string(result) {
-  const trimmed = result.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function is_pr_already_exists_message(error_message) {
-  return error_message.toLowerCase().includes("already exists");
-}
-function get_error_message_with_stderr(error) {
-  if (!(error instanceof Error)) return String(error);
-  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
-${error.stderr}`;
-  return error.message;
-}
-function handle_pr_create_error(error) {
-  const error_message = get_error_message_with_stderr(error);
-  if (is_pr_already_exists_message(error_message)) {
-    throw new Error("PR_ALREADY_EXISTS");
-  }
-  throw error;
-}
-var git_gh_helpers = {
-  parse_pr_state_string,
-  get_error_message_with_stderr,
-  handle_pr_create_error
-};
-
-// scripts/gh/git-gh-rest-state.ts
-var MERGED_STATE = "MERGED";
-function to_gh_state(state) {
-  return state?.toUpperCase();
-}
-
-export {
-  git_gh_helpers,
-  MERGED_STATE,
-  to_gh_state
-};