@joshuafolkken/kit 1.872.0

package/dist/version/index.js

@@ -0,0 +1,1024 @@
+// scripts/version/kit-descriptor.ts
+var KIT_PACKAGE_NAME = "@joshuafolkken/kit";
+var kit_package_descriptor = { package_name: KIT_PACKAGE_NAME };
+
+// scripts/version/version-command-config.ts
+var NODE_MODULES = "node_modules";
+var FIX_GH_PACKAGES_SCRIPT = "scripts/gh/fix-gh-packages.ts";
+var SCOPED_PACKAGE_PATTERN = /^@(?<owner>[^/]+)\/(?<name>.+)$/u;
+var FIX_GH_PACKAGES_PATH = `${NODE_MODULES}/${KIT_PACKAGE_NAME}/${FIX_GH_PACKAGES_SCRIPT}`;
+function parse_scoped_package_name(package_name) {
+  const groups = SCOPED_PACKAGE_PATTERN.exec(package_name)?.groups;
+  const { owner, name } = groups ?? {};
+  if (owner === void 0 || name === void 0) return void 0;
+  return { owner, name };
+}
+function derive_versions_endpoint(package_name) {
+  const scoped = parse_scoped_package_name(package_name);
+  if (scoped === void 0) {
+    throw new Error(`Cannot derive a versions endpoint from unscoped package name: ${package_name}`);
+  }
+  return `/users/${scoped.owner}/packages/npm/${scoped.name}/versions?per_page=1`;
+}
+function pick_effective_hooks(descriptor) {
+  const hooks = {};
+  if (descriptor.resolve_effective_version !== void 0) {
+    hooks.resolve_effective_version = descriptor.resolve_effective_version;
+  }
+  if (descriptor.resolve_global_upgrade_command !== void 0) {
+    hooks.resolve_global_upgrade_command = descriptor.resolve_global_upgrade_command;
+  }
+  if (descriptor.is_global_upgrade_command_pinned !== void 0) {
+    hooks.is_global_upgrade_command_pinned = descriptor.is_global_upgrade_command_pinned;
+  }
+  return hooks;
+}
+function resolve_upstream(descriptor) {
+  return {
+    package_name: descriptor.package_name,
+    versions_endpoint: derive_versions_endpoint(descriptor.package_name),
+    fix_gh_packages_path: FIX_GH_PACKAGES_PATH,
+    ...pick_effective_hooks(descriptor)
+  };
+}
+function resolve_versions_endpoint(options) {
+  const { versions_endpoint, package_name } = options;
+  if (versions_endpoint === void 0) return derive_versions_endpoint(package_name);
+  if (versions_endpoint.trim() !== "") return versions_endpoint;
+  throw new Error(
+    `versions_endpoint for ${package_name} was set to an empty string; omit it to derive the endpoint or pass a non-empty value.`
+  );
+}
+function create_version_command_config(options) {
+  const config = {
+    package_name: options.package_name,
+    versions_endpoint: resolve_versions_endpoint(options),
+    fix_gh_packages_path: FIX_GH_PACKAGES_PATH,
+    upstreams: (options.upstreams ?? []).map((descriptor) => resolve_upstream(descriptor))
+  };
+  if (options.self_directory !== void 0) config.self_directory = options.self_directory;
+  if (options.resolve_warning !== void 0) config.resolve_warning = options.resolve_warning;
+  return config;
+}
+
+// scripts/version/effective-upstream.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+// 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({
+    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 with_development_deps_schema = z.looseObject({
+  devDependencies: z.record(z.string(), z.string()).optional()
+});
+var with_package_manager_schema = z.looseObject({
+  packageManager: z.string().optional()
+});
+var with_development_engine_schema = z.looseObject({
+  devEngines: z.record(z.string(), z.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());
+
+// scripts/version/parse-json.ts
+function safe_json_parse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+
+// scripts/version/effective-upstream.ts
+var PACKAGE_JSON = "package.json";
+var MAX_WALK_DEPTH = 64;
+function read_matching_version(manifest_path, package_name) {
+  if (!existsSync(manifest_path)) return void 0;
+  const parsed = package_named_version_schema.safeParse(
+    safe_json_parse(readFileSync(manifest_path, "utf8"))
+  );
+  if (!parsed.success) return void 0;
+  if (parsed.data.name !== package_name) return void 0;
+  return parsed.data.version;
+}
+function ancestor_directories(start_directory) {
+  const directories = [];
+  let current = start_directory;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth += 1) {
+    directories.push(current);
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return directories;
+}
+function walk_up_for_version(start_directory, package_name) {
+  for (const directory of ancestor_directories(start_directory)) {
+    const version = read_matching_version(path.join(directory, PACKAGE_JSON), package_name);
+    if (version !== void 0) return version;
+  }
+  return void 0;
+}
+function resolve_from_base(base_url, package_name, resolve_marker) {
+  try {
+    return createRequire(base_url).resolve(resolve_marker ?? package_name);
+  } catch {
+    return void 0;
+  }
+}
+function resolve_effective_upstream_version(base_url, package_name, options = {}) {
+  const resolved = resolve_from_base(base_url, package_name, options.resolve_marker);
+  if (resolved === void 0) return void 0;
+  return walk_up_for_version(path.dirname(resolved), package_name);
+}
+
+// scripts/version/version-commands.ts
+import { execaSync as execaSync4 } from "execa";
+
+// scripts/version/release-age.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+import semver from "semver";
+import { z as z2 } from "zod";
+var MINIMUM_RELEASE_AGE_RE = /^minimum-release-age\s*=\s*(\d+)\s*$/mu;
+var NO_QUARANTINE_MINUTES = 0;
+var NPMRC_PATH = ".npmrc";
+var release_times_schema = z2.record(z2.string(), z2.string());
+var MS_PER_MINUTE = 6e4;
+function parse_minimum_release_age(npmrc_content) {
+  const raw = MINIMUM_RELEASE_AGE_RE.exec(npmrc_content)?.[1];
+  return raw === void 0 ? NO_QUARANTINE_MINUTES : Number(raw);
+}
+function is_on_major(version, major) {
+  return major === void 0 || String(semver.major(version)) === major;
+}
+function is_eligible(version, published_at, major, cutoff_ms) {
+  if (semver.valid(version) === null || semver.prerelease(version) !== null || !is_on_major(version, major)) {
+    return false;
+  }
+  const published_ms = Date.parse(published_at);
+  return Number.isFinite(published_ms) && published_ms <= cutoff_ms;
+}
+function select_aged_version(times, major, minimum_age_minutes, now_ms) {
+  const cutoff_ms = now_ms - minimum_age_minutes * MS_PER_MINUTE;
+  const eligible = Object.entries(times).filter(([version, published_at]) => is_eligible(version, published_at, major, cutoff_ms)).map(([version]) => version).toSorted(semver.rcompare);
+  return eligible[0];
+}
+function read_declared_minimum_release_age(npmrc_path) {
+  try {
+    const raw = MINIMUM_RELEASE_AGE_RE.exec(readFileSync2(npmrc_path, "utf8"))?.[1];
+    return raw === void 0 ? void 0 : Number(raw);
+  } catch {
+    return void 0;
+  }
+}
+function read_minimum_release_age(npmrc_path = NPMRC_PATH) {
+  return read_declared_minimum_release_age(npmrc_path) ?? NO_QUARANTINE_MINUTES;
+}
+function find_declared_minimum_release_age(start, boundary) {
+  const declared = read_declared_minimum_release_age(path2.join(start, NPMRC_PATH));
+  if (declared !== void 0) return declared;
+  if (start === boundary) return void 0;
+  const parent = path2.dirname(start);
+  return parent === start ? void 0 : find_declared_minimum_release_age(parent, boundary);
+}
+function read_nearest_minimum_release_age(start, boundary) {
+  return find_declared_minimum_release_age(path2.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
+}
+var release_age = {
+  release_times_schema,
+  parse_minimum_release_age,
+  read_minimum_release_age,
+  read_nearest_minimum_release_age,
+  select_aged_version
+};
+
+// scripts/version/release-hold.ts
+import semver2 from "semver";
+var MINUTES_PER_HOUR = 60;
+var MS_PER_MINUTE2 = 6e4;
+var HOLD_LABEL = "Held:";
+function is_latest_withheld(times, latest, minimum_age_minutes, now_ms) {
+  const published_at = times[latest];
+  if (published_at === void 0) return false;
+  const published_ms = Date.parse(published_at);
+  if (!Number.isFinite(published_ms)) return false;
+  return published_ms > now_ms - minimum_age_minutes * MS_PER_MINUTE2;
+}
+function resolve_installable(times, latest, minimum_age_minutes, now_ms) {
+  if (times === void 0) return void 0;
+  if (!is_latest_withheld(times, latest, minimum_age_minutes, now_ms)) return void 0;
+  const installable = release_age.select_aged_version(times, void 0, minimum_age_minutes, now_ms);
+  return installable === latest ? void 0 : installable;
+}
+function is_at_or_above(version, installable) {
+  if (semver2.valid(version) === null || semver2.valid(installable) === null) {
+    return version === installable;
+  }
+  return semver2.gte(version, installable);
+}
+function is_release_age_hold(version, latest, installable) {
+  if (version === void 0 || installable === void 0 || version === latest) return false;
+  return is_at_or_above(version, installable);
+}
+function format_window(minimum_age_minutes) {
+  if (minimum_age_minutes % MINUTES_PER_HOUR !== 0) return `${String(minimum_age_minutes)} min`;
+  return `${String(minimum_age_minutes / MINUTES_PER_HOUR)} h`;
+}
+function format_release_hold_note(version, latest, installable, minimum_age_minutes) {
+  const window = format_window(minimum_age_minutes);
+  const head = `${HOLD_LABEL} ${latest} is inside the ${window} minimum-release-age window`;
+  if (version !== installable) return `${head}; an unpinned resolve cannot reach it yet`;
+  return `${head}; an unpinned resolve lands on ${installable}`;
+}
+function build_release_hold_notes(version, latest, installable, minimum_age_minutes) {
+  if (version === void 0 || installable === void 0) return [];
+  if (!is_release_age_hold(version, latest, installable)) return [];
+  return [format_release_hold_note(version, latest, installable, minimum_age_minutes)];
+}
+var release_hold = {
+  HOLD_LABEL,
+  is_at_or_above,
+  is_latest_withheld,
+  resolve_installable,
+  is_release_age_hold,
+  format_window,
+  format_release_hold_note,
+  build_release_hold_notes
+};
+
+// scripts/version/running-binary.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import path3 from "node:path";
+var PACKAGE_JSON2 = "package.json";
+var SCRIPT_DEPTH_FROM_ROOT = ["..", ".."];
+function resolve_self_package_path(self_directory) {
+  return path3.join(self_directory, ...SCRIPT_DEPTH_FROM_ROOT, PACKAGE_JSON2);
+}
+function running_package_directory(self_directory) {
+  return path3.resolve(self_directory, ...SCRIPT_DEPTH_FROM_ROOT);
+}
+function read_running_version(self_directory) {
+  const package_path = resolve_self_package_path(self_directory);
+  if (!existsSync2(package_path)) return void 0;
+  const parsed = package_version_schema.safeParse(
+    safe_json_parse(readFileSync3(package_path, "utf8"))
+  );
+  return parsed.success ? parsed.data.version : void 0;
+}
+var running_binary = {
+  resolve_self_package_path,
+  running_package_directory,
+  read_running_version
+};
+
+// scripts/version/upgrade-command-guard.ts
+var VERSION_PIN_PATTERN = /^(?<name>@[\w.-]+\/[\w.-]+|[\w.-]+)@(?<version>\d[\w.+-]*)$/u;
+var WHITESPACE_PATTERN = /\s+/u;
+function parse_version_pin(token) {
+  const { name, version } = VERSION_PIN_PATTERN.exec(token)?.groups ?? {};
+  if (name === void 0 || version === void 0) return void 0;
+  return { name, version };
+}
+function extract_version_pins(command) {
+  return command.split(WHITESPACE_PATTERN).flatMap((token) => parse_version_pin(token) ?? []);
+}
+function is_no_op_upgrade_command(command, installed) {
+  const pins = extract_version_pins(command);
+  if (pins.length === 0) return false;
+  return pins.every((pin) => installed.get(pin.name) === pin.version);
+}
+
+// scripts/version/upgrade-shell-command.ts
+function update_scope_flag(is_local) {
+  return is_local ? "-D" : "-g";
+}
+function format_update_command(latest, is_local, config) {
+  return `pnpm add ${update_scope_flag(is_local)} ${config.package_name}@${latest}`;
+}
+function build_upgrade_shell_command(latest, is_local, config) {
+  const add_command = format_update_command(latest, is_local, config);
+  if (!is_local) return add_command;
+  return `${add_command} && node_modules/.bin/tsx ${config.fix_gh_packages_path}`;
+}
+
+// scripts/version/version-check-logic.ts
+var NOT_INSTALLED = "not installed";
+var GLOBAL_LABEL = "Global: ";
+var PROJECT_LABEL = "Project: ";
+var LATEST_LABEL = "Latest: ";
+var RUNNING_LABEL = "Running:";
+var NOTE_LABEL = "Note:";
+var STATUS_PAD_WIDTH = 12;
+function format_running_line(running) {
+  if (running === void 0) return [];
+  return [`  ${RUNNING_LABEL} ${running.version.padEnd(STATUS_PAD_WIDTH)}(${running.path})`];
+}
+function is_target_stale(version, latest) {
+  return version !== void 0 && version !== latest;
+}
+function format_target_status(version, latest) {
+  if (version === void 0) return NOT_INSTALLED;
+  if (version === latest) return `${version.padEnd(STATUS_PAD_WIDTH)}\u2713`;
+  return `${version.padEnd(STATUS_PAD_WIDTH)}\u26A0 \u2192 ${latest}`;
+}
+function format_target_line(label, version, latest) {
+  return `  ${label} ${format_target_status(version, latest)}`;
+}
+function format_held_target_line(label, version, latest, hold) {
+  const notes = hold === void 0 ? [] : release_hold.build_release_hold_notes(
+    version,
+    latest,
+    hold.installable,
+    hold.minimum_age_minutes
+  );
+  return [format_target_line(label, version, latest), ...notes.map((note) => `  ${note}`)];
+}
+function format_upstream_global_line(report) {
+  if (report.effective === void 0) return [];
+  return format_held_target_line(GLOBAL_LABEL, report.effective.version, report.latest, report.hold);
+}
+function is_effective_stale(report) {
+  const { effective, latest } = report;
+  if (effective === void 0) return false;
+  return is_target_stale(effective.version, latest);
+}
+function resolve_effective_upgrade_hint(report) {
+  const command = report.effective?.upgrade_command;
+  if (command === void 0 || !is_effective_stale(report)) return void 0;
+  const installed = report.installed_versions;
+  return {
+    command,
+    is_no_op: installed !== void 0 && is_no_op_upgrade_command(command, installed)
+  };
+}
+function build_effective_upgrade_commands(report) {
+  const hint = resolve_effective_upgrade_hint(report);
+  if (hint === void 0 || hint.is_no_op) return [];
+  return [hint.command];
+}
+function build_effective_upgrade_notes(report) {
+  const hint = resolve_effective_upgrade_hint(report);
+  if (hint?.is_no_op !== true) return [];
+  return [
+    `${NOTE_LABEL} \`${hint.command}\` is already satisfied; it cannot upgrade ${report.config.package_name} to ${report.latest}`
+  ];
+}
+function build_upstream_upgrade_notes(reports) {
+  return reports.flatMap((report) => build_effective_upgrade_notes(report));
+}
+function format_upstream_lines(report) {
+  return [
+    "",
+    report.config.package_name,
+    ...format_upstream_global_line(report),
+    ...build_effective_upgrade_notes(report).map((note) => `  ${note}`),
+    format_target_line(PROJECT_LABEL, report.project_version, report.latest),
+    `  ${LATEST_LABEL} ${report.latest}`
+  ];
+}
+function unique_upgrade_commands(commands) {
+  return [...new Set(commands)];
+}
+function format_unchanged_outcome(report, version) {
+  const name = report.config.package_name;
+  return `${name}: still ${version} \u2014 the global upgrade command did not change it (latest ${report.latest})`;
+}
+function format_advanced_outcome(report, before, after) {
+  const name = report.config.package_name;
+  return `${name}: ${before} \u2192 ${after} \u2014 still behind latest ${report.latest}`;
+}
+function format_effective_outcome(report, after) {
+  const previous = report.effective?.version;
+  const before = previous ?? NOT_INSTALLED;
+  if (after === previous) return format_unchanged_outcome(report, before);
+  return format_advanced_outcome(report, before, after ?? NOT_INSTALLED);
+}
+function build_project_upgrade_commands(report) {
+  if (!is_target_stale(report.project_version, report.latest)) return [];
+  return [build_upgrade_shell_command(report.latest, true, report.config)];
+}
+function build_upstream_upgrade_commands(reports) {
+  return reports.flatMap((report) => [
+    ...build_effective_upgrade_commands(report),
+    ...build_project_upgrade_commands(report)
+  ]);
+}
+function build_dual_upgrade_commands(snapshot, config) {
+  const { global_version, project_version, latest } = snapshot;
+  const commands = [];
+  if (is_target_stale(global_version, latest)) {
+    commands.push(build_upgrade_shell_command(latest, false, config));
+  }
+  if (is_target_stale(project_version, latest)) {
+    commands.push(build_upgrade_shell_command(latest, true, config));
+  }
+  return commands;
+}
+function format_target_lines(snapshot) {
+  const { global_version, project_version, latest } = snapshot;
+  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 = []) {
+  const lines = [
+    config.package_name,
+    ...format_target_lines(snapshot),
+    ...format_running_line(extras.running),
+    ...upstreams.flatMap((report) => format_upstream_lines(report))
+  ];
+  const hints = unique_upgrade_commands([
+    ...build_dual_upgrade_commands(snapshot, config),
+    ...build_upstream_upgrade_commands(upstreams)
+  ]).map((command) => `Run: ${command}`);
+  if (hints.length > 0) lines.push("", ...hints);
+  if (extras.warning !== void 0) lines.push("", extras.warning);
+  return lines.join("\n");
+}
+var version_check_logic = {
+  format_dual_version_output,
+  format_running_line,
+  format_upstream_lines,
+  format_upstream_global_line,
+  build_dual_upgrade_commands,
+  build_upstream_upgrade_commands,
+  build_upstream_upgrade_notes,
+  build_effective_upgrade_commands,
+  build_effective_upgrade_notes,
+  build_project_upgrade_commands,
+  format_update_command,
+  format_effective_outcome,
+  build_upgrade_shell_command,
+  unique_upgrade_commands
+};
+
+// scripts/josh/agent-session-environment.ts
+var SESSION_ID_KEY = "CLAUDE_CODE_SESSION_ID";
+var PARENT_SESSION_KEYS = [
+  "CLAUDE_CODE_MESSAGING_SOCKET",
+  "CLAUDE_CODE_MESSAGING_TOKEN",
+  SESSION_ID_KEY,
+  "CLAUDE_CODE_CHILD_SESSION"
+];
+var PROXY_KEYS = [
+  "ALL_PROXY",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "all_proxy",
+  "http_proxy",
+  "https_proxy",
+  "GLOBAL_AGENT_HTTP_PROXY",
+  "GLOBAL_AGENT_HTTPS_PROXY"
+];
+var PROXY_CERTIFICATE_KEY = "NODE_EXTRA_CA_CERTS";
+var LOOPBACK_HOSTS = ["localhost", "ip6-localhost", "[::1]"];
+var LOOPBACK_PREFIX = "127.";
+var NO_HOST = "";
+function parsed_host(value) {
+  try {
+    return new URL(value).hostname;
+  } catch {
+    return NO_HOST;
+  }
+}
+function proxy_host(value) {
+  const direct = parsed_host(value);
+  return direct === NO_HOST ? parsed_host(`http://${value}`) : direct;
+}
+function is_loopback_host(host) {
+  return host.startsWith(LOOPBACK_PREFIX) || LOOPBACK_HOSTS.includes(host);
+}
+function is_loopback_proxy(value) {
+  if (value === void 0 || value === NO_HOST) return false;
+  return is_loopback_host(proxy_host(value));
+}
+function is_declared(value) {
+  return value !== void 0 && value !== NO_HOST;
+}
+function loopback_proxy_keys(source, is_removed = is_loopback_proxy) {
+  const declared = PROXY_KEYS.filter((key) => is_declared(source[key]));
+  const matched = declared.filter((key) => is_removed(source[key]));
+  const is_certificate_included = matched.length > 0 && matched.length === declared.length;
+  return is_certificate_included ? [...matched, PROXY_CERTIFICATE_KEY] : matched;
+}
+function to_removed(keys) {
+  return Object.fromEntries(keys.map((key) => [key, void 0]));
+}
+function removed_environment(source = process.env) {
+  return to_removed([...PARENT_SESSION_KEYS, ...loopback_proxy_keys(source)]);
+}
+var SCANNER_DIRECTORY = ".safe-chain";
+var PATH_SEPARATOR = /[/\\]/u;
+function is_scanner_certificate(value) {
+  return value?.split(PATH_SEPARATOR).includes(SCANNER_DIRECTORY) ?? false;
+}
+var SCANNER_PROXY_KEY = "HTTPS_PROXY";
+function is_scanner_proxy(source) {
+  const scanner_proxy = source[SCANNER_PROXY_KEY];
+  return function is_match(value) {
+    return value === scanner_proxy && is_loopback_proxy(value);
+  };
+}
+function removed_proxy_environment(source = process.env) {
+  if (!is_scanner_certificate(source[PROXY_CERTIFICATE_KEY])) return {};
+  return to_removed(loopback_proxy_keys(source, is_scanner_proxy(source)));
+}
+var agent_session_environment = {
+  LOOPBACK_HOSTS,
+  PARENT_SESSION_KEYS,
+  PROXY_CERTIFICATE_KEY,
+  PROXY_KEYS,
+  SESSION_ID_KEY,
+  removed_environment,
+  removed_proxy_environment
+};
+
+// scripts/git/git-gh-exec.ts
+import { execa as execa2, execaSync } from "execa";
+
+// scripts/git/git-execa-error.ts
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+
+// scripts/git/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/";
+var gh_check = {};
+async function run_gh_check() {
+  try {
+    await execa("gh", ["--version"]);
+  } catch {
+    delete gh_check.promise;
+    throw new Error(GH_NOT_INSTALLED_MSG);
+  }
+}
+async function check_gh_installed() {
+  gh_check.promise ??= run_gh_check();
+  await gh_check.promise;
+}
+
+// scripts/git/git-gh-failure.ts
+import { z as z3 } from "zod";
+
+// scripts/git/parse-json-array.ts
+var MALFORMED_JSON = /* @__PURE__ */ Symbol("malformed-json");
+function parse_json_loose(raw_json) {
+  try {
+    return JSON.parse(raw_json);
+  } catch (error) {
+    if (error instanceof SyntaxError) return MALFORMED_JSON;
+    throw error;
+  }
+}
+function parse_json_array_or_undefined(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === MALFORMED_JSON || !Array.isArray(value)) return void 0;
+  return element_schema.array().parse(value);
+}
+function read_json_listing(raw_json, element_schema) {
+  try {
+    const rows = parse_json_array_or_undefined(raw_json, element_schema);
+    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
+  } catch {
+    return { kind: "unexpected_shape" };
+  }
+}
+function parse_json_array_safe(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === MALFORMED_JSON) return [];
+  return element_schema.array().parse(value);
+}
+function parse_json_object_safe(raw_json, schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === MALFORMED_JSON) return void 0;
+  return schema.parse(value);
+}
+var parse_json = {
+  parse_json_array_safe,
+  parse_json_array_or_undefined,
+  parse_json_object_safe,
+  read_json_listing
+};
+
+// scripts/git/git-gh-failure.ts
+var error_document_schema = z3.object({ status: z3.union([z3.string(), z3.number()]).optional() }).catch({});
+var GH_FAILURE_FIELD = "gh_failure";
+function has_gh_failure(error) {
+  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
+}
+function parse_response_status(stdout) {
+  const document = parse_json.parse_json_object_safe(stdout, error_document_schema);
+  if (document?.status === void 0) return void 0;
+  const status = Number(document.status);
+  return Number.isSafeInteger(status) ? status : void 0;
+}
+function classify_stdout(stdout) {
+  return { status: parse_response_status(stdout) };
+}
+function attach(error, failure) {
+  Object.defineProperty(error, GH_FAILURE_FIELD, {
+    value: failure,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+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 };
+
+// scripts/git/git-gh-exec.ts
+var BODY_FROM_STDIN = "-";
+var GH_REQUEST_TIMEOUT_MS = 6e4;
+function to_timeout_option(timeout_ms) {
+  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
+}
+function direct_environment() {
+  const removed = agent_session_environment.removed_proxy_environment();
+  return Object.keys(removed).length > 0 ? { env: removed } : {};
+}
+function to_spawn_options(timeout_ms) {
+  return { ...to_timeout_option(timeout_ms), ...direct_environment() };
+}
+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}: ` : "";
+}
+function to_error_message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function to_gh_error(error) {
+  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
+  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
+  const summary = stderr.length > 0 ? stderr : to_error_message(error);
+  const detail = stdout.length > 0 ? `${summary}
+${stdout}` : summary;
+  return gh_failure.attach(
+    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
+    gh_failure.classify_stdout(stdout)
+  );
+}
+async function exec_gh_command(arguments_, timeout_ms) {
+  await check_gh_installed();
+  try {
+    const { stdout } = await execa2("gh", arguments_, to_spawn_options(timeout_ms));
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+async function exec_gh_command_with_stdin(input) {
+  await check_gh_installed();
+  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms) };
+  try {
+    const { stdout } = await execa2("gh", input.args, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
+function parse_status_line(output) {
+  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
+  return status === void 0 ? void 0 : Number(status);
+}
+async function exec_gh_api_status(path5, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    await check_gh_installed();
+    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path5], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+  }
+}
+var METHOD_FLAG = "--method";
+var INPUT_FLAG = "--input";
+var PAGINATE_FLAG = "--paginate";
+var SLURP_FLAG = "--slurp";
+var JQ_FLAG = "--jq";
+function optional_flag(flag, value) {
+  return value === void 0 ? [] : [flag, value];
+}
+function to_gh_api_args(request) {
+  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
+  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
+  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
+  return [
+    "api",
+    request.path,
+    ...optional_flag(METHOD_FLAG, request.method),
+    ...body_args,
+    ...paginate_args,
+    ...slurp_args,
+    ...optional_flag(JQ_FLAG, request.jq_filter)
+  ];
+}
+async function exec_gh_api(request) {
+  const args = to_gh_api_args(request);
+  if (request.body === void 0) return await exec_gh_command(args, request.timeout_ms);
+  return await exec_gh_command_with_stdin({
+    args,
+    stdin_body: request.body,
+    timeout_ms: request.timeout_ms
+  });
+}
+function exec_gh_api_sync(request) {
+  const body_option = request.body === void 0 ? {} : { input: request.body };
+  const options = { ...body_option, ...to_spawn_options(request.timeout_ms) };
+  try {
+    const { stdout } = execaSync("gh", to_gh_api_args(request), options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+var git_gh_exec = {
+  direct_environment,
+  exec_gh_command,
+  exec_gh_command_with_stdin,
+  exec_gh_api,
+  exec_gh_api_sync,
+  exec_gh_api_status,
+  parse_status_line
+};
+
+// scripts/version/version-remote.ts
+import { execaSync as execaSync2 } from "execa";
+var GH_FAILURE_FALLBACK = "gh api failed";
+var TIMES_PAGE_SIZE = 100;
+var TIMES_JQ = "[.[] | {(.name): .created_at}] | add";
+function require_endpoint(versions_endpoint, package_name) {
+  if (versions_endpoint !== void 0 && versions_endpoint.trim() !== "") return versions_endpoint;
+  throw new Error(
+    `Could not derive a versions endpoint for ${package_name}; check its version-command config.`
+  );
+}
+function describe_failure(result) {
+  const stderr = result.stderr.trim();
+  if (stderr !== "") return stderr;
+  return result.shortMessage ?? GH_FAILURE_FALLBACK;
+}
+function fetch_latest_version(versions_endpoint, package_name) {
+  const endpoint = require_endpoint(versions_endpoint, package_name);
+  const result = execaSync2("gh", ["api", endpoint, "--jq", ".[0].name"], {
+    ...git_gh_exec.direct_environment(),
+    reject: false
+  });
+  if (result.exitCode === 0) return result.stdout.trim();
+  throw new Error(
+    `Failed to fetch latest version for ${package_name} via ${endpoint}: ${describe_failure(result)}`
+  );
+}
+function with_page_size(endpoint, page_size) {
+  const separator = endpoint.indexOf("?");
+  const path_part = separator === -1 ? endpoint : endpoint.slice(0, separator);
+  const query = new URLSearchParams(separator === -1 ? "" : endpoint.slice(separator + 1));
+  query.set("per_page", String(page_size));
+  return `${path_part}?${query.toString()}`;
+}
+function fetch_release_times(versions_endpoint) {
+  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
+  const endpoint = with_page_size(versions_endpoint, TIMES_PAGE_SIZE);
+  const result = execaSync2("gh", ["api", endpoint, "--jq", TIMES_JQ], {
+    ...git_gh_exec.direct_environment(),
+    reject: false
+  });
+  if (result.exitCode !== 0) return void 0;
+  const parsed = release_age.release_times_schema.safeParse(safe_json_parse(result.stdout));
+  return parsed.success ? parsed.data : void 0;
+}
+
+// scripts/version/version-targets.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
+import path4 from "node:path";
+import { execaSync as execaSync3 } from "execa";
+var NODE_MODULES2 = "node_modules";
+var PACKAGE_JSON3 = "package.json";
+function build_pnpm_ls_arguments(package_name) {
+  return ["ls", "-g", "--json", package_name];
+}
+function parse_global_version(stdout, package_name) {
+  const parsed = pnpm_ls_global_schema.safeParse(safe_json_parse(stdout));
+  if (!parsed.success) return void 0;
+  return parsed.data[0]?.dependencies?.[package_name]?.version;
+}
+function parse_project_version(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = package_version_schema.safeParse(safe_json_parse(raw));
+  return parsed.success ? parsed.data.version : void 0;
+}
+function read_global_version(package_name) {
+  const result = execaSync3("pnpm", build_pnpm_ls_arguments(package_name), { reject: false });
+  return parse_global_version(result.stdout, package_name);
+}
+function project_package_path(cwd, package_name) {
+  return path4.join(cwd, NODE_MODULES2, package_name, PACKAGE_JSON3);
+}
+function read_project_version(cwd, package_name) {
+  const package_path = project_package_path(cwd, package_name);
+  const raw = existsSync3(package_path) ? readFileSync4(package_path, "utf8") : void 0;
+  return parse_project_version(raw);
+}
+function read_workspace_version(cwd) {
+  const package_path = path4.join(cwd, PACKAGE_JSON3);
+  const raw = existsSync3(package_path) ? readFileSync4(package_path, "utf8") : void 0;
+  return parse_project_version(raw);
+}
+var version_targets = {
+  build_pnpm_ls_arguments,
+  parse_global_version,
+  parse_project_version,
+  read_global_version,
+  read_project_version,
+  project_package_path,
+  read_workspace_version,
+  // The manifest's filename. Exported rather than re-declared in each of `josh release`'s two
+  // halves (joshuafolkken/kit#1169): the module that already owns "where the project's manifest is"
+  // is where the name belongs.
+  PACKAGE_JSON: PACKAGE_JSON3
+};
+
+// scripts/version/version-commands.ts
+var FAILURE_EXIT_CODE = 1;
+var ALREADY_UP_TO_DATE = "Already up to date";
+var NO_QUARANTINE_MINUTES2 = 0;
+function read_release_hold(versions_endpoint, latest, versions) {
+  if (versions.every((version) => version === void 0 || version === latest)) return void 0;
+  const minimum_age_minutes = release_age.read_nearest_minimum_release_age(process.cwd());
+  if (minimum_age_minutes <= NO_QUARANTINE_MINUTES2) return void 0;
+  const installable = release_hold.resolve_installable(
+    fetch_release_times(versions_endpoint),
+    latest,
+    minimum_age_minutes,
+    Date.now()
+  );
+  if (installable === void 0) return void 0;
+  return { installable, minimum_age_minutes };
+}
+function read_snapshot(config) {
+  return {
+    global_version: version_targets.read_global_version(config.package_name),
+    project_version: version_targets.read_project_version(process.cwd(), config.package_name),
+    latest: fetch_latest_version(config.versions_endpoint, config.package_name)
+  };
+}
+function read_running_binary(self_directory) {
+  if (self_directory === void 0) return void 0;
+  const version = running_binary.read_running_version(self_directory);
+  if (version === void 0) return void 0;
+  return { version, path: running_binary.running_package_directory(self_directory) };
+}
+function build_extras(config) {
+  const extras = {};
+  const running = read_running_binary(config.self_directory);
+  if (running !== void 0) extras.running = running;
+  const warning = config.resolve_warning?.();
+  if (warning !== void 0) extras.warning = warning;
+  return extras;
+}
+function build_upstream_effective(upstream, context) {
+  const { resolve_effective_version, resolve_global_upgrade_command } = upstream;
+  if (resolve_effective_version === void 0) return void 0;
+  if (resolve_global_upgrade_command === void 0) return void 0;
+  return {
+    version: resolve_effective_version(context),
+    upgrade_command: resolve_global_upgrade_command(context)
+  };
+}
+function build_installed_versions(report, config, snapshot) {
+  return /* @__PURE__ */ new Map([
+    [config.package_name, snapshot.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 };
+  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);
+}
+function read_upstream_report(upstream, config, snapshot, 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);
+  const hold = is_hold_wanted ? read_release_hold(upstream.versions_endpoint, 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) {
+  return config.upstreams.map(
+    (upstream) => read_upstream_report(upstream, config, snapshot, is_hold_wanted)
+  );
+}
+function run_check(config) {
+  const snapshot = read_snapshot(config);
+  const upstream_reports = read_upstream_reports(config, snapshot, true);
+  console.info(
+    version_check_logic.format_dual_version_output(
+      snapshot,
+      config,
+      build_extras(config),
+      upstream_reports
+    )
+  );
+}
+function run_upgrade_command(command) {
+  const result = execaSync4("sh", ["-c", command], { stdio: "inherit", reject: false });
+  return result.exitCode ?? FAILURE_EXIT_CODE;
+}
+function run_all_upgrade_commands(commands) {
+  let exit_code = 0;
+  for (const command of commands) {
+    const code = run_upgrade_command(command);
+    if (code !== 0) exit_code = code;
+  }
+  return exit_code;
+}
+function build_idle_message(reports) {
+  const notes = version_check_logic.build_upstream_upgrade_notes(reports);
+  if (notes.length === 0) return ALREADY_UP_TO_DATE;
+  return notes.join("\n");
+}
+function describe_effective_outcome(upstream, report, snapshot) {
+  const { resolve_effective_version } = upstream;
+  if (resolve_effective_version === void 0 || report === void 0) return [];
+  if (version_check_logic.build_effective_upgrade_commands(report).length === 0) return [];
+  const after = resolve_effective_version({
+    latest: snapshot.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) {
+  const lines = config.upstreams.flatMap(
+    (upstream, index) => describe_effective_outcome(upstream, reports[index], snapshot)
+  );
+  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 commands = version_check_logic.unique_upgrade_commands([
+    ...version_check_logic.build_dual_upgrade_commands(snapshot, config),
+    ...version_check_logic.build_upstream_upgrade_commands(reports)
+  ]);
+  if (commands.length === 0) {
+    console.info(build_idle_message(reports));
+    return 0;
+  }
+  const exit_code = run_all_upgrade_commands(commands);
+  report_effective_outcomes(config, snapshot, reports);
+  return exit_code;
+}
+var version_commands = {
+  read_snapshot,
+  read_upstream_reports,
+  build_extras,
+  run_check,
+  run_upgrade,
+  run_upgrade_command,
+  run_all_upgrade_commands
+};
+export {
+  KIT_PACKAGE_NAME,
+  create_version_command_config,
+  derive_versions_endpoint,
+  kit_package_descriptor,
+  resolve_effective_upstream_version,
+  version_commands
+};