@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/dist/hooks/chunk-45CJJOO7.js

@@ -0,0 +1,1243 @@
+// scripts/init/init-paths.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+var PROJECT_ROOT = process.cwd();
+function package_path(relative_path) {
+  return path.join(PACKAGE_DIR, relative_path);
+}
+
+// scripts/lib/atomic-write.ts
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import path2 from "node:path";
+var STAGING_EXTENSION = ".tmp";
+var CREATE_EXCLUSIVE_FLAG = "wx";
+function staging_path(target, staging_directory) {
+  const name = `${path2.basename(target)}.${String(process.pid)}.${randomUUID()}${STAGING_EXTENSION}`;
+  return path2.join(staging_directory, name);
+}
+function write_staged(staging, content, mode) {
+  writeFileSync(staging, content, {
+    flag: CREATE_EXCLUSIVE_FLAG,
+    ...mode !== void 0 && { mode }
+  });
+  if (mode !== void 0) chmodSync(staging, mode);
+}
+function replace_file(target, content, options = {}) {
+  const directory = options.staging_directory ?? path2.dirname(target);
+  const staging = staging_path(target, directory);
+  mkdirSync(directory, { recursive: true });
+  try {
+    write_staged(staging, content, options.mode);
+    renameSync(staging, target);
+  } finally {
+    rmSync(staging, { force: true });
+  }
+}
+var atomic_write = { replace_file };
+
+// scripts/josh/stamp-file.ts
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+
+// scripts/josh/platform-temporary.ts
+import { accessSync, constants } from "node:fs";
+import { tmpdir } from "node:os";
+var POSIX_TEMP_ROOT = "/tmp";
+var WINDOWS_PLATFORM = "win32";
+function is_writable_directory(directory) {
+  try {
+    accessSync(directory, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolve_temporary_root(platform2, can_write = is_writable_directory) {
+  if (platform2 === WINDOWS_PLATFORM) return tmpdir();
+  return can_write(POSIX_TEMP_ROOT) ? POSIX_TEMP_ROOT : tmpdir();
+}
+var TEMP_ROOT_KEY = "JOSH_TEMP_ROOT";
+function temporary_root(override, platform2) {
+  return override === void 0 || override === "" ? resolve_temporary_root(platform2) : override;
+}
+var PLATFORM_TEMP_ROOT = temporary_root(process.env[TEMP_ROOT_KEY], process.platform);
+var platform_temporary = {
+  TEMP_ROOT_KEY,
+  resolve_temporary_root,
+  is_writable_directory,
+  temporary_root
+};
+
+// scripts/josh/stamp-file.ts
+var HASH_ALGORITHM = "sha256";
+var STAMP_SUFFIX = ".json";
+var STAMP_KEY_LENGTH = 16;
+var STAMP_FILE_MODE = 384;
+var STAMP_WRITE_FLAG = "wx";
+var STAMP_CREATE_FLAG = STAMP_WRITE_FLAG;
+var EXISTS_ERROR_CODE = "EEXIST";
+var ACCOUNT_KEY_SEPARATOR = ":";
+function digest(content) {
+  return createHash(HASH_ALGORITHM).update(content).digest("hex");
+}
+function account_key() {
+  return String(process.getuid?.() ?? "");
+}
+function stamp_name(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  const key = digest(`${account_key()}${ACCOUNT_KEY_SEPARATOR}${root}`).slice(0, STAMP_KEY_LENGTH);
+  return `${prefix}${key}${suffix}`;
+}
+function stamp_path(prefix, root = PACKAGE_DIR, suffix = STAMP_SUFFIX) {
+  return path3.join(PLATFORM_TEMP_ROOT, stamp_name(prefix, root, suffix));
+}
+function write_exclusively(target, content) {
+  rmSync2(target, { force: true });
+  writeFileSync2(target, content, { flag: STAMP_WRITE_FLAG, mode: STAMP_FILE_MODE });
+  return target;
+}
+function write_stamp(target, payload) {
+  return write_exclusively(target, JSON.stringify(payload));
+}
+function is_own_regular_file(source) {
+  const stats = lstatSync(source);
+  if (!stats.isFile()) return false;
+  const uid = process.getuid?.();
+  return uid === void 0 || stats.uid === uid;
+}
+function is_foreign_file(target) {
+  try {
+    return lstatSync(target).isFile() && !is_own_regular_file(target);
+  } catch {
+    return false;
+  }
+}
+function replace_text_stamp(target, text) {
+  if (is_foreign_file(target)) {
+    throw new Error(`refusing to replace another account's file: ${target}`);
+  }
+  atomic_write.replace_file(target, text, { mode: STAMP_FILE_MODE });
+  return target;
+}
+function replace_stamp(target, payload) {
+  return replace_text_stamp(target, JSON.stringify(payload));
+}
+function write_text_stamp(target, text) {
+  return write_exclusively(target, text);
+}
+function create_stamp(target, payload) {
+  try {
+    writeFileSync2(target, JSON.stringify(payload), {
+      flag: STAMP_CREATE_FLAG,
+      mode: STAMP_FILE_MODE
+    });
+    return true;
+  } catch (error) {
+    if (error.code === EXISTS_ERROR_CODE) return false;
+    throw error;
+  }
+}
+function remove_stamp(target) {
+  rmSync2(target, { force: true });
+}
+function read_stamp_text(source) {
+  try {
+    if (!is_own_regular_file(source)) return void 0;
+    return readFileSync(source, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var stamp_file = {
+  create_stamp,
+  digest,
+  is_own_regular_file,
+  read_stamp_text,
+  replace_stamp,
+  replace_text_stamp,
+  remove_stamp,
+  stamp_name,
+  stamp_path,
+  write_stamp,
+  write_text_stamp
+};
+
+// scripts/lib/timeouts.ts
+var MS_PER_SECOND = 1e3;
+var SECONDS_PER_MINUTE = 60;
+var MS_PER_MINUTE = MS_PER_SECOND * SECONDS_PER_MINUTE;
+var PROBE_TIMEOUT_MS = 2e3;
+var FETCH_TIMEOUT_MS = 1e4;
+var GIT_TIMEOUT_MS = 1e4;
+var HOOK_PROCESS_TIMEOUT_MS = 15e3;
+var GH_API_TIMEOUT_MS = 2e4;
+var COMMAND_TIMEOUT_MS = 3e4;
+var INSTALL_TIMEOUT_MS = 6e5;
+var SUITE_TIMEOUT_MS = 18e5;
+
+// scripts/git/constants.ts
+import { platform } from "node:os";
+var GIT_COMMAND_UNIX = "/usr/bin/git";
+var PORCELAIN_FLAG = "--porcelain";
+var UNTRACKED_FILES_FLAG = "--untracked-files=all";
+var GIT_BINARY_KEY = "JOSH_GIT_BINARY";
+function get_git_command() {
+  if (platform() === "win32") return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
+  return GIT_COMMAND_UNIX;
+}
+function get_git_command_for_spawn() {
+  const binary = process.env[GIT_BINARY_KEY];
+  if (binary !== void 0 && binary !== "") return binary;
+  if (platform() === "win32") return String.raw`C:\Program Files\Git\cmd\git.exe`;
+  return GIT_COMMAND_UNIX;
+}
+var git_utilities = {
+  get_git_command,
+  get_git_command_for_spawn
+};
+
+// scripts/git/git-spawn.ts
+import { execa as execa3 } from "execa";
+
+// scripts/git/git-execa-error.ts
+function get_exit_code(error) {
+  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
+  const { exitCode: exit_code } = error;
+  return typeof exit_code === "number" ? exit_code : void 0;
+}
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+var TIMEOUT_EXIT_CODE = "timeout";
+function create_spawn_error(command, exit_code) {
+  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
+  const error_message = `git ${command} exited with code ${exit_code_string}`;
+  return new Error(error_message, { cause: { exit_code: exit_code_string } });
+}
+
+// scripts/git/git-push-transport.ts
+import { execa as execa2 } from "execa";
+
+// scripts/git/git-ssh-keepalive.ts
+import { execa } from "execa";
+var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
+var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
+var SSH_LEGACY_VARIABLE = "GIT_SSH";
+var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
+var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
+var CONFIG_PROBE_ARGUMENTS = ["config", "--get", SSH_COMMAND_CONFIG_KEY];
+var PROBE_OPTIONS = { timeout: PROBE_TIMEOUT_MS };
+function to_environment_value(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function to_configured_ssh_command() {
+  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
+  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
+}
+async function has_configured_ssh_command() {
+  if (to_configured_ssh_command() !== "") return true;
+  try {
+    const git_command_bin = git_utilities.get_git_command_for_spawn();
+    const { stdout } = await execa(git_command_bin, CONFIG_PROBE_ARGUMENTS, PROBE_OPTIONS);
+    return stdout.trim() !== "";
+  } catch (error) {
+    return has_timed_out(error);
+  }
+}
+async function to_environment() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {};
+}
+var git_ssh_keepalive = {
+  to_environment
+};
+
+// scripts/git/git-push-transport.ts
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_SUBCOMMAND = "push";
+async function to_push_options() {
+  return {
+    stdio: "inherit",
+    timeout: PUSH_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  };
+}
+async function did_push_time_out(arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const options = await to_push_options();
+  try {
+    await execa2(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    return false;
+  } catch (error) {
+    if (has_timed_out(error)) return true;
+    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
+  }
+}
+function to_manual_command(arguments_list) {
+  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
+}
+function to_retry_notice(arguments_list) {
+  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
+}
+function create_timeout_error(arguments_list) {
+  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
+  return new Error(message, { cause: { exit_code: TIMEOUT_EXIT_CODE } });
+}
+async function push(arguments_list) {
+  if (!await did_push_time_out(arguments_list)) return;
+  console.warn(to_retry_notice(arguments_list));
+  if (!await did_push_time_out(arguments_list)) return;
+  throw create_timeout_error(arguments_list);
+}
+var git_push_transport = {
+  push
+};
+
+// scripts/git/git-spawn.ts
+async function read(arguments_, timeout_ms = GIT_TIMEOUT_MS) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  const { stdout } = await execa3(git_cmd, arguments_, { timeout: timeout_ms });
+  return stdout.trimEnd();
+}
+var REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS;
+function to_budget_error(command, error, timeout_ms) {
+  if (!has_timed_out(error)) return create_spawn_error(command, get_exit_code(error));
+  const seconds = String(Math.round(timeout_ms / MS_PER_SECOND));
+  return new Error(`git ${command} timed out after ${seconds}s`, {
+    cause: { exit_code: TIMEOUT_EXIT_CODE }
+  });
+}
+async function spawn_remote(arguments_, options) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  try {
+    const { stdout } = await execa3(git_cmd, arguments_, options);
+    return typeof stdout === "string" ? stdout.trimEnd() : "";
+  } catch (error) {
+    throw to_budget_error(arguments_[0] ?? "", error, options.timeout);
+  }
+}
+async function read_remote(arguments_, timeout_ms = REMOTE_TIMEOUT_MS) {
+  return await spawn_remote(arguments_, {
+    timeout: timeout_ms,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output_remote(command, arguments_list) {
+  await spawn_remote([command, ...arguments_list], {
+    stdio: "inherit",
+    timeout: REMOTE_TIMEOUT_MS,
+    env: await git_ssh_keepalive.to_environment()
+  });
+}
+async function with_output(command, arguments_list, options = {}) {
+  const { config_options = [], timeout_ms = GIT_TIMEOUT_MS } = options;
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const spawn_arguments = [...config_options, command, ...arguments_list];
+  try {
+    await execa3(git_command_bin, spawn_arguments, { stdio: "inherit", timeout: timeout_ms });
+  } catch (error) {
+    throw to_budget_error(command, error, timeout_ms);
+  }
+}
+var git_spawn = {
+  read,
+  read_remote,
+  with_output,
+  with_output_remote
+};
+
+// scripts/git/git-diff-reads.ts
+var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
+var NAME_ONLY_FLAG = "--name-only";
+var DEFAULT_BRANCH_FALLBACK = "main";
+var DEFAULT_BRANCH_ARGUMENTS = ["symbolic-ref", "refs/remotes/origin/HEAD"];
+function default_branch_of(output) {
+  const trimmed = output?.trim() ?? "";
+  if (!trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
+  return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
+}
+async function get_default_branch() {
+  try {
+    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
+  } catch {
+    return DEFAULT_BRANCH_FALLBACK;
+  }
+}
+var MERGE_BASE_COMMAND = "merge-base";
+function reference_check_arguments(reference) {
+  return ["rev-parse", "--verify", "--quiet", reference];
+}
+function remote_reference_of(default_branch) {
+  return `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
+}
+async function reference_exists(reference) {
+  try {
+    await git_spawn.read([...reference_check_arguments(reference)]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function default_branch_reference() {
+  const default_branch = await get_default_branch();
+  const remote_reference = remote_reference_of(default_branch);
+  return await reference_exists(remote_reference) ? remote_reference : default_branch;
+}
+function merge_base_arguments(reference) {
+  return [MERGE_BASE_COMMAND, reference, "HEAD"];
+}
+function incoming_base_arguments(reference) {
+  return [MERGE_BASE_COMMAND, reference, "MERGE_HEAD"];
+}
+function later_base_arguments(base, incoming) {
+  return [MERGE_BASE_COMMAND, "--independent", base, incoming];
+}
+function later_base_of(output, base) {
+  const [later = ""] = output?.split("\n", 1) ?? [];
+  return later === "" ? base : later;
+}
+async function change_base() {
+  const default_branch = await default_branch_reference();
+  try {
+    return await git_spawn.read([...merge_base_arguments(default_branch)]);
+  } catch {
+    return default_branch;
+  }
+}
+async function diff_main(file_path) {
+  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
+}
+var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
+var NO_RELATIVE_PATHS = "--no-relative";
+var NO_RENAME_DETECTION = "--no-renames";
+async function change_base_commit() {
+  return await git_spawn.read(["rev-parse", await change_base()]);
+}
+function names_since_arguments(commit2) {
+  return [
+    ...NO_PATH_QUOTING,
+    "diff",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    commit2,
+    "--"
+  ];
+}
+async function diff_names_since(commit2) {
+  return await git_spawn.read([...names_since_arguments(commit2)]);
+}
+async function tree_names_at(commit2, paths) {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "ls-tree",
+    "-r",
+    NAME_ONLY_FLAG,
+    "--full-tree",
+    commit2,
+    "--",
+    ...paths
+  ]);
+}
+async function diff_main_names() {
+  return await diff_names_since(await change_base());
+}
+async function diff_cached_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--cached",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION
+  ]);
+}
+async function diff_numstat_since(base) {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--numstat",
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    base,
+    "--"
+  ]);
+}
+var WHOLE_TREE_PATHSPEC = ":/";
+var UNTRACKED_ARGUMENTS = [
+  ...NO_PATH_QUOTING,
+  "ls-files",
+  "--others",
+  "--exclude-standard",
+  "--full-name",
+  WHOLE_TREE_PATHSPEC
+];
+async function untracked_names() {
+  return await git_spawn.read([...UNTRACKED_ARGUMENTS]);
+}
+var git_diff_reads = {
+  DEFAULT_BRANCH_ARGUMENTS,
+  UNTRACKED_ARGUMENTS,
+  change_base,
+  change_base_commit,
+  default_branch_of,
+  default_branch_reference,
+  diff_cached_names,
+  diff_main,
+  diff_main_names,
+  diff_numstat_since,
+  diff_names_since,
+  get_default_branch,
+  incoming_base_arguments,
+  later_base_arguments,
+  later_base_of,
+  merge_base_arguments,
+  names_since_arguments,
+  reference_check_arguments,
+  remote_reference_of,
+  tree_names_at,
+  untracked_names
+};
+
+// scripts/git/git-pre-push-hook.ts
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path4 from "node:path";
+var REMOTE = "origin";
+var HOOK_NAME = "pre-push";
+var PROBE_HOOK_NAME = "kit-hook-run-probe";
+var ALLOW_UNKNOWN_HOOK_NAME_FLAG = "--allow-unknown-hook-name";
+var HOOK_RUN = "run";
+var STDIN_FILE = "refs";
+var TEMPORARY_PREFIX = "kit-pre-push-";
+var ZERO_DIGIT = "0";
+async function read_remote_oid(branch2) {
+  try {
+    return await git_spawn.read([
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      `refs/remotes/${REMOTE}/${branch2}`
+    ]);
+  } catch {
+    return void 0;
+  }
+}
+async function read_push_references() {
+  const [branch2, local_oid] = await Promise.all([
+    git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]),
+    git_spawn.read(["rev-parse", "HEAD"])
+  ]);
+  return { branch: branch2, local_oid, remote_oid: await read_remote_oid(branch2) };
+}
+function to_stdin_line(references) {
+  const reference = `refs/heads/${references.branch}`;
+  const remote_oid = references.remote_oid ?? ZERO_DIGIT.repeat(references.local_oid.length);
+  return `${reference} ${references.local_oid} ${reference} ${remote_oid}
+`;
+}
+function to_hook_run_arguments(stdin_path, hook_name) {
+  return [HOOK_RUN, "--ignore-missing", `--to-stdin=${stdin_path}`, hook_name];
+}
+async function can_probe(probe_arguments) {
+  try {
+    await git_spawn.read(["hook", ...probe_arguments]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function can_run_hooks(stdin_path) {
+  const [, ...options] = to_hook_run_arguments(stdin_path, PROBE_HOOK_NAME);
+  if (await can_probe([HOOK_RUN, ALLOW_UNKNOWN_HOOK_NAME_FLAG, ...options])) return true;
+  return await can_probe([HOOK_RUN, ...options]);
+}
+async function run_with_stdin(stdin_line) {
+  const directory = await mkdtemp(path4.join(tmpdir2(), TEMPORARY_PREFIX));
+  const stdin_path = path4.join(directory, STDIN_FILE);
+  try {
+    await writeFile(stdin_path, stdin_line);
+    if (!await can_run_hooks(stdin_path)) return false;
+    const url = await git_spawn.read(["remote", "get-url", REMOTE]);
+    await git_spawn.with_output(
+      "hook",
+      [...to_hook_run_arguments(stdin_path, HOOK_NAME), "--", REMOTE, url],
+      { timeout_ms: SUITE_TIMEOUT_MS }
+    );
+    return true;
+  } finally {
+    await rm(directory, { force: true, recursive: true });
+  }
+}
+async function run() {
+  const references = await read_push_references();
+  if (references.local_oid === references.remote_oid) return true;
+  return await run_with_stdin(to_stdin_line(references));
+}
+var git_pre_push_hook = {
+  run
+};
+
+// scripts/lib/spawn-exit.ts
+function read_spawn_stdout(result) {
+  return result.stdout ?? "";
+}
+function read_spawn_stderr(result) {
+  return result.stderr ?? "";
+}
+
+// scripts/git/git-spawn-sync.ts
+import { execaSync } from "execa";
+
+// scripts/git/git-location-environment.ts
+var GIT_LOCATION_VARIABLES = [
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_NAMESPACE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_WORK_TREE"
+];
+function location_free_environment() {
+  return Object.fromEntries(GIT_LOCATION_VARIABLES.map((name) => [name, void 0]));
+}
+function forget(name) {
+  Reflect.deleteProperty(process.env, name);
+}
+function restore_one(name, value) {
+  if (value === void 0) forget(name);
+  else process.env[name] = value;
+}
+function clear_git_location_variables() {
+  const previous = GIT_LOCATION_VARIABLES.map((name) => [name, process.env[name]]);
+  for (const [name] of previous) forget(name);
+  return () => {
+    for (const [name, value] of previous) restore_one(name, value);
+  };
+}
+var git_location_environment = { clear_git_location_variables, location_free_environment };
+
+// scripts/git/git-spawn-sync.ts
+var SUCCESS_EXIT_CODE = 0;
+var C_LOCALE = { LC_ALL: "C", LANGUAGE: "C" };
+function run2(args, options = {}) {
+  const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
+    ...options,
+    extendEnv: true,
+    reject: false,
+    timeout: options.timeout ?? GIT_TIMEOUT_MS
+  });
+  return {
+    exit_code: result.exitCode,
+    stdout: read_spawn_stdout(result),
+    stderr: read_spawn_stderr(result)
+  };
+}
+function read2(args, options = {}) {
+  const result = run2(args, options);
+  return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : void 0;
+}
+function origin_url(cwd) {
+  return read2(["config", "--get", "remote.origin.url"], {
+    cwd,
+    env: git_location_environment.location_free_environment()
+  });
+}
+function toplevel(timeout = GIT_TIMEOUT_MS) {
+  return run2(["rev-parse", "--show-toplevel"], { env: C_LOCALE, timeout });
+}
+var git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run: run2, read: read2, origin_url, toplevel };
+
+// scripts/git/git-command.ts
+async function branch() {
+  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+async function status(directory) {
+  const location = directory === void 0 ? [] : ["-C", directory];
+  return await git_spawn.read([...location, "status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
+}
+async function repository_root() {
+  const result = git_spawn_sync.toplevel();
+  if (result.exit_code !== 0) throw create_spawn_error("rev-parse", result.exit_code);
+  return result.stdout.trim();
+}
+async function head_commit() {
+  return await git_spawn.read(["rev-parse", "HEAD"]);
+}
+var GIT_DIRECTORY_ARGUMENTS = [
+  "rev-parse",
+  "--absolute-git-dir",
+  "--path-format=absolute",
+  "--git-common-dir"
+];
+async function git_directories() {
+  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
+  return output.split("\n").filter((line) => line !== "");
+}
+async function diff_cached(file_path) {
+  return await git_spawn.read(["diff", "--cached", file_path]);
+}
+async function fetch_branch(branch_name) {
+  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
+  return await git_spawn.read_remote(["fetch", "origin", refspec]);
+}
+async function merge_fast_forward(branch_name) {
+  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`], SUITE_TIMEOUT_MS);
+}
+async function fast_forward_local(branch_name) {
+  return await git_spawn.read_remote(["fetch", "origin", `${branch_name}:${branch_name}`]);
+}
+async function merge_branch(branch_name, message) {
+  const message_arguments = message === void 0 ? [] : ["-m", message];
+  await git_spawn.with_output("merge", [...message_arguments, `origin/${branch_name}`], {
+    timeout_ms: SUITE_TIMEOUT_MS
+  });
+}
+async function checkout_b(branch_name) {
+  return await git_spawn.read(["checkout", "-b", branch_name], SUITE_TIMEOUT_MS);
+}
+async function checkout(branch_name) {
+  return await git_spawn.read(["checkout", branch_name], SUITE_TIMEOUT_MS);
+}
+async function commit(message) {
+  await git_spawn.with_output("commit", ["-m", message], { timeout_ms: SUITE_TIMEOUT_MS });
+}
+async function delete_branch(branch_name) {
+  await git_spawn.read(["branch", "-d", branch_name]);
+}
+async function read_commit_count(revisions) {
+  const output = await git_spawn.read(["rev-list", "--count", ...revisions]);
+  const parsed = Number(output);
+  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
+  throw new Error(
+    `\`git rev-list --count ${revisions.join(" ")}\` printed \`${output}\` rather than a count`
+  );
+}
+async function commit_count_beyond(base, tip) {
+  return await read_commit_count([`${base}..${tip}`]);
+}
+async function commit_count_unpushed(branch_name) {
+  return await read_commit_count([branch_name, "--not", "--remotes"]);
+}
+function is_exit_code_128(cause) {
+  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
+}
+function is_upstream_not_set_error(error) {
+  if (!(error instanceof Error)) return false;
+  const { cause } = error;
+  return cause !== void 0 && is_exit_code_128(cause);
+}
+var NO_VERIFY_FLAG = "--no-verify";
+async function push_with_upstream(branch_name, verify_flags) {
+  await git_push_transport.push([...verify_flags, "--set-upstream", "origin", branch_name]);
+}
+async function push2() {
+  const verify_flags = await git_pre_push_hook.run() ? [NO_VERIFY_FLAG] : [];
+  try {
+    await git_push_transport.push([...verify_flags]);
+  } catch (error) {
+    if (is_upstream_not_set_error(error)) {
+      const current_branch = await branch();
+      await push_with_upstream(current_branch, verify_flags);
+      return;
+    }
+    throw error;
+  }
+}
+async function pull_fast_forward() {
+  await git_spawn.with_output_remote("pull", ["--ff-only"]);
+}
+var SHORT_NAME_FORMAT = "--format=%(refname:short)";
+var REMOTES_FLAG = "--remotes";
+async function list_branches(flags, pattern) {
+  try {
+    const output = await git_spawn.read([
+      "branch",
+      "--list",
+      SHORT_NAME_FORMAT,
+      ...flags,
+      pattern
+    ]);
+    return output.split("\n").filter((line) => line.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+async function branch_names(pattern) {
+  return await list_branches([], pattern);
+}
+async function branch_names_remote(pattern) {
+  return await list_branches([REMOTES_FLAG], pattern);
+}
+async function branch_exists(branch_name) {
+  const names = await branch_names(branch_name);
+  return names.length > 0;
+}
+var ALL_PATHS_PATHSPEC = ":/";
+function exclude_pathspec(file_path) {
+  return `:(exclude,top)${file_path}`;
+}
+async function add_tracked(excluded_paths) {
+  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
+  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
+}
+async function add_path(file_path) {
+  await git_spawn.with_output("add", ["--", file_path]);
+}
+var FIRST_PARENT_FLAG = "--first-parent";
+async function log_first_parent(limit, file_path, tip = "HEAD") {
+  const output = await git_spawn.read([
+    "log",
+    FIRST_PARENT_FLAG,
+    "--format=%H",
+    `-n`,
+    String(limit),
+    tip,
+    "--",
+    file_path
+  ]);
+  return output.split("\n").filter((line) => line.length > 0);
+}
+async function show_file(spec) {
+  return await git_spawn.read(["show", spec]);
+}
+var MERGE_COUNT_ARGUMENTS = [
+  "rev-list",
+  "--count",
+  "--merges",
+  FIRST_PARENT_FLAG
+];
+function merge_count_arguments(range) {
+  return [...MERGE_COUNT_ARGUMENTS, range];
+}
+async function count_merges(range) {
+  const output = await git_spawn.read(merge_count_arguments(range));
+  const parsed = Number(output.trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+var git_command = {
+  GIT_DIRECTORY_ARGUMENTS,
+  branch,
+  status,
+  repository_root,
+  head_commit,
+  git_directories,
+  diff_cached,
+  // The default branch, the change base and every reading against it are `git-diff-reads.ts`'s,
+  // re-exported here so no call site, mock or spy moved with them.
+  ...git_diff_reads,
+  fetch_branch,
+  merge_fast_forward,
+  fast_forward_local,
+  merge_branch,
+  checkout_b,
+  checkout,
+  commit,
+  commit_count_beyond,
+  commit_count_unpushed,
+  delete_branch,
+  push: push2,
+  pull_fast_forward,
+  branch_exists,
+  branch_names,
+  branch_names_remote,
+  add_tracked,
+  add_path,
+  log_first_parent,
+  show_file,
+  count_merges,
+  merge_count_arguments,
+  is_upstream_not_set_error
+};
+
+// scripts/git/git-common-directory.ts
+import { execFileSync } from "node:child_process";
+var STATE_DIRECTORY = "josh";
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS2 = 5e3;
+var answers = /* @__PURE__ */ new Map();
+function probe_environment(cwd) {
+  if (cwd === void 0) return process.env;
+  return { ...process.env, ...git_location_environment.location_free_environment() };
+}
+function cache_key(cwd) {
+  if (cwd !== void 0) return `explicit\0${cwd}`;
+  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
+  return ["inherited", process.cwd(), ...locations].join("\0");
+}
+function read_directories(cwd) {
+  try {
+    const output = execFileSync(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      {
+        cwd,
+        env: probe_environment(cwd),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: PROBE_TIMEOUT_MS2
+      }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function directories(cwd) {
+  const key = cache_key(cwd);
+  const known = answers.get(key);
+  if (known !== void 0) return known;
+  const read3 = read_directories(cwd);
+  if (read3.length > 0) answers.set(key, read3);
+  return read3;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+function select_linked(found) {
+  const own_directory = found[OWN_GIT_DIRECTORY];
+  const common = found[COMMON_GIT_DIRECTORY];
+  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
+}
+function resolve(cwd) {
+  return select_linked(directories(cwd));
+}
+var git_common_directory = {
+  STATE_DIRECTORY,
+  directories,
+  own,
+  repository,
+  resolve,
+  select_linked
+};
+
+// scripts/discovery/repo-origin.ts
+var GITHUB_HOST = "github.com";
+var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
+var GIT_SUFFIX = ".git";
+var PATH_SEPARATOR = "/";
+var USER_SEPARATOR = "@";
+var HOST_SEPARATOR = ":";
+var OWNER_INDEX = 0;
+var REPO_INDEX = 1;
+var REPO_PATH_SEGMENTS = 2;
+var NOT_FOUND = -1;
+var SECTION_PREFIX = "[";
+var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
+var REMOTE_SECTION = /^\[remote\s+"[^"]+"\]$/u;
+var URL_KEY = "url";
+function is_github_hostname(host) {
+  return host.toLowerCase() === GITHUB_HOST;
+}
+function is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
+}
+function strip_git_suffix(name) {
+  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
+}
+function to_identity(repository_path) {
+  const segments = repository_path.split(PATH_SEPARATOR).filter((segment) => segment !== "");
+  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
+  const owner = segments[OWNER_INDEX] ?? "";
+  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
+  return repo === "" ? void 0 : { owner, repo };
+}
+function parse_scp_like(url) {
+  const user_end = url.indexOf(USER_SEPARATOR);
+  const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1);
+  const host_end = authority.indexOf(HOST_SEPARATOR);
+  if (host_end === NOT_FOUND || !is_github_ssh_host(authority.slice(0, host_end))) return void 0;
+  return to_identity(authority.slice(host_end + 1));
+}
+function parse_url_like(url) {
+  try {
+    const parsed = new URL(url);
+    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parse_origin_url(url) {
+  const trimmed = url.trim();
+  if (trimmed === "") return void 0;
+  return parse_url_like(trimmed) ?? parse_scp_like(trimmed);
+}
+function is_section_header(line) {
+  return line.startsWith(SECTION_PREFIX);
+}
+function origin_section_lines(lines) {
+  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
+  if (start === NOT_FOUND) return [];
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => is_section_header(line));
+  return end === NOT_FOUND ? rest : rest.slice(0, end);
+}
+function url_value(line) {
+  const separator = line.indexOf("=");
+  if (separator === NOT_FOUND || line.slice(0, separator).trim() !== URL_KEY) return void 0;
+  return line.slice(separator + 1).trim();
+}
+function parse_origin_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return origin_section_lines(lines).map((line) => url_value(line)).find((url) => url !== void 0);
+}
+function section_groups(lines) {
+  const groups = [];
+  for (const line of lines) {
+    if (is_section_header(line)) groups.push([line]);
+    else groups.at(-1)?.push(line);
+  }
+  return groups;
+}
+function parse_remote_urls_from_config(content) {
+  const lines = content.split("\n").map((line) => line.trim());
+  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => url_value(line))).filter((url) => url !== void 0);
+}
+function format_identity(identity) {
+  return `${identity.owner}${PATH_SEPARATOR}${identity.repo}`.toLowerCase();
+}
+var repo_origin = {
+  GITHUB_HOST,
+  is_github_hostname,
+  is_github_ssh_host,
+  parse_origin_from_config,
+  parse_origin_url,
+  parse_remote_urls_from_config,
+  format_identity
+};
+
+// scripts/discovery/repo-discovery.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import path5 from "node:path";
+
+// scripts/lib/stamped-memo.ts
+import { lstatSync as lstatSync2 } from "node:fs";
+var NO_STAMP = "";
+var STAMP_SEPARATOR = ":";
+function create() {
+  const answers2 = /* @__PURE__ */ new Map();
+  return {
+    of(key, stamp, compute) {
+      const known = answers2.get(key);
+      if (known?.stamp === stamp) return known.value;
+      const value = compute();
+      answers2.set(key, { stamp, value });
+      return value;
+    },
+    keep(keys) {
+      for (const key of answers2.keys()) if (!keys.has(key)) answers2.delete(key);
+    }
+  };
+}
+function file_stamp(file) {
+  try {
+    const status2 = lstatSync2(file);
+    return [status2.ino, status2.mtimeMs, status2.ctimeMs, status2.size].join(STAMP_SEPARATOR);
+  } catch {
+    return NO_STAMP;
+  }
+}
+var stamped_memo = { NO_STAMP, create, file_stamp };
+
+// scripts/discovery/repo-map-logic.ts
+var OVERRIDE_ENTRY_SEPARATOR = ",";
+var OVERRIDE_PAIR_SEPARATOR = "=";
+var OVERRIDE_PAIR_PARTS = 2;
+var KEY_INDEX = 0;
+var PATH_INDEX = 1;
+function is_same_owner(identity, current_owner) {
+  return identity.owner.toLowerCase() === current_owner.toLowerCase();
+}
+function add_entry(target, origin_url2, repository_path, current_owner) {
+  if (origin_url2 === void 0) return;
+  const identity = repo_origin.parse_origin_url(origin_url2);
+  if (identity === void 0 || !is_same_owner(identity, current_owner)) return;
+  target.set(repo_origin.format_identity(identity), repository_path);
+}
+function parse_override_entry(entry) {
+  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
+  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
+  const key = parts[KEY_INDEX] ?? "";
+  const repository_path = parts[PATH_INDEX] ?? "";
+  if (repository_path === "") return void 0;
+  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
+}
+function parse_overrides(raw) {
+  if (raw === void 0) return [];
+  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
+}
+function build_repository_map(discovered, current_owner, override_value) {
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner);
+  for (const entry of parse_overrides(override_value)) {
+    add_entry(result, entry.origin_url, entry.path, current_owner);
+  }
+  return result;
+}
+var repo_map_logic = {
+  is_same_owner,
+  build_repository_map
+};
+
+// scripts/discovery/repo-discovery.ts
+var GIT_DIRECTORY = ".git";
+var GIT_CONFIG = "config";
+var GITDIR_PREFIX = "gitdir:";
+var COMMON_DIRECTORY_FILE = "commondir";
+var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
+function resolve_common_directory(git_directory) {
+  const pointer = path5.join(git_directory, COMMON_DIRECTORY_FILE);
+  if (!existsSync(pointer)) return git_directory;
+  try {
+    return path5.resolve(git_directory, readFileSync2(pointer, "utf8").trim());
+  } catch {
+    return git_directory;
+  }
+}
+function follow_git_file(repository_path, git_file) {
+  const pointer = readFileSync2(git_file, "utf8").trim();
+  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
+  return path5.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
+}
+function resolve_git_directory(repository_path) {
+  const candidate = path5.join(repository_path, GIT_DIRECTORY);
+  if (!existsSync(candidate)) return void 0;
+  try {
+    if (statSync(candidate).isDirectory()) return candidate;
+    const linked = follow_git_file(repository_path, candidate);
+    return linked === void 0 ? void 0 : resolve_common_directory(linked);
+  } catch {
+    return void 0;
+  }
+}
+function read_text(file) {
+  try {
+    return readFileSync2(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var git_directories2 = stamped_memo.create();
+var configs = stamped_memo.create();
+function read_config(repository_path) {
+  const git_entry = path5.join(repository_path, GIT_DIRECTORY);
+  const git_directory = git_directories2.of(
+    repository_path,
+    stamped_memo.file_stamp(git_entry),
+    () => resolve_git_directory(repository_path)
+  );
+  if (git_directory === void 0) return void 0;
+  const config = path5.join(git_directory, GIT_CONFIG);
+  return configs.of(config, stamped_memo.file_stamp(config), () => read_text(config));
+}
+function read_origin_url(repository_path) {
+  const config = read_config(repository_path);
+  return config === void 0 ? void 0 : repo_origin.parse_origin_from_config(config);
+}
+function read_remote_urls(repository_path) {
+  const config = read_config(repository_path);
+  return config === void 0 ? [] : repo_origin.parse_remote_urls_from_config(config);
+}
+function sibling_directories(parent) {
+  try {
+    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path5.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function scan_siblings(parent) {
+  return sibling_directories(parent).map((repository_path) => ({
+    path: repository_path,
+    origin_url: read_origin_url(repository_path)
+  }));
+}
+function resolve_current_owner(repository_path) {
+  const origin_url2 = read_origin_url(repository_path);
+  if (origin_url2 === void 0) return void 0;
+  return repo_origin.parse_origin_url(origin_url2)?.owner;
+}
+function main_worktree(repository_path) {
+  const git_directory = resolve_git_directory(repository_path);
+  if (git_directory === void 0 || path5.basename(git_directory) !== GIT_DIRECTORY) {
+    return repository_path;
+  }
+  return path5.dirname(git_directory);
+}
+function discover_repositories(repository_path, environment = process.env) {
+  const main = main_worktree(repository_path);
+  const current_owner = resolve_current_owner(main);
+  if (current_owner === void 0) return /* @__PURE__ */ new Map();
+  return repo_map_logic.build_repository_map(
+    scan_siblings(path5.dirname(main)),
+    current_owner,
+    environment[OVERRIDE_ENV_KEY]
+  );
+}
+var repo_discovery = {
+  OVERRIDE_ENV_KEY,
+  main_worktree,
+  read_origin_url,
+  read_remote_urls,
+  resolve_current_owner,
+  scan_siblings,
+  discover_repositories
+};
+
+// scripts/lib/error-message.ts
+function message_of(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var DEBUG_ENV_KEY = "JOSH_DEBUG";
+function trace_swallowed(where, error) {
+  if ((process.env[DEBUG_ENV_KEY] ?? "").trim() === "") return;
+  process.stderr.write(`josh debug: ${where}: ${message_of(error)}
+`);
+}
+var error_text = { message_of, trace_swallowed };
+
+export {
+  PACKAGE_DIR,
+  PROJECT_ROOT,
+  package_path,
+  PLATFORM_TEMP_ROOT,
+  platform_temporary,
+  atomic_write,
+  stamp_file,
+  MS_PER_SECOND,
+  MS_PER_MINUTE,
+  PROBE_TIMEOUT_MS,
+  FETCH_TIMEOUT_MS,
+  HOOK_PROCESS_TIMEOUT_MS,
+  GH_API_TIMEOUT_MS,
+  COMMAND_TIMEOUT_MS,
+  INSTALL_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS,
+  PORCELAIN_FLAG,
+  UNTRACKED_FILES_FLAG,
+  get_exit_code,
+  has_timed_out,
+  git_spawn,
+  git_diff_reads,
+  GIT_LOCATION_VARIABLES,
+  git_location_environment,
+  git_spawn_sync,
+  git_command,
+  git_common_directory,
+  stamped_memo,
+  repo_origin,
+  repo_map_logic,
+  repo_discovery,
+  error_text
+};