@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/version/index.js

@@ -85,6 +85,7 @@ var ancestor_directories = { list, nearest };
 // scripts/lib/package-manifest.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 import path2 from "node:path";
+import { z } from "zod";
 
 // scripts/lib/json-value.ts
 function parse_or_undefined(text) {
@@ -137,6 +138,28 @@ var file_reader = { is_absent, read_optional, read_file_or_empty, read_if_readab
 
 // scripts/lib/package-manifest.ts
 var PACKAGE_JSON = "package.json";
+var REVIEW_GATE_SCHEMA = z.enum(["ci", "local"]);
+var FORMAT_SCHEMA = z.enum(["auto", "all"]);
+var LANE_SCHEMA = z.object({ setup: z.string().min(1) });
+var GATE_STEP_SCHEMA = z.strictObject({
+  name: z.string().min(1),
+  command: z.string().min(1),
+  paths: z.array(z.string().min(1)).min(1).optional(),
+  cores: z.int().positive().optional()
+});
+var GATE_STEPS_SCHEMA = z.array(GATE_STEP_SCHEMA).refine((steps) => new Set(steps.map((step) => step.name)).size === steps.length, {
+  message: "step names must be unique"
+});
+var GATE_SCHEMA = z.object({ steps: GATE_STEPS_SCHEMA.optional() });
+var josh_schemas = {
+  format: z.object({ josh: z.object({ format: FORMAT_SCHEMA.optional() }).optional() }),
+  gate_steps: z.object({ josh: z.object({ gate: GATE_SCHEMA.optional() }).optional() }),
+  lane_setup: z.object({ josh: z.object({ lane: LANE_SCHEMA.optional() }).optional() }),
+  progress_interval_minutes: z.object({
+    josh: z.object({ progress_interval_minutes: z.number().positive() }).optional()
+  }),
+  review_gate: z.object({ josh: z.object({ review_gate: REVIEW_GATE_SCHEMA }).optional() })
+};
 function manifest_path(directory) {
   return path2.join(directory, PACKAGE_JSON);
 }
@@ -149,39 +172,53 @@ function read_manifest_if_valid(directory, schema) {
   if (text === void 0) return void 0;
   return json_value.parse_with(text, schema);
 }
-var package_manifest = { manifest_path, read_manifest, read_manifest_if_valid };
+function read_nearest_value(start, schema, select) {
+  const value_schema = schema.transform(select);
+  for (const directory of ancestor_directories.list(start)) {
+    const value = read_manifest_if_valid(directory, value_schema);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+var package_manifest = {
+  josh_schemas,
+  manifest_path,
+  read_manifest,
+  read_manifest_if_valid,
+  read_nearest_value
+};
 
 // scripts/lib/schemas.ts
-import { z } from "zod";
-var overrides_snapshot_schema = z.record(z.string(), z.string());
-var package_version_schema = z.object({ version: z.string() });
-var package_named_version_schema = z.looseObject({ name: z.string(), version: z.string() });
-var package_with_version_schema = z.looseObject({ version: z.string() });
-var ls_global_dependency_schema = z.looseObject({ version: z.string() });
-var ls_global_dependencies_schema = z.record(z.string(), ls_global_dependency_schema).optional();
-var pnpm_ls_global_schema = z.array(
-  z.looseObject({
+import { z as z2 } from "zod";
+var overrides_snapshot_schema = z2.record(z2.string(), z2.string());
+var package_version_schema = z2.object({ version: z2.string() });
+var package_named_version_schema = z2.looseObject({ name: z2.string(), version: z2.string() });
+var package_with_version_schema = z2.looseObject({ version: z2.string() });
+var ls_global_dependency_schema = z2.looseObject({ version: z2.string() });
+var ls_global_dependencies_schema = z2.record(z2.string(), ls_global_dependency_schema).optional();
+var pnpm_ls_global_schema = z2.array(
+  z2.looseObject({
     dependencies: ls_global_dependencies_schema
   })
 );
-var vscode_settings_schema = z.record(z.string(), z.unknown());
-var with_scripts_schema = z.looseObject({
-  scripts: z.record(z.string(), z.string()).optional()
+var vscode_settings_schema = z2.record(z2.string(), z2.unknown());
+var with_scripts_schema = z2.looseObject({
+  scripts: z2.record(z2.string(), z2.string()).optional()
 });
-var with_development_deps_schema = z.looseObject({
-  devDependencies: z.record(z.string(), z.string()).optional()
+var with_development_deps_schema = z2.looseObject({
+  devDependencies: z2.record(z2.string(), z2.string()).optional()
 });
-var with_package_manager_schema = z.looseObject({
-  packageManager: z.string().optional()
+var with_package_manager_schema = z2.looseObject({
+  packageManager: z2.string().optional()
 });
-var with_development_engine_schema = z.looseObject({
-  devEngines: z.record(z.string(), z.unknown()).optional()
+var with_development_engine_schema = z2.looseObject({
+  devEngines: z2.record(z2.string(), z2.unknown()).optional()
 });
-var bin_entry_schema = z.union([z.string(), z.record(z.string(), z.string())]).optional();
-var package_bin_schema = z.looseObject({ bin: bin_entry_schema });
-var json_object_schema = z.record(z.string(), z.unknown());
-var string_array_schema = z.array(z.string());
-var string_record_schema = z.record(z.string(), z.string());
+var bin_entry_schema = z2.union([z2.string(), z2.record(z2.string(), z2.string())]).optional();
+var package_bin_schema = z2.looseObject({ bin: bin_entry_schema });
+var json_object_schema = z2.record(z2.string(), z2.unknown());
+var string_array_schema = z2.array(z2.string());
+var string_record_schema = z2.record(z2.string(), z2.string());
 
 // scripts/version/effective-upstream.ts
 function read_matching_version(directory, package_name) {
@@ -251,11 +288,11 @@ var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
 
 // scripts/version/release-age.ts
 import semver from "semver";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var NO_QUARANTINE_MINUTES = 0;
 var WORKSPACE_PATH = "pnpm-workspace.yaml";
-var workspace_age_schema = z2.object({ minimumReleaseAge: z2.number().int().nonnegative() });
-var release_times_schema = z2.record(z2.string(), z2.string());
+var workspace_age_schema = z3.object({ minimumReleaseAge: z3.number().int().nonnegative() });
+var release_times_schema = z3.record(z3.string(), z3.string());
 function parse_workspace(workspace_content) {
   try {
     return yaml_document.parse_yaml(workspace_content);
@@ -531,8 +568,8 @@ function build_upstream_upgrade_commands(reports) {
     ...build_project_upgrade_commands(report)
   ]);
 }
-function build_dual_upgrade_commands(snapshot, config) {
-  const { global_version, project_version, latest } = snapshot;
+function build_dual_upgrade_commands(snapshot2, config) {
+  const { global_version, project_version, latest } = snapshot2;
   const commands = [];
   if (is_target_stale(global_version, latest)) {
     commands.push(build_upgrade_command(latest, false, config));
@@ -542,23 +579,23 @@ function build_dual_upgrade_commands(snapshot, config) {
   }
   return commands;
 }
-function format_target_lines(snapshot) {
-  const { global_version, project_version, latest } = snapshot;
+function format_target_lines(snapshot2) {
+  const { global_version, project_version, latest } = snapshot2;
   return [
     format_target_line(GLOBAL_LABEL, global_version, latest),
     format_target_line(PROJECT_LABEL, project_version, latest),
     `  ${LATEST_LABEL} ${latest}`
   ];
 }
-function format_dual_version_output(snapshot, config, extras = {}, upstreams = []) {
+function format_dual_version_output(snapshot2, config, extras = {}, upstreams = []) {
   const lines = [
     config.package_name,
-    ...format_target_lines(snapshot),
+    ...format_target_lines(snapshot2),
     ...format_running_line(extras.running),
     ...upstreams.flatMap((report) => format_upstream_lines(report))
   ];
   const hints = unique_upgrade_commands([
-    ...build_dual_upgrade_commands(snapshot, config),
+    ...build_dual_upgrade_commands(snapshot2, config),
     ...build_upstream_upgrade_commands(upstreams)
   ]).map((command) => `Run: ${command.text}`);
   if (hints.length > 0) lines.push("", ...hints);
@@ -594,6 +631,13 @@ function has_timed_out(error) {
 // scripts/josh/agent-session-environment.ts
 var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
 var AGENT_PID_KEY = "CLAUDE_PID";
+function session_pid(environment = process.env) {
+  const pid = Number(environment[AGENT_PID_KEY]);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+function own_session_pid(environment = process.env) {
+  return environment[SESSION_ID_KEY] === void 0 ? void 0 : session_pid(environment);
+}
 var PARENT_SESSION_KEYS = [
   "CLAUDE_CODE_MESSAGING_SOCKET",
   "CLAUDE_CODE_MESSAGING_TOKEN",
@@ -670,10 +714,69 @@ var agent_session_environment = {
   PROXY_CERTIFICATE_KEY,
   PROXY_KEYS,
   SESSION_ID_KEY,
+  own_session_pid,
   removed_environment,
-  removed_proxy_environment
+  removed_proxy_environment,
+  session_pid
 };
 
+// scripts/lib/bounded-pool.ts
+function pool_width(limit, total) {
+  if (!Number.isFinite(limit)) return 1;
+  return Math.max(1, Math.min(Math.floor(limit), total));
+}
+function throw_first_failure(failures) {
+  if (failures.length === 0) return;
+  const [first] = failures;
+  throw first;
+}
+async function drain(pool, worker) {
+  for (let entry = pool.queue.shift(); entry !== void 0 && pool.failures.length === 0; entry = pool.queue.shift()) {
+    const [index, item] = entry;
+    try {
+      pool.results.push({ index, value: await worker(item, index) });
+    } catch (error) {
+      pool.failures.push(error);
+    }
+  }
+}
+async function bounded_map(items, limit, worker) {
+  const pool = {
+    failures: [],
+    queue: items.map((item, index) => [index, item]),
+    results: []
+  };
+  const consumers = Array.from({ length: pool_width(limit, items.length) }, async () => {
+    await drain(pool, worker);
+  });
+  await Promise.all(consumers);
+  throw_first_failure(pool.failures);
+  return pool.results.toSorted((left, right) => left.index - right.index).map((result) => result.value);
+}
+function limiter(limit) {
+  const width = pool_width(limit, Infinity);
+  const waiting = [];
+  let active = 0;
+  return {
+    async run(task) {
+      if (active < width) active += 1;
+      else {
+        await new Promise((resolve) => {
+          waiting.push(resolve);
+        });
+      }
+      try {
+        return await task();
+      } finally {
+        const next = waiting.shift();
+        if (next === void 0) active -= 1;
+        else next();
+      }
+    }
+  };
+}
+var bounded_pool = { bounded_map, limiter, pool_width };
+
 // scripts/lib/error-message.ts
 function message_of(error) {
   return error instanceof Error ? error.message : String(error);
@@ -758,6 +861,400 @@ var token_shape = {
 // scripts/gh/git-gh-exec.ts
 import { execa as execa2, execaSync } from "execa";
 
+// scripts/rules/git-argv.ts
+var ENV_ASSIGNMENT = /^[A-Za-z_]\w*=/u;
+var WORD_QUOTING = /["'\\]/gu;
+var WRAPPER_WORDS = /* @__PURE__ */ new Set([
+  "pnpm",
+  "npx",
+  "exec",
+  "run",
+  "sudo",
+  "command",
+  "env",
+  "time"
+]);
+var FLAGGED_WRAPPERS = /* @__PURE__ */ new Set(["time", "pnpm", "env"]);
+var WRAPPER_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-o",
+  "-f",
+  "--output",
+  "--format",
+  "-C",
+  "--dir",
+  "--filter",
+  "-u",
+  "--unset"
+]);
+var SUBSHELL_OPEN = "(";
+var CONFIG_ENV = "--config-env";
+var ATTACHED_CONFIG = /^(?:-c|--config-env=)(.+)$/u;
+var VALUE_TAKING_GLOBALS = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--super-prefix",
+  CONFIG_ENV
+]);
+var FLAG_PREFIX = "-";
+var GIT_COMMAND = "git";
+var NEXT = 1;
+var AFTER_VALUE = 2;
+var WORD = /(?:\\.|'[^']*'|"(?:\\.|[^"\\])*"|\S)+/gsu;
+function words_of(segment) {
+  return segment.match(WORD) ?? [];
+}
+var PATH_SEPARATOR2 = "/";
+function program_name(word) {
+  return word.slice(word.lastIndexOf(PATH_SEPARATOR2) + NEXT);
+}
+function is_wrapper_token(word) {
+  return word === SUBSHELL_OPEN || ENV_ASSIGNMENT.test(word.replaceAll(WORD_QUOTING, "")) || WRAPPER_WORDS.has(program_name(word));
+}
+function wrapper_flag_width(word = "") {
+  if (!word.startsWith(FLAG_PREFIX)) return 0;
+  return WRAPPER_VALUE_FLAGS.has(word) ? AFTER_VALUE : NEXT;
+}
+function after_wrapper_word(words, index) {
+  let next = index + NEXT;
+  if (!FLAGGED_WRAPPERS.has(program_name(words[index] ?? ""))) return next;
+  let width = wrapper_flag_width(words[next]);
+  while (width > 0) {
+    next += width;
+    width = wrapper_flag_width(words[next]);
+  }
+  return next;
+}
+function after_wrapper(words) {
+  let index = 0;
+  while (index < words.length && is_wrapper_token(words[index] ?? "")) {
+    index = after_wrapper_word(words, index);
+  }
+  return index;
+}
+function global_step(flag) {
+  return VALUE_TAKING_GLOBALS.has(flag) ? AFTER_VALUE : NEXT;
+}
+function after_globals(words) {
+  let index = 0;
+  while (index < words.length) {
+    const flag = words[index] ?? "";
+    if (!flag.startsWith(FLAG_PREFIX)) return index;
+    index += global_step(flag);
+  }
+  return index;
+}
+function program_of(segment) {
+  const words = words_of(segment);
+  const command_index = after_wrapper(words);
+  const word = words[command_index];
+  if (word === void 0) return void 0;
+  return { name: program_name(word), args: words.slice(command_index + NEXT) };
+}
+function arguments_of(segment, command) {
+  const call = program_of(segment);
+  return call?.name === command ? call.args : void 0;
+}
+function parse(segment) {
+  const words = arguments_of(segment, GIT_COMMAND);
+  if (words === void 0) return void 0;
+  const subcommand_index = after_globals(words);
+  return { subcommand: words[subcommand_index], args: words.slice(subcommand_index + NEXT) };
+}
+function config_value(flag, next) {
+  if (flag === "-c" || flag === CONFIG_ENV) return next;
+  return ATTACHED_CONFIG.exec(flag)?.[1];
+}
+function config_arguments_of(segment) {
+  const words = arguments_of(segment, GIT_COMMAND) ?? [];
+  const values = [];
+  const end = after_globals(words);
+  let index = 0;
+  while (index < end) {
+    const flag = words[index] ?? "";
+    const value = config_value(flag, words[index + NEXT]);
+    if (value !== void 0) values.push(value);
+    index += global_step(flag);
+  }
+  return values;
+}
+var SHORT_CLUSTER = /^-[A-Za-z]+$/u;
+function short_cluster_has(token, letters) {
+  if (!SHORT_CLUSTER.test(token)) return false;
+  const cluster = token.slice(FLAG_PREFIX.length);
+  for (let index = 0; index < letters.length; index += 1) {
+    if (cluster.includes(letters.charAt(index))) return true;
+  }
+  return false;
+}
+var git_argv = {
+  arguments_of,
+  config_arguments_of,
+  parse,
+  program_of,
+  short_cluster_has,
+  words_of
+};
+
+// scripts/rules/gh-api.ts
+var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
+var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
+var GH_COMMAND = "gh";
+var METHOD_FLAGS = /* @__PURE__ */ new Set(["-X", "--method"]);
+var ATTACHED_METHOD = /^(?:-X=?|--method=)([A-Za-z]+)$/u;
+var FIELD_FLAGS = /* @__PURE__ */ new Set(["-f", "-F", "--field", "--raw-field", "--input"]);
+var ATTACHED_FIELD = /^(?:-[fF].|--(?:raw-field|field|input)=)/u;
+var QUOTES = /['"]/gu;
+var FLAG_PREFIX2 = "-";
+var NEXT2 = 1;
+var READ_METHOD = "GET";
+var API_VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  "-R",
+  "--repo",
+  ...METHOD_FLAGS,
+  ...FIELD_FLAGS,
+  "-H",
+  "--header",
+  "-q",
+  "--jq",
+  "-t",
+  "--template",
+  "--hostname",
+  "-p",
+  "--preview",
+  "--cache"
+]);
+var INCLUDE_CLUSTER = /^-i+(?=[A-Za-z])/u;
+var REPO_PATH = /repos\/([^/\s'"?]+)\/([^/\s'"?]+)/u;
+var OWNER_GROUP = 1;
+var REPO_GROUP = 2;
+var OWNER_PLACEHOLDERS = /* @__PURE__ */ new Set(["{owner}", ":owner"]);
+function is_gh_api(segment) {
+  return GH_API_COMMAND.test(segment);
+}
+function flags_of(segment) {
+  const words = (git_argv.arguments_of(segment, GH_COMMAND) ?? []).map(
+    (word) => word.replace(INCLUDE_CLUSTER, "-")
+  );
+  let has_value_pending = false;
+  return words.map((word, index) => [word, words[index + NEXT2] ?? ""]).filter(([word]) => {
+    if (has_value_pending) {
+      has_value_pending = false;
+      return false;
+    }
+    has_value_pending = API_VALUE_TAKING_FLAGS.has(word);
+    return word.startsWith(FLAG_PREFIX2);
+  });
+}
+function method_value(flag, next) {
+  if (METHOD_FLAGS.has(flag)) return next.replaceAll(QUOTES, "");
+  return ATTACHED_METHOD.exec(flag)?.[1];
+}
+function method_of(segment) {
+  const methods = flags_of(segment).map(([flag, next]) => method_value(flag, next));
+  return methods.findLast((method) => method !== void 0)?.toUpperCase();
+}
+function is_field_flag(flag) {
+  return FIELD_FLAGS.has(flag) || ATTACHED_FIELD.test(flag);
+}
+function is_read(segment) {
+  const method = method_of(segment);
+  if (method !== void 0) return method === READ_METHOD;
+  return flags_of(segment).every(([flag]) => !is_field_flag(flag));
+}
+function is_write(segment) {
+  return !is_read(segment);
+}
+var INPUT_FLAG = "--input";
+var READS_FILE_FLAGS = /* @__PURE__ */ new Set(["-F", "--field"]);
+var ATTACHED_PARTS = /^(-[fF]|--(?:raw-field|field|input))=?(.+)$/u;
+var ATTACHED_FLAG_GROUP = 1;
+var ATTACHED_VALUE_GROUP = 2;
+var FILE_PREFIX = "@";
+var STANDARD_INPUT = "-";
+var FIELD_KEY_END = "=";
+function field_parts(flag, next) {
+  if (FIELD_FLAGS.has(flag)) return [flag, next];
+  const match = ATTACHED_PARTS.exec(flag);
+  if (match === null) return void 0;
+  return [String(match[ATTACHED_FLAG_GROUP]), String(match[ATTACHED_VALUE_GROUP])];
+}
+function field_value(value) {
+  return value.slice(value.indexOf(FIELD_KEY_END) + NEXT2);
+}
+function file_path(flag, value) {
+  if (flag === INPUT_FLAG) return value;
+  const sent = field_value(value);
+  if (!READS_FILE_FLAGS.has(flag) || !sent.startsWith(FILE_PREFIX)) return void 0;
+  return sent.slice(FILE_PREFIX.length);
+}
+function field_source(flag, raw) {
+  const value = raw.replaceAll(QUOTES, "");
+  const path7 = file_path(flag, value);
+  if (path7 === void 0) return { kind: "text", value: field_value(value) };
+  return path7 === STANDARD_INPUT ? void 0 : { kind: "file", value: path7 };
+}
+function field_sources(segment) {
+  return flags_of(segment).flatMap(([flag, next]) => {
+    const parts = field_parts(flag, next);
+    const source = parts === void 0 ? void 0 : field_source(...parts);
+    return source === void 0 ? [] : [source];
+  });
+}
+function repo_target(segment) {
+  const match = REPO_PATH.exec(segment);
+  if (match === null) return void 0;
+  return { owner: match[OWNER_GROUP] ?? "", repo: match[REPO_GROUP] ?? "" };
+}
+function is_owner_placeholder(owner) {
+  return OWNER_PLACEHOLDERS.has(owner);
+}
+var gh_api = {
+  API_VALUE_TAKING_FLAGS,
+  FIELD_FLAGS,
+  GH_FLAGS,
+  METHOD_FLAGS,
+  field_sources,
+  is_gh_api,
+  is_owner_placeholder,
+  is_read,
+  is_write,
+  method_of,
+  repo_target
+};
+
+// scripts/gh/gh-call-kind.ts
+var API = "api";
+var GRAPHQL = "graphql";
+var RATE_LIMIT = "GET rate_limit";
+var GH_PREFIX = "gh ";
+var DEFAULT_METHOD = "GET";
+var BODY_METHOD = "POST";
+var OWNER_REPO = ["repos", "{o}", "{r}"];
+var NUMBER = /^\d+$/u;
+var SHA = /^[\da-f]{7,40}$/u;
+var { METHOD_FLAGS: METHOD_FLAGS2, FIELD_FLAGS: BODY_FLAGS, API_VALUE_TAKING_FLAGS: VALUE_FLAGS } = gh_api;
+var NAME_AFTER = /* @__PURE__ */ new Map([
+  ["commits", "{ref}"],
+  ["branches", "{branch}"],
+  ["heads", "{branch}"],
+  ["labels", "{label}"],
+  ["compare", "{range}"]
+]);
+function placeholder_of(segment, previous = "") {
+  const named = NAME_AFTER.get(previous);
+  if (named !== void 0) return named;
+  if (NUMBER.test(segment)) return "{n}";
+  return SHA.test(segment) ? "{sha}" : segment;
+}
+function normalized(path7) {
+  const [bare = ""] = path7.replace(/^\//u, "").split("?", 1);
+  const segments = bare.split("/");
+  const is_repo = segments[0] === OWNER_REPO[0];
+  return segments.map(
+    (segment, index) => is_repo && index < OWNER_REPO.length ? OWNER_REPO[index] : placeholder_of(segment, segments[index - 1])
+  ).join("/");
+}
+function of_api(path7, method = DEFAULT_METHOD) {
+  const bare = normalized(path7);
+  return bare === GRAPHQL ? GRAPHQL : `${method.toUpperCase()} ${bare}`;
+}
+function path_of(arguments_) {
+  const rest = arguments_.slice(1);
+  return rest.find(
+    (argument, index) => !argument.startsWith("-") && !VALUE_FLAGS.has(rest[index - 1] ?? "")
+  ) ?? "";
+}
+function method_of2(arguments_) {
+  const flag = arguments_.findIndex((argument) => METHOD_FLAGS2.has(argument));
+  if (flag !== -1) return arguments_[flag + 1] ?? DEFAULT_METHOD;
+  return arguments_.some((argument) => BODY_FLAGS.has(argument)) ? BODY_METHOD : DEFAULT_METHOD;
+}
+function of(arguments_) {
+  const [subcommand = "", action = ""] = arguments_;
+  if (subcommand === API) return of_api(path_of(arguments_), method_of2(arguments_));
+  const named = action.startsWith("-") ? [subcommand] : [subcommand, action];
+  return `${GH_PREFIX}${named.join(" ")}`.trimEnd();
+}
+function class_of(kind) {
+  if (kind === GRAPHQL) return "graphql";
+  if (kind === RATE_LIMIT) return "free";
+  return kind.startsWith(GH_PREFIX) ? "gh" : "rest";
+}
+var gh_call_kind = { of, of_api, class_of };
+
+// scripts/gh/gh-request-tally.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("josh.gh-request-tally");
+function is_state(value) {
+  return typeof value === "object" && value !== null && Reflect.has(value, "endpoints");
+}
+function shared_state() {
+  const existing = Reflect.get(globalThis, STATE_KEY);
+  if (is_state(existing)) return existing;
+  const state = {
+    tally: { calls: 0, not_modified: 0 },
+    endpoints: /* @__PURE__ */ new Map(),
+    core: { read: void 0, start: void 0 }
+  };
+  Reflect.set(globalThis, STATE_KEY, state);
+  return state;
+}
+var { tally, endpoints, core } = shared_state();
+function watch_core(read) {
+  core.read = async () => {
+    try {
+      return await read();
+    } catch {
+      return void 0;
+    }
+  };
+}
+function endpoint_of(kind) {
+  const count = endpoints.get(kind) ?? { calls: 0, not_modified: 0 };
+  endpoints.set(kind, count);
+  return count;
+}
+function snapshot() {
+  const entries = [...endpoints].map(([kind, count]) => [kind, { ...count }]);
+  return { ...tally, endpoints: Object.fromEntries(entries) };
+}
+function count_call(kind) {
+  if (core.read !== void 0) core.start ??= core.read();
+  tally.calls += 1;
+  endpoint_of(kind).calls += 1;
+}
+function count_not_modified(kind) {
+  tally.not_modified += 1;
+  endpoint_of(kind).not_modified += 1;
+}
+function to_delta(start, end) {
+  if (start === void 0 || start.reset_ms !== end?.reset_ms) return void 0;
+  return end.used - start.used;
+}
+async function core_delta() {
+  if (core.read === void 0 || core.start === void 0) return void 0;
+  const [start, end] = await Promise.all([core.start, core.read()]);
+  return to_delta(start, end);
+}
+function reset() {
+  tally.calls = 0;
+  tally.not_modified = 0;
+  endpoints.clear();
+  core.read = void 0;
+  core.start = void 0;
+}
+var gh_request_tally = {
+  watch_core,
+  count_call,
+  count_not_modified,
+  snapshot,
+  core_delta,
+  reset
+};
+
 // scripts/gh/git-gh-check.ts
 import { execa } from "execa";
 var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
@@ -789,9 +1286,12 @@ var parse_json = {
 };
 
 // scripts/gh/git-gh-failure.ts
-import { z as z3 } from "zod";
-var error_document_schema = z3.object({ status: z3.union([z3.string(), z3.number()]).optional() }).catch({});
+import { z as z4 } from "zod";
+var error_document_schema = z4.object({ status: z4.union([z4.string(), z4.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
+function has_stdout_field(error) {
+  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
+}
 function has_gh_failure(error) {
   return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
 }
@@ -815,7 +1315,11 @@ function attach(error, failure) {
 function failure_of(error) {
   return has_gh_failure(error) ? error.gh_failure : void 0;
 }
-var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
+function body_of(error) {
+  const cause = error instanceof Error ? error.cause : void 0;
+  return has_stdout_field(cause) ? cause.stdout : void 0;
+}
+var gh_failure = { attach, body_of, classify_stdout, failure_of, parse_response_status };
 
 // scripts/gh/git-gh-retry.ts
 import { setTimeout as delay } from "node:timers/promises";
@@ -844,18 +1348,22 @@ function has_answer(spawn_error) {
   if (!(spawn_error instanceof Error) || !("stdout" in spawn_error)) return false;
   return typeof spawn_error.stdout === "string" && spawn_error.stdout.trim().length > 0;
 }
-function is_transient_status(status, spawn_error) {
+function is_transient_status(status, spawn_error, is_read2) {
+  if (is_read2 && has_timed_out(spawn_error)) return true;
   if (status === void 0) return !has_answer(spawn_error);
   return status >= SERVER_ERROR_FLOOR;
 }
-function is_final_spawn(spawn_error) {
-  return has_timed_out(spawn_error) || get_exit_code(spawn_error) === GH_AUTH_REQUIRED_EXIT_CODE;
+function is_final_spawn(spawn_error, is_read2) {
+  return !is_read2 && has_timed_out(spawn_error) || get_exit_code(spawn_error) === GH_AUTH_REQUIRED_EXIT_CODE;
 }
-function is_transient(error) {
+function is_transient_request(error, is_read2) {
   const failure = gh_failure.failure_of(error);
   if (failure === void 0 || !(error instanceof Error)) return false;
   const status = failure.status ?? summary_status(error);
-  return !is_final_spawn(error.cause) && is_transient_status(status, error.cause);
+  return !is_final_spawn(error.cause, is_read2) && is_transient_status(status, error.cause, is_read2);
+}
+function is_transient(error) {
+  return is_transient_request(error, false);
 }
 function first_line(error) {
   return error_text.message_of(error).split("\n", 1)[0] ?? "";
@@ -864,30 +1372,48 @@ function retry_note(error, attempt, wait_ms) {
   const ordinal = `${String(attempt)}/${String(MAX_ATTEMPTS)}`;
   return `gh: request failed transiently (attempt ${ordinal}: ${first_line(error)}) \u2014 retrying in ${String(wait_ms)} ms`;
 }
-function retry_delay(error, attempt) {
-  return is_transient(error) ? RETRY_DELAYS_MS[attempt - 1] : void 0;
+function retry_delay(error, attempt, is_read2) {
+  return is_transient_request(error, is_read2) ? RETRY_DELAYS_MS[attempt - 1] : void 0;
 }
 function spent_note(message) {
   return `${SPENT_NOTE} (${message})`;
 }
-function note_spent(error, attempt, hooks) {
-  if (attempt === MAX_ATTEMPTS && is_transient(error)) hooks.note(spent_note(first_line(error)));
+function note_spent(error, attempt, hooks, is_read2) {
+  if (attempt === MAX_ATTEMPTS && is_transient_request(error, is_read2)) {
+    hooks.note(spent_note(first_line(error)));
+  }
 }
-async function with_retry(request, hooks = DEFAULT_HOOKS, attempt = 1) {
+async function retry_request(request, hooks, attempt, is_read2) {
   try {
     return await request();
   } catch (error) {
-    const wait_ms = retry_delay(error, attempt);
+    const wait_ms = retry_delay(error, attempt, is_read2);
     if (wait_ms === void 0) {
-      note_spent(error, attempt, hooks);
+      note_spent(error, attempt, hooks, is_read2);
       throw error;
     }
     hooks.note(retry_note(error, attempt, wait_ms));
     await hooks.wait(wait_ms);
-    return await with_retry(request, hooks, attempt + 1);
+    return await retry_request(request, hooks, attempt + 1, is_read2);
   }
 }
-var gh_retry = { MAX_ATTEMPTS, RETRY_DELAYS_MS, is_transient, spent_note, with_retry };
+async function with_retry(request, hooks = DEFAULT_HOOKS, attempt = 1) {
+  return await retry_request(request, hooks, attempt, false);
+}
+async function with_read_retry(request, hooks = DEFAULT_HOOKS) {
+  return await retry_request(request, hooks, 1, true);
+}
+var gh_retry = {
+  MAX_ATTEMPTS,
+  RETRY_DELAYS_MS,
+  is_transient,
+  spent_note,
+  with_retry,
+  with_read_retry
+};
+
+// scripts/gh/git-gh-spawn-width.ts
+var GH_SPAWN_CONCURRENCY = 8;
 
 // scripts/gh/git-gh-exec.ts
 var BODY_FROM_STDIN = "-";
@@ -910,9 +1436,6 @@ var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
 function has_stderr_field(error) {
   return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
 }
-function has_stdout_field(error) {
-  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
-}
 function to_timeout_prefix(error) {
   return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
 }
@@ -927,9 +1450,11 @@ ${stdout}` : summary;
     gh_failure.classify_stdout(stdout)
   );
 }
-async function exec_gh_command(arguments_, timeout_ms, cwd) {
+var gh_slots = bounded_pool.limiter(GH_SPAWN_CONCURRENCY);
+async function spawn_gh_command(arguments_, timeout_ms, cwd) {
   await check_gh_installed();
   const options = to_spawn_options(timeout_ms, cwd);
+  gh_request_tally.count_call(gh_call_kind.of(arguments_));
   try {
     const { stdout } = await execa2("gh", arguments_, options);
     return stdout.trimEnd();
@@ -937,9 +1462,13 @@ async function exec_gh_command(arguments_, timeout_ms, cwd) {
     throw to_gh_error(error);
   }
 }
-async function exec_gh_command_with_stdin(input) {
+async function exec_gh_command(arguments_, timeout_ms, cwd) {
+  return await gh_slots.run(async () => await spawn_gh_command(arguments_, timeout_ms, cwd));
+}
+async function spawn_gh_command_with_stdin(input) {
   await check_gh_installed();
   const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
+  gh_request_tally.count_call(gh_call_kind.of(input.args));
   try {
     const { stdout } = await execa2("gh", input.args, options);
     return stdout.trimEnd();
@@ -947,6 +1476,9 @@ async function exec_gh_command_with_stdin(input) {
     throw to_gh_error(error);
   }
 }
+async function exec_gh_command_with_stdin(input) {
+  return await gh_slots.run(async () => await spawn_gh_command_with_stdin(input));
+}
 var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
 function parse_status_line(output) {
   const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
@@ -955,18 +1487,23 @@ function parse_status_line(output) {
 function status_of_failure(error) {
   return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
 }
-async function exec_gh_api_status(path7, timeout_ms) {
+async function spawn_gh_api_status(path7, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
     await check_gh_installed();
+    gh_request_tally.count_call(gh_call_kind.of_api(path7));
     const { stdout } = await execa2("gh", ["api", "--include", "--silent", path7], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
   }
 }
+async function exec_gh_api_status(path7, timeout_ms) {
+  return await gh_slots.run(async () => await spawn_gh_api_status(path7, timeout_ms));
+}
 function exec_gh_api_status_sync(path7, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
+  gh_request_tally.count_call(gh_call_kind.of_api(path7));
   try {
     const { stdout } = execaSync("gh", ["api", "--include", "--silent", path7], options);
     return parse_status_line(stdout);
@@ -975,7 +1512,7 @@ function exec_gh_api_status_sync(path7, timeout_ms) {
   }
 }
 var METHOD_FLAG = "--method";
-var INPUT_FLAG = "--input";
+var INPUT_FLAG2 = "--input";
 var PAGINATE_FLAG = "--paginate";
 var SLURP_FLAG = "--slurp";
 var JQ_FLAG = "--jq";
@@ -989,7 +1526,7 @@ function refuse_credential_body(request) {
   }
 }
 function to_gh_api_args(request) {
-  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
+  const body_args = request.body === void 0 ? [] : [INPUT_FLAG2, BODY_FROM_STDIN];
   const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
   const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
   const escape_args = request.should_allow_escapes === true ? [ALLOW_ESCAPES_FLAG] : [];
@@ -1021,12 +1558,23 @@ async function exec_gh_api(request) {
   if (request.should_retry === false) return await send_gh_api(request);
   return await gh_retry.with_retry(async () => await send_gh_api(request));
 }
+async function exec_gh_api_uncounted(request) {
+  const options = to_spawn_options(request.timeout_ms, request.cwd);
+  try {
+    const { stdout } = await execa2("gh", to_gh_api_args(request), options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
 function exec_gh_api_sync(request) {
   refuse_credential_body(request);
   const body_option = request.body === void 0 ? {} : { input: request.body };
   const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
+  const gh_arguments = to_gh_api_args(request);
+  gh_request_tally.count_call(gh_call_kind.of(gh_arguments));
   try {
-    const { stdout } = execaSync("gh", to_gh_api_args(request), options);
+    const { stdout } = execaSync("gh", gh_arguments, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -1044,6 +1592,7 @@ var git_gh_exec = {
   exec_gh_command,
   exec_gh_command_with_stdin,
   exec_gh_api,
+  exec_gh_api_uncounted,
   exec_gh_api_sync,
   read_gh_api_sync,
   exec_gh_api_status,
@@ -1054,7 +1603,7 @@ var git_gh_exec = {
 // scripts/version/npm-registry.ts
 import { execaSync as execaSync2 } from "execa";
 import semver3 from "semver";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var PUBLIC_REGISTRY = "https://registry.npmjs.org";
 var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
 var FULL_ACCEPT = "application/json";
@@ -1073,9 +1622,11 @@ var FETCH_SCRIPT = [
   "if (!response.ok) process.exit(1)",
   "process.stdout.write(await response.text())"
 ].join("\n");
-var version_schema = z4.string().refine((value) => semver3.valid(value) === value);
-var latest_schema = z4.looseObject({ "dist-tags": z4.looseObject({ latest: version_schema }) });
-var times_schema = z4.looseObject({ time: release_age.release_times_schema });
+var version_schema = z5.string().refine((value) => semver3.valid(value) === value);
+var latest_schema = z5.looseObject({ "dist-tags": z5.looseObject({ latest: version_schema }) });
+var times_schema = z5.looseObject({ time: release_age.release_times_schema });
+var name_schema = z5.looseObject({ name: z5.string().optional() });
+var PUBLISHING_SCOPE = "@joshuafolkken/";
 function packument_url(package_name) {
   return `${PUBLIC_REGISTRY}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
 }
@@ -1125,6 +1676,11 @@ function has_public_version(package_name, version) {
   const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
   return parsed.success && parsed.data.time[version] !== void 0;
 }
+function published_package_name(cwd) {
+  const name = package_manifest.read_manifest_if_valid(cwd, name_schema)?.name;
+  if (name?.startsWith(PUBLISHING_SCOPE) !== true) return void 0;
+  return latest_schema.safeParse(read_packument(name, ABBREVIATED_ACCEPT)).success ? name : void 0;
+}
 function view(spec, field, format = "text") {
   const format_arguments = format === "json" ? [JSON_FLAG] : [];
   const result = execaSync2(PNPM, ["view", spec, field, ...format_arguments], {
@@ -1139,6 +1695,7 @@ function valid_version(value) {
 var npm_registry = {
   has_public_version,
   packument_url,
+  published_package_name,
   read_latest,
   read_release_times,
   valid_version,
@@ -1277,40 +1834,40 @@ function build_upstream_effective(upstream, context) {
     upgrade_command: resolve_global_upgrade_command(context)
   };
 }
-function build_installed_versions(report, config, snapshot) {
+function build_installed_versions(report, config, snapshot2) {
   return /* @__PURE__ */ new Map([
-    [config.package_name, snapshot.global_version],
+    [config.package_name, snapshot2.global_version],
     [report.config.package_name, report.effective?.version]
   ]);
 }
-function attach_upstream_effective(report, config, snapshot, upstream) {
-  const context = { latest: snapshot.latest, upstream_latest: report.latest };
+function attach_upstream_effective(report, config, snapshot2, upstream) {
+  const context = { latest: snapshot2.latest, upstream_latest: report.latest };
   const effective = build_upstream_effective(upstream, context);
   if (effective === void 0) return;
   report.effective = effective;
   if (upstream.is_global_upgrade_command_pinned !== true) return;
-  report.installed_versions = build_installed_versions(report, config, snapshot);
+  report.installed_versions = build_installed_versions(report, config, snapshot2);
 }
-function read_upstream_report(upstream, config, snapshot, is_hold_wanted) {
+function read_upstream_report(upstream, config, snapshot2, is_hold_wanted) {
   const latest = fetch_latest_version(upstream.versions_endpoint, upstream.package_name);
   const project_version = version_targets.read_project_version(process.cwd(), upstream.package_name);
   const report = { config: upstream, project_version, latest };
-  attach_upstream_effective(report, config, snapshot, upstream);
+  attach_upstream_effective(report, config, snapshot2, upstream);
   const hold = is_hold_wanted ? read_release_hold(upstream, latest, [report.effective?.version]) : void 0;
   if (hold !== void 0) report.hold = hold;
   return report;
 }
-function read_upstream_reports(config, snapshot, is_hold_wanted = false) {
+function read_upstream_reports(config, snapshot2, is_hold_wanted = false) {
   return config.upstreams.map(
-    (upstream) => read_upstream_report(upstream, config, snapshot, is_hold_wanted)
+    (upstream) => read_upstream_report(upstream, config, snapshot2, is_hold_wanted)
   );
 }
 function run_check(config) {
-  const snapshot = read_snapshot(config);
-  const upstream_reports = read_upstream_reports(config, snapshot, true);
+  const snapshot2 = read_snapshot(config);
+  const upstream_reports = read_upstream_reports(config, snapshot2, true);
   console.info(
     version_check_logic.format_dual_version_output(
-      snapshot,
+      snapshot2,
       config,
       build_extras(config),
       upstream_reports
@@ -1354,29 +1911,29 @@ function build_idle_message(reports) {
   if (notes.length === 0) return ALREADY_UP_TO_DATE;
   return notes.join("\n");
 }
-function describe_effective_outcome(upstream, report, snapshot) {
+function describe_effective_outcome(upstream, report, snapshot2) {
   const { resolve_effective_version } = upstream;
   if (resolve_effective_version === void 0 || report === void 0 || version_check_logic.build_effective_upgrade_commands(report).length === 0) {
     return [];
   }
   const after = resolve_effective_version({
-    latest: snapshot.latest,
+    latest: snapshot2.latest,
     upstream_latest: report.latest
   });
   if (after === report.latest) return [];
   return [version_check_logic.format_effective_outcome(report, after)];
 }
-function report_effective_outcomes(config, snapshot, reports) {
+function report_effective_outcomes(config, snapshot2, reports) {
   const lines = config.upstreams.flatMap(
-    (upstream, index) => describe_effective_outcome(upstream, reports[index], snapshot)
+    (upstream, index) => describe_effective_outcome(upstream, reports[index], snapshot2)
   );
   if (lines.length > 0) console.info(lines.join("\n"));
 }
 function run_upgrade(config) {
-  const snapshot = read_snapshot(config);
-  const reports = read_upstream_reports(config, snapshot);
+  const snapshot2 = read_snapshot(config);
+  const reports = read_upstream_reports(config, snapshot2);
   const commands = version_check_logic.unique_upgrade_commands([
-    ...version_check_logic.build_dual_upgrade_commands(snapshot, config),
+    ...version_check_logic.build_dual_upgrade_commands(snapshot2, config),
     ...version_check_logic.build_upstream_upgrade_commands(reports)
   ]);
   if (commands.length === 0) {
@@ -1384,7 +1941,7 @@ function run_upgrade(config) {
     return 0;
   }
   const exit_code = run_all_upgrade_commands(commands);
-  report_effective_outcomes(config, snapshot, reports);
+  report_effective_outcomes(config, snapshot2, reports);
   return exit_code;
 }
 var version_commands = {