@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-5AZTSESD.js

@@ -1,114 +0,0 @@
-import {
-  backlog_ready,
-  backlog_stalled
-} from "./chunk-7OEBSPPU.js";
-import {
-  lane_ledger
-} from "./chunk-2O64H5UJ.js";
-import {
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-
-// scripts/backlog/backlog-stalled-detect.ts
-var NO_FREE = 0;
-var NO_READY = 0;
-var NO_AGE = 0;
-function ready_count_of(ready) {
-  return async function() {
-    const issues = await ready.ready_issues();
-    return issues.length;
-  };
-}
-async function real_emit_stall(text) {
-  const { STALL, CHILD_LAUNCH } = run_event_stream.EVENT_KIND;
-  return await run_event_stream_emit.emit_once_since(STALL, text, CHILD_LAUNCH);
-}
-async function read_real_ledger() {
-  const path = await lane_ledger.target();
-  return path === void 0 ? [] : lane_ledger.read_entries(path);
-}
-async function real_mark_offerable(is_offerable) {
-  await lane_ledger_write.record_offerable(is_offerable);
-}
-function ports_over(ready) {
-  return {
-    resolve_target: run_event_stream_emit.stream_target,
-    read_events: run_event_stream.read_events,
-    now_ms: () => Date.now(),
-    free_lane_count: ready.free_lane_count,
-    ready_count: ready_count_of(ready),
-    read_ledger: read_real_ledger,
-    mark_offerable: real_mark_offerable,
-    emit_stall: real_emit_stall
-  };
-}
-var DEFAULT_PORTS = ports_over(backlog_ready.DEFAULT_PORTS);
-function ok_reading() {
-  return { ready_count: NO_READY, free_lanes: NO_FREE, waiting_ms: NO_AGE };
-}
-async function read_counts(ports) {
-  const free_lanes = await ports.free_lane_count();
-  if (free_lanes <= NO_FREE) return { ready_count: NO_READY, free_lanes };
-  return { ready_count: await ports.ready_count(), free_lanes };
-}
-function has_both(counts) {
-  return counts.ready_count > NO_READY && counts.free_lanes > NO_FREE;
-}
-async function waiting_ms(ports, entries, clock, is_offerable) {
-  const opened_ms = backlog_stalled.open_offerable_ms(entries, clock.reference_ms);
-  if (is_offerable === (opened_ms !== void 0)) return clock.now_ms - (opened_ms ?? clock.now_ms);
-  await ports.mark_offerable(is_offerable);
-  return NO_AGE;
-}
-async function probe_reading(ports, clock) {
-  const counts = await read_counts(ports);
-  const entries = await ports.read_ledger();
-  const waited = await waiting_ms(ports, entries, clock, has_both(counts));
-  return { ...counts, waiting_ms: waited, hold: backlog_stalled.open_hold(entries) };
-}
-function clock_of(ports, target) {
-  const now_ms = ports.now_ms();
-  const age = backlog_stalled.dispatch_age_ms(ports.read_events(target), now_ms);
-  return age === void 0 ? void 0 : { reference_ms: now_ms - age, now_ms };
-}
-async function gather(ports, threshold_ms) {
-  const target = await ports.resolve_target();
-  if (target === void 0) return void 0;
-  const clock = clock_of(ports, target);
-  if (clock === void 0 || clock.now_ms - clock.reference_ms <= threshold_ms) return ok_reading();
-  return await probe_reading(ports, clock);
-}
-async function observe_offerable(is_offerable, ports = DEFAULT_PORTS) {
-  try {
-    const target = await ports.resolve_target();
-    const clock = target === void 0 ? void 0 : clock_of(ports, target);
-    if (clock !== void 0) await waiting_ms(ports, await ports.read_ledger(), clock, is_offerable);
-  } catch {
-  }
-}
-async function report(ports, reading) {
-  await ports.emit_stall(backlog_stalled.describe(reading));
-}
-async function detect_and_report(ports = DEFAULT_PORTS, threshold_ms = backlog_stalled.STALL_THRESHOLD_MS) {
-  const reading = await gather(ports, threshold_ms);
-  const verdict = backlog_stalled.assess(reading, threshold_ms);
-  if (reading !== void 0 && verdict === backlog_stalled.STALLED) await report(ports, reading);
-  return verdict;
-}
-async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
-  try {
-    await detect_and_report(ports_over(ready));
-  } catch {
-  }
-}
-var backlog_stalled_detect = { detect_and_report, observe_offerable, run_stall_check };
-
-export {
-  backlog_stalled_detect
-};

package/dist/commands/chunk-5FUI2MLY.js

@@ -1,89 +0,0 @@
-import {
-  run_park
-} from "./chunk-BPDNGJXY.js";
-import {
-  bash_triggers
-} from "./chunk-2BC33QPY.js";
-import {
-  shell_segments
-} from "./chunk-CVJHQOI3.js";
-import {
-  lane_handoff
-} from "./chunk-BRMJVCP7.js";
-import {
-  NEEDS_DECISION_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  lane_child_marker
-} from "./chunk-XXPDFJRI.js";
-
-// scripts/rules/lane-park.ts
-var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
-var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
-function is_confirmation_notify(command) {
-  return shell_segments.segments_of(command).some(
-    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
-  );
-}
-var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
-var COMMAND_NOTIFY_MARKER = "stop notified: a confirmation Telegram was sent by this command";
-function mentions_confirmation_notify(text) {
-  if (text.includes(COMMAND_NOTIFY_MARKER)) return true;
-  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
-}
-function is_parking_child(directory = process.cwd(), source = process.env) {
-  return lane_child_marker.is_child_of(directory, source) && !lane_handoff.is_handed_off(directory, source);
-}
-function is_unparked_child(directory = process.cwd(), source = process.env) {
-  if (!is_parking_child(directory, source)) return false;
-  const issue = lane_child_marker.marked_issue(source);
-  return issue === void 0 || !run_park.is_parked_sync(issue, directory);
-}
-function is_unparked_stop(command, is_child = is_unparked_child) {
-  if (!is_confirmation_notify(command)) return false;
-  return is_child();
-}
-function is_unparked_stop_in(command, context) {
-  return is_unparked_stop(command, () => is_unparked_child(context.cwd, context.env));
-}
-var APPLIES_NEEDS_DECISION = new RegExp(
-  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
-  "u"
-);
-var PARK_COMMANDS = /* @__PURE__ */ new Set(["run:park"]);
-var CLEAR_FLAG = /(?:^|\s)--clear\b/u;
-function is_park_command(segment) {
-  return shell_segments.is_josh_command(segment, PARK_COMMANDS) && !CLEAR_FLAG.test(segment);
-}
-function records_the_park(command) {
-  if (APPLIES_NEEDS_DECISION.test(command)) return true;
-  return shell_segments.segments_of(command).some((segment) => is_park_command(segment));
-}
-var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `pnpm josh run:park <N> --body-file <path>` (options, tiers, recommendation, stash \u2014 it applies `needs-decision`); a `needs-human-review` / `already-done` stop already is. The park is the stop: no notify after it. Refused once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
-var ROW = {
-  id: "lane-park",
-  is_trigger: bash_triggers.on_bash_command(is_unparked_stop_in),
-  reason: LANE_PARK_REASON,
-  keeps: bash_triggers.on_bash_command(records_the_park),
-  about: {
-    title: "Lane child park",
-    topic: "`.claude/skills/workflow-commands/pre-gate-cut.md`",
-    fires: "a dispatched lane child issuing `pnpm josh notify --task-type confirmation`",
-    quiet: "not a lane child, or not a stop notification"
-  }
-};
-var lane_park = {
-  COMMAND_NOTIFY_MARKER,
-  LANE_PARK_REASON,
-  ROW,
-  is_confirmation_notify,
-  is_parking_child,
-  is_unparked_child,
-  is_unparked_stop,
-  mentions_confirmation_notify,
-  records_the_park
-};
-
-export {
-  lane_park
-};

package/dist/commands/chunk-5IHEBIPD.js

@@ -1,333 +0,0 @@
-import {
-  MERGED_STATE,
-  git_gh_helpers,
-  to_gh_state
-} from "./chunk-IAGENI2U.js";
-import {
-  git_gh_issue_memo
-} from "./chunk-IPS7EBE5.js";
-import {
-  rest_comment_schema
-} from "./chunk-34DND4BA.js";
-import {
-  FULL_PAGE_QUERY,
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  gh_failure,
-  git_gh_exec,
-  parse_json_array_or_undefined,
-  parse_json_object_or_undefined
-} from "./chunk-43DU7DYZ.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/gh/git-gh-comments-unreadable.ts
-var UNREADABLE_COMMENTS_STOP = "the merge gate stopped on reviewer comments it could not read";
-var RETRY_PENDING_KEY = "JOSH_SHIP_RETRY_PENDING";
-var RETRY_PENDING_VALUE = "1";
-function note_unreadable_comments(branch_name, reason) {
-  console.warn(`\u26A0 pull request comments could not be read for ${branch_name}: ${reason}`);
-}
-function note_unreadable_stop() {
-  console.info(`\u26A0\uFE0F ${UNREADABLE_COMMENTS_STOP}`);
-}
-function is_retry_pending() {
-  return process.env[RETRY_PENDING_KEY] === RETRY_PENDING_VALUE;
-}
-
-// scripts/gh/git-gh-pr-rest.ts
-import { z } from "zod";
-var rest_repo_schema = z.looseObject({ full_name: z.string().optional() }).nullish();
-var rest_pull_side_schema = z.looseObject({ ref: z.string().optional(), repo: rest_repo_schema });
-var rest_pull_schema = z.looseObject({
-  number: z.number(),
-  html_url: z.string().optional(),
-  body: z.string().nullish(),
-  state: z.string().optional(),
-  merged: z.boolean().nullish(),
-  merged_at: z.string().nullish(),
-  mergeable: z.boolean().nullish(),
-  mergeable_state: z.string().optional(),
-  // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
-  // REST hangs the check runs and the status contexts off the commit rather than off the pull
-  // request.
-  head: z.looseObject({ ref: z.string().optional(), sha: z.string().optional(), repo: rest_repo_schema }).nullish(),
-  base: rest_pull_side_schema.nullish(),
-  // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
-  // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`.
-  node_id: z.string().optional(),
-  auto_merge: z.looseObject({}).nullish()
-});
-var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
-var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
-var NOT_A_COMMENT_LISTING_MESSAGE = "gh api answered something other than a comment listing";
-var OPEN_STATE = "open";
-var EMPTY_BODY = "";
-function parse_rest_pull(rest_json) {
-  const parsed = parse_json_object_or_undefined(rest_json, rest_pull_schema);
-  if (parsed === void 0) throw new Error(NOT_A_PULL_MESSAGE);
-  return parsed;
-}
-function parse_rest_pulls(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_pull_schema);
-  if (parsed === void 0) throw new Error(NOT_A_PULL_LISTING_MESSAGE);
-  return parsed;
-}
-function select_pull(pulls) {
-  return pulls.find((pull) => pull.state === OPEN_STATE) ?? pulls[0];
-}
-function is_merged(pull) {
-  return pull.merged === true || typeof pull.merged_at === "string";
-}
-function to_pr_state(pull) {
-  return is_merged(pull) ? MERGED_STATE : to_gh_state(pull.state);
-}
-function to_repo_name(side) {
-  return side?.repo?.full_name;
-}
-function is_same_repository_head(pull) {
-  const head_repo = to_repo_name(pull.head);
-  return head_repo !== void 0 && head_repo === to_repo_name(pull.base);
-}
-function to_pr_info(pull) {
-  return {
-    mergeable: pull.mergeable,
-    mergeStateStatus: to_gh_state(pull.mergeable_state),
-    state: to_pr_state(pull)
-  };
-}
-function to_pr_comments(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_comment_schema);
-  if (parsed === void 0) throw new Error(NOT_A_COMMENT_LISTING_MESSAGE);
-  return parsed.map((comment) => ({
-    body: comment.body ?? EMPTY_BODY,
-    url: comment.html_url,
-    author: { login: comment.user?.login },
-    updatedAt: comment.updated_at
-  }));
-}
-var git_gh_pr_rest = {
-  parse_rest_pull,
-  parse_rest_pulls,
-  select_pull,
-  is_same_repository_head,
-  is_merged,
-  to_pr_state,
-  to_pr_info,
-  to_pr_comments
-};
-
-// scripts/gh/git-gh-pr-too-large.ts
-var UNPROCESSABLE_STATUS = 422;
-var TOO_MANY_FILES_TEXT = "too many files changed";
-function is_too_many_files(error) {
-  if (gh_failure.failure_of(error)?.status !== UNPROCESSABLE_STATUS) return false;
-  return error_text.message_of(error).includes(TOO_MANY_FILES_TEXT);
-}
-var git_gh_pr_too_large = { is_too_many_files };
-
-// scripts/gh/git-gh-pr-read.ts
-var pr_number_by_branch = /* @__PURE__ */ new Map();
-var LOOKUP_QUERY = "state=all&sort=created&direction=desc&per_page=100";
-var COMMENTS_QUERY = FULL_PAGE_QUERY;
-var OWNER_PLACEHOLDER = "{owner}";
-var NO_PULL_REQUEST_MESSAGE = "gh api found no pull request for branch";
-var UNREADABLE_PULL_REQUEST_MESSAGE = "gh api could not read the pull requests for branch";
-function lookup_path(branch_name) {
-  const head = `${OWNER_PLACEHOLDER}:${encodeURIComponent(branch_name)}`;
-  return `${git_gh_api_path.pulls_api_path()}?head=${head}&${LOOKUP_QUERY}`;
-}
-async function fetch_branch_pull(branch_name) {
-  const json = await git_gh_exec.exec_gh_api({ path: lookup_path(branch_name) });
-  return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json));
-}
-async function fetch_pr_number(branch_name) {
-  const pull = await fetch_branch_pull(branch_name);
-  return pull?.number;
-}
-var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
-var pull_by_number = /* @__PURE__ */ new Map();
-async function fetch_pr_number_read(branch_name) {
-  try {
-    const pr_number = await fetch_pr_number(branch_name);
-    if (pr_number === void 0) return { kind: "missing" };
-    pr_number_by_branch.set(branch_name, pr_number);
-    return { kind: "read", pr_number };
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-async function start_pr_number_read(branch_name) {
-  const pending = pending_pr_number_by_branch.get(branch_name);
-  if (pending !== void 0) return await pending;
-  const lookup = fetch_pr_number_read(branch_name);
-  pending_pr_number_by_branch.set(branch_name, lookup);
-  try {
-    return await lookup;
-  } finally {
-    pending_pr_number_by_branch.delete(branch_name);
-  }
-}
-function forget_pr_numbers() {
-  pr_number_by_branch.clear();
-  pending_pr_number_by_branch.clear();
-  pull_by_number.clear();
-  git_gh_issue_memo.forget();
-}
-async function read_pr_number(branch_name) {
-  const cached = pr_number_by_branch.get(branch_name);
-  if (cached !== void 0) return { kind: "read", pr_number: cached };
-  return await start_pr_number_read(branch_name);
-}
-async function resolve_pr_number(branch_name) {
-  const read = await read_pr_number(branch_name);
-  return read.kind === "read" ? read.pr_number : void 0;
-}
-function to_unreadable_error(branch_name, cause) {
-  const [gist = ""] = error_text.message_of(cause).split("\n", 1);
-  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name} (${gist})`, { cause });
-}
-async function require_pr_number(branch_name) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind === "read") return read.pr_number;
-  if (read.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
-  throw to_unreadable_error(branch_name, read.cause);
-}
-async function read_pull(pr_number) {
-  const json = await git_gh_exec.exec_gh_api({
-    path: git_gh_api_path.pull_api_path(String(pr_number))
-  });
-  return git_gh_pr_rest.parse_rest_pull(json);
-}
-async function read_remembered_pull(pr_number) {
-  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
-  pull_by_number.set(pr_number, pending);
-  try {
-    return await pending;
-  } catch (error) {
-    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
-    throw error;
-  }
-}
-async function read_listed_pull(detail_error, branch_name, pr_number) {
-  if (!git_gh_pr_too_large.is_too_many_files(detail_error)) return void 0;
-  const pull = await fetch_branch_pull(branch_name);
-  return pull?.number === pr_number ? pull : void 0;
-}
-async function read_pull_or_listed(branch_name, pr_number, read) {
-  try {
-    return await read(pr_number);
-  } catch (error) {
-    const listed = await read_listed_pull(error, branch_name, pr_number);
-    if (listed === void 0) throw error;
-    return listed;
-  }
-}
-async function read_pull_of_branch(branch_name, read = read_remembered_pull) {
-  const number_read = await read_pr_number(branch_name);
-  if (number_read.kind !== "read") return number_read;
-  try {
-    return {
-      kind: "read",
-      pull: await read_pull_or_listed(branch_name, number_read.pr_number, read)
-    };
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-async function read_pull_or_undefined(branch_name) {
-  const read = await read_pull_of_branch(branch_name);
-  return read.kind === "read" ? read.pull : void 0;
-}
-async function pr_exists(branch_name) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
-  return read.kind === "read";
-}
-async function pr_get_number(branch_name) {
-  return await resolve_pr_number(branch_name);
-}
-async function pr_get_url(branch_name) {
-  const pull = await read_pull_or_undefined(branch_name);
-  if (pull?.html_url === void 0) return void 0;
-  return git_gh_helpers.parse_pr_state_string(pull.html_url);
-}
-async function pr_get_merge_state(branch_name) {
-  const read = await read_pull_of_branch(branch_name, read_pull);
-  if (read.kind !== "read") return void 0;
-  const { pull } = read;
-  return {
-    is_merged: git_gh_pr_rest.is_merged(pull),
-    merged_at: pull.merged_at ?? void 0,
-    head_sha: pull.head?.sha,
-    merge_state_status: to_gh_state(pull.mergeable_state)
-  };
-}
-async function pr_get_body(branch_name) {
-  const pull = await read_pull_or_undefined(branch_name);
-  const body = pull?.body;
-  return typeof body === "string" && body.length > 0 ? body : void 0;
-}
-async function pr_view(branch_name) {
-  const read = await read_pull_of_branch(branch_name, read_pull);
-  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
-  if (read.kind === "missing") return "";
-  return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull));
-}
-function unresolved_reason(read) {
-  return read.kind === "unreadable" ? error_text.message_of(read.cause) : NO_PULL_REQUEST_MESSAGE;
-}
-async function read_comments(branch_name, to_path, to_json) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind !== "read") {
-    note_unreadable_comments(branch_name, unresolved_reason(read));
-    return void 0;
-  }
-  const path = `${to_path(String(read.pr_number))}${COMMENTS_QUERY}`;
-  try {
-    return to_json(await git_gh_exec.exec_gh_api({ path, should_paginate: true }));
-  } catch (error) {
-    note_unreadable_comments(branch_name, error_text.message_of(error));
-    return void 0;
-  }
-}
-function to_comments_json(raw) {
-  return JSON.stringify(git_gh_pr_rest.to_pr_comments(raw));
-}
-function as_served(raw) {
-  return raw;
-}
-async function pr_get_comments(branch_name) {
-  return await read_comments(branch_name, git_gh_api_path.issue_comments_api_path, to_comments_json);
-}
-async function pr_get_review_comments(branch_name) {
-  return await read_comments(branch_name, git_gh_api_path.pull_comments_api_path, as_served);
-}
-var git_gh_pr_read = {
-  pr_exists,
-  pr_get_number,
-  pr_get_url,
-  pr_get_body,
-  pr_get_merge_state,
-  pr_view,
-  pr_get_comments,
-  pr_get_review_comments
-};
-
-export {
-  UNREADABLE_COMMENTS_STOP,
-  RETRY_PENDING_KEY,
-  RETRY_PENDING_VALUE,
-  note_unreadable_stop,
-  is_retry_pending,
-  git_gh_pr_rest,
-  git_gh_pr_too_large,
-  forget_pr_numbers,
-  require_pr_number,
-  read_pull,
-  read_listed_pull,
-  read_pull_or_listed,
-  git_gh_pr_read
-};

package/dist/commands/chunk-5KAW5GPF.js

@@ -1,44 +0,0 @@
-import {
-  run_progress_clock
-} from "./chunk-3YT3RCSI.js";
-import {
-  run_headless
-} from "./chunk-Q4ULMZAS.js";
-import {
-  lane_registry
-} from "./chunk-NEOCCN6D.js";
-import {
-  lane_reap
-} from "./chunk-ON4IKRGS.js";
-import {
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/run/run-watcher-guard.ts
-var WATCHER_TICK_MS = 3e4;
-var TICK_MULTIPLIER = 3;
-var STALE_THRESHOLD_MS = WATCHER_TICK_MS * TICK_MULTIPLIER;
-var STALE_THRESHOLD_S = STALE_THRESHOLD_MS / MS_PER_SECOND;
-var STALE_NOTE = `Lane children are in-flight but the progress watcher has not pinged in the last ${String(STALE_THRESHOLD_S)}s \u2014 run \`pnpm josh run:progress --wait\` in the background before proceeding. It reports to the run event stream on its own and exits only when newly runnable work arrives, so start it once and relay nothing`;
-var OK_RESULT = { kind: "ok" };
-async function owes_watcher(ancestry) {
-  if (run_headless.is_headless() || !await run_headless.is_backlog_parent(process.env, ancestry)) {
-    return false;
-  }
-  return await lane_registry.has_lanes_in_flight();
-}
-async function check(life_target, ancestry = lane_reap.own_ancestry) {
-  if (!await owes_watcher(ancestry) || run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) {
-    return OK_RESULT;
-  }
-  return { kind: "stale", note: STALE_NOTE };
-}
-var run_watcher_guard = {
-  STALE_NOTE,
-  STALE_THRESHOLD_MS,
-  check
-};
-
-export {
-  run_watcher_guard
-};

package/dist/commands/chunk-5KSJEWXR.js

@@ -1,77 +0,0 @@
-import {
-  git_gh_exec
-} from "./chunk-43DU7DYZ.js";
-import {
-  git_location_environment,
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  COMMAND_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/init/start-exec.ts
-import { execaSync } from "execa";
-var SUCCESS_EXIT_CODE = 0;
-var GIT_DIRECTORY = ".git";
-var IDENTITY_VARIABLES = ["GIT_AUTHOR_IDENT", "GIT_COMMITTER_IDENT"];
-function root_environment() {
-  return git_location_environment.location_free_environment();
-}
-function git_succeeds(args, root) {
-  return git_spawn_sync.run(args, { cwd: root, env: root_environment() }).exit_code === 0;
-}
-function git_read(args, root) {
-  return git_spawn_sync.read(args, { cwd: root, env: root_environment() });
-}
-function is_identity_refused(variable, options) {
-  const { exit_code } = git_spawn_sync.run(["var", variable], options);
-  return exit_code !== void 0 && exit_code !== SUCCESS_EXIT_CODE;
-}
-function lacks_git_identity(root, is_new_repository) {
-  const location = is_new_repository ? { GIT_DIR: GIT_DIRECTORY } : {};
-  const options = { cwd: root, env: { ...root_environment(), ...location } };
-  return IDENTITY_VARIABLES.some((variable) => is_identity_refused(variable, options));
-}
-function git_run(args, root) {
-  const options = { cwd: root, env: root_environment(), timeout: SUITE_TIMEOUT_MS };
-  const { exit_code } = git_spawn_sync.run(args, { ...options, stdio: "inherit" });
-  if (exit_code === SUCCESS_EXIT_CODE) return;
-  const outcome = exit_code === void 0 ? "did not finish" : `exited with ${String(exit_code)}`;
-  throw new Error(`git ${args.join(" ")} ${outcome}`);
-}
-function gh_probe_options(root) {
-  const environment = { ...root_environment(), ...git_gh_exec.direct_environment().env };
-  return { cwd: root, env: environment, timeout: COMMAND_TIMEOUT_MS, reject: false };
-}
-function is_gh_installed(root) {
-  const result = execaSync("gh", ["--version"], gh_probe_options(root));
-  return result.exitCode === SUCCESS_EXIT_CODE;
-}
-function is_gh_signed_in(root) {
-  const result = execaSync("gh", ["auth", "status"], gh_probe_options(root));
-  return result.exitCode === SUCCESS_EXIT_CODE;
-}
-function create_github_repository(name, visibility, root) {
-  const source = ["--source", ".", "--remote", "origin", "--push"];
-  const { env } = gh_probe_options(root);
-  const options = { cwd: root, env, timeout: SUITE_TIMEOUT_MS, stdio: "inherit" };
-  execaSync("gh", ["repo", "create", name, `--${visibility}`, ...source], options);
-}
-function run_local(command, args, root) {
-  execaSync(command, args, { cwd: root, stdio: "inherit" });
-}
-var start_exec = {
-  git_succeeds,
-  git_read,
-  git_run,
-  lacks_git_identity,
-  is_gh_installed,
-  is_gh_signed_in,
-  create_github_repository,
-  run_local
-};
-
-export {
-  start_exec
-};