@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/dist/version/index.js

@@ -62,9 +62,8 @@ function create_version_command_config(options) {
 }
 
 // scripts/version/effective-upstream.ts
-import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // scripts/lib/ancestor-directories.ts
 import path from "node:path";
@@ -83,6 +82,10 @@ function nearest(start_directory, is_match) {
 }
 var ancestor_directories = { list, nearest };
 
+// scripts/lib/package-manifest.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+
 // scripts/lib/json-value.ts
 function parse_or_undefined(text) {
   try {
@@ -97,10 +100,56 @@ function parse_with(text, schema) {
   const parsed = schema.safeParse(value);
   return parsed.success ? parsed.data : void 0;
 }
+function parse_array(text) {
+  const value = parse_or_undefined(text);
+  return Array.isArray(value) ? value : void 0;
+}
 function is_record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var json_value = { parse_or_undefined, parse_with, is_record };
+var json_value = { parse_or_undefined, parse_with, parse_array, is_record };
+
+// scripts/lib/read-file.ts
+import { readFileSync } from "node:fs";
+var ABSENT_CODE = "ENOENT";
+function is_absent(error) {
+  return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
+}
+function read_optional(path7) {
+  try {
+    return readFileSync(path7, "utf8");
+  } catch (error) {
+    if (is_absent(error)) return void 0;
+    throw error;
+  }
+}
+function read_file_or_empty(path7) {
+  return read_optional(path7) ?? "";
+}
+function read_if_readable(path7) {
+  try {
+    return readFileSync(path7, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var file_reader = { is_absent, read_optional, read_file_or_empty, read_if_readable };
+
+// scripts/lib/package-manifest.ts
+var PACKAGE_JSON = "package.json";
+function manifest_path(directory) {
+  return path2.join(directory, PACKAGE_JSON);
+}
+function read_manifest(directory, schema) {
+  const text = readFileSync2(manifest_path(directory), "utf8");
+  return schema.parse(JSON.parse(text));
+}
+function read_manifest_if_valid(directory, schema) {
+  const text = file_reader.read_if_readable(manifest_path(directory));
+  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 };
 
 // scripts/lib/schemas.ts
 import { z } from "zod";
@@ -135,18 +184,14 @@ var string_array_schema = z.array(z.string());
 var string_record_schema = z.record(z.string(), z.string());
 
 // scripts/version/effective-upstream.ts
-var PACKAGE_JSON = "package.json";
-function read_matching_version(manifest_path, package_name) {
-  if (!existsSync(manifest_path)) return void 0;
-  const parsed = package_named_version_schema.safeParse(
-    json_value.parse_or_undefined(readFileSync(manifest_path, "utf8"))
-  );
-  if (!parsed.success || parsed.data.name !== package_name) return void 0;
-  return parsed.data.version;
+function read_matching_version(directory, package_name) {
+  const manifest = package_manifest.read_manifest_if_valid(directory, package_named_version_schema);
+  if (manifest?.name !== package_name) return void 0;
+  return manifest.version;
 }
 function walk_up_for_version(start_directory, package_name) {
   for (const directory of ancestor_directories.list(start_directory)) {
-    const version = read_matching_version(path2.join(directory, PACKAGE_JSON), package_name);
+    const version = read_matching_version(directory, package_name);
     if (version !== void 0) return version;
   }
   return void 0;
@@ -161,10 +206,13 @@ function resolve_from_base(base_url, package_name, resolve_marker = package_name
 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(path2.dirname(resolved), package_name);
+  return walk_up_for_version(path3.dirname(resolved), package_name);
 }
 
 // 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 FETCH_TIMEOUT_MS = 1e4;
 var COMMAND_TIMEOUT_MS = 3e4;
 var INSTALL_TIMEOUT_MS = 6e5;
@@ -173,8 +221,8 @@ var INSTALL_TIMEOUT_MS = 6e5;
 import { execaSync as execaSync4 } from "execa";
 
 // scripts/version/release-age.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import path3 from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+import path4 from "node:path";
 
 // scripts/lib/yaml-document.ts
 import { load, loadAll, YAMLException } from "js-yaml";
@@ -208,7 +256,6 @@ 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 MS_PER_MINUTE = 6e4;
 function parse_workspace(workspace_content) {
   try {
     return yaml_document.parse_yaml(workspace_content);
@@ -240,7 +287,7 @@ function select_aged_version(times, major, minimum_age_minutes, now_ms) {
 }
 function read_declared_minimum_release_age(workspace_path) {
   try {
-    return parse_declared_minimum_release_age(readFileSync2(workspace_path, "utf8"));
+    return parse_declared_minimum_release_age(readFileSync3(workspace_path, "utf8"));
   } catch {
     return void 0;
   }
@@ -249,14 +296,14 @@ function read_minimum_release_age(workspace_path = WORKSPACE_PATH) {
   return read_declared_minimum_release_age(workspace_path) ?? NO_QUARANTINE_MINUTES;
 }
 function find_declared_minimum_release_age(start, boundary) {
-  const declared = read_declared_minimum_release_age(path3.join(start, WORKSPACE_PATH));
+  const declared = read_declared_minimum_release_age(path4.join(start, WORKSPACE_PATH));
   if (declared !== void 0) return declared;
   if (start === boundary) return void 0;
-  const parent = path3.dirname(start);
+  const parent = path4.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(path3.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
+  return find_declared_minimum_release_age(path4.resolve(start), boundary) ?? NO_QUARANTINE_MINUTES;
 }
 var release_age = {
   release_times_schema,
@@ -270,14 +317,13 @@ var release_age = {
 // 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;
+  return published_ms > now_ms - minimum_age_minutes * MS_PER_MINUTE;
 }
 function resolve_installable(times, latest, minimum_age_minutes, now_ms) {
   if (times === void 0 || !is_latest_withheld(times, latest, minimum_age_minutes, now_ms)) {
@@ -320,21 +366,20 @@ var release_hold = {
 };
 
 // scripts/version/running-binary.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import path4 from "node:path";
-var PACKAGE_JSON2 = "package.json";
+import { existsSync, readFileSync as readFileSync4 } from "node:fs";
+import path5 from "node:path";
 var SCRIPT_DEPTH_FROM_ROOT = ["..", ".."];
 function resolve_self_package_path(self_directory) {
-  return path4.join(self_directory, ...SCRIPT_DEPTH_FROM_ROOT, PACKAGE_JSON2);
+  return path5.join(self_directory, ...SCRIPT_DEPTH_FROM_ROOT, PACKAGE_JSON);
 }
 function running_package_directory(self_directory) {
-  return path4.resolve(self_directory, ...SCRIPT_DEPTH_FROM_ROOT);
+  return path5.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;
+  if (!existsSync(package_path)) return void 0;
   const parsed = package_version_schema.safeParse(
-    json_value.parse_or_undefined(readFileSync3(package_path, "utf8"))
+    json_value.parse_or_undefined(readFileSync4(package_path, "utf8"))
   );
   return parsed.success ? parsed.data.version : void 0;
 }
@@ -536,6 +581,11 @@ var version_check_logic = {
 };
 
 // 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;
@@ -636,6 +686,75 @@ function trace_swallowed(where, error) {
 }
 var error_text = { message_of, trace_swallowed };
 
+// scripts/lib/token-shape.ts
+var REDACTED = "[REDACTED]";
+var GITHUB_RULE = "@secretlint/secretlint-rule-github";
+var ANTHROPIC_OAUTH_TOKEN = /sk-ant-oat\d+-[\w-]+/u;
+var SHAPES = [
+  {
+    name: "GitHub token",
+    pattern: new RegExp("(?<!\\p{L})(?:ghp|gho|ghu|ghs|ghr)_\\w{36}(?!\\w)", "u"),
+    secretlint: GITHUB_RULE
+  },
+  {
+    name: "GitHub App installation token",
+    pattern: new RegExp("(?<!\\p{L})ghs_\\d{1,20}_[\\w-]{1,1000}\\.[\\w-]{1,10000}\\.[\\w-]{1,1000}(?![\\w-])", "u"),
+    secretlint: GITHUB_RULE
+  },
+  {
+    name: "GitHub fine-grained token",
+    pattern: new RegExp("(?<!\\p{L})github_pat_\\w{82}(?!\\w)", "u"),
+    secretlint: GITHUB_RULE
+  },
+  {
+    name: "Slack token",
+    pattern: /\b(?:xoxb|xoxp|xapp|xoxa|xoxo|xoxr)-(?:\d-)?(?:[a-zA-Z0-9]{1,40}-)+[a-zA-Z0-9]{1,40}\b/u,
+    secretlint: "@secretlint/secretlint-rule-slack"
+  },
+  {
+    name: "Anthropic API key",
+    pattern: new RegExp("(?<!\\p{L})sk-ant-api0\\d-[\\w-]{90,128}AA(?![\\w-])", "u"),
+    secretlint: "@secretlint/secretlint-rule-anthropic"
+  },
+  { name: "Anthropic OAuth token", pattern: ANTHROPIC_OAUTH_TOKEN, secretlint: void 0 }
+];
+var EVERY_SHAPE = new RegExp(SHAPES.map((shape) => shape.pattern.source).join("|"), "gu");
+function find(text) {
+  return SHAPES.find((shape) => shape.pattern.test(text));
+}
+function holds(text) {
+  return SHAPES.some((shape) => shape.pattern.test(text));
+}
+function refuse(text, subject) {
+  const shape = find(text);
+  if (shape === void 0) return;
+  throw new Error(
+    `${subject} holds a ${shape.name}-shaped string, so it was not sent. Remove the credential and send it again.`
+  );
+}
+function redact(text) {
+  return text.replaceAll(EVERY_SHAPE, () => REDACTED);
+}
+function string_leaves(value) {
+  if (typeof value === "string") return [value];
+  if (typeof value !== "object" || value === null) return [];
+  return Object.values(value).flatMap((entry) => string_leaves(entry));
+}
+function decoded(body) {
+  const value = json_value.parse_or_undefined(body);
+  return value === void 0 ? body : string_leaves(value).join("\n");
+}
+var token_shape = {
+  ANTHROPIC_OAUTH_TOKEN,
+  REDACTED,
+  SHAPES,
+  decoded,
+  find,
+  holds,
+  refuse,
+  redact
+};
+
 // scripts/gh/git-gh-exec.ts
 import { execa as execa2, execaSync } from "execa";
 
@@ -698,6 +817,78 @@ function failure_of(error) {
 }
 var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
 
+// scripts/gh/git-gh-retry.ts
+import { setTimeout as delay } from "node:timers/promises";
+var FIRST_RETRY_DELAY_MS = 2e3;
+var SECOND_RETRY_DELAY_MS = 5e3;
+var RETRY_DELAYS_MS = [FIRST_RETRY_DELAY_MS, SECOND_RETRY_DELAY_MS];
+var MAX_ATTEMPTS = RETRY_DELAYS_MS.length + 1;
+var SERVER_ERROR_FLOOR = 500;
+var GH_AUTH_REQUIRED_EXIT_CODE = 4;
+var SPENT_NOTE = "gh: request failed transiently on every attempt";
+var SUMMARY_STATUS_PATTERN = /\(HTTP (?<status>\d{3})\)/u;
+var DEFAULT_HOOKS = {
+  wait: async (milliseconds) => {
+    await delay(milliseconds);
+  },
+  note: (text) => {
+    process.stderr.write(`${text}
+`);
+  }
+};
+function summary_status(error) {
+  const { status } = SUMMARY_STATUS_PATTERN.exec(error.message)?.groups ?? {};
+  return status === void 0 ? void 0 : Number(status);
+}
+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) {
+  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_transient(error) {
+  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);
+}
+function first_line(error) {
+  return error_text.message_of(error).split("\n", 1)[0] ?? "";
+}
+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 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)));
+}
+async function with_retry(request, hooks = DEFAULT_HOOKS, attempt = 1) {
+  try {
+    return await request();
+  } catch (error) {
+    const wait_ms = retry_delay(error, attempt);
+    if (wait_ms === void 0) {
+      note_spent(error, attempt, hooks);
+      throw error;
+    }
+    hooks.note(retry_note(error, attempt, wait_ms));
+    await hooks.wait(wait_ms);
+    return await with_retry(request, hooks, attempt + 1);
+  }
+}
+var gh_retry = { MAX_ATTEMPTS, RETRY_DELAYS_MS, is_transient, spent_note, with_retry };
+
 // scripts/gh/git-gh-exec.ts
 var BODY_FROM_STDIN = "-";
 var GH_REQUEST_TIMEOUT_MS = 6e4;
@@ -764,20 +955,20 @@ 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(path6, timeout_ms) {
+async function exec_gh_api_status(path7, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
     await check_gh_installed();
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path6], options);
+    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path7], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
   }
 }
-function exec_gh_api_status_sync(path6, timeout_ms) {
+function exec_gh_api_status_sync(path7, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path6], options);
+    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path7], options);
     return parse_status_line(stdout);
   } catch (error) {
     return status_of_failure(error);
@@ -788,13 +979,20 @@ var INPUT_FLAG = "--input";
 var PAGINATE_FLAG = "--paginate";
 var SLURP_FLAG = "--slurp";
 var JQ_FLAG = "--jq";
+var ALLOW_ESCAPES_FLAG = "--allow-escape-sequences";
 function optional_flag(flag, value) {
   return value === void 0 ? [] : [flag, value];
 }
+function refuse_credential_body(request) {
+  if (request.body !== void 0) {
+    token_shape.refuse(token_shape.decoded(request.body), `The gh api ${request.path} body`);
+  }
+}
 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] : [];
+  const escape_args = request.should_allow_escapes === true ? [ALLOW_ESCAPES_FLAG] : [];
   return [
     "api",
     request.path,
@@ -802,10 +1000,11 @@ function to_gh_api_args(request) {
     ...body_args,
     ...paginate_args,
     ...slurp_args,
+    ...escape_args,
     ...optional_flag(JQ_FLAG, request.jq_filter)
   ];
 }
-async function exec_gh_api(request) {
+async function send_gh_api(request) {
   const args = to_gh_api_args(request);
   if (request.body === void 0) {
     return await exec_gh_command(args, request.timeout_ms, request.cwd);
@@ -817,7 +1016,13 @@ async function exec_gh_api(request) {
     cwd: request.cwd
   });
 }
+async function exec_gh_api(request) {
+  refuse_credential_body(request);
+  if (request.should_retry === false) return await send_gh_api(request);
+  return await gh_retry.with_retry(async () => await send_gh_api(request));
+}
 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) };
   try {
@@ -846,328 +1051,21 @@ var git_gh_exec = {
   parse_status_line
 };
 
-// scripts/gh/fix-gh-packages-logic.ts
-import { loadAll as loadAll2 } from "js-yaml";
-import { z as z4 } from "zod";
-var GH_PACKAGES_HOST = "npm.pkg.github.com";
-var RESOLUTION_BLOCK = "\n    resolution:\n";
-var INTEGRITY_PREFIX = "      integrity: ";
-var TARBALL_PREFIX = "      tarball: ";
-var FLOW_RESOLUTION_LINE_START = "\n    resolution: {";
-var FLOW_TARBALL_KEY = ", tarball: ";
-var NPMRC_AUTH_TOKEN_PREFIX = `//${GH_PACKAGES_HOST}/:_authToken=`;
-var REGISTRY_KEY = ":registry=";
-var lockfile_resolution_schema = z4.looseObject({
-  integrity: z4.string().optional(),
-  tarball: z4.string().optional()
-});
-var lockfile_package_schema = z4.looseObject({
-  resolution: lockfile_resolution_schema.optional()
-});
-var lockfile_document_schema = z4.looseObject({
-  packages: z4.record(z4.string(), lockfile_package_schema).optional()
-});
-function parse_lockfile_packages(raw) {
-  const merged = {};
-  for (const document of loadAll2(raw)) {
-    const { packages } = lockfile_document_schema.parse(document);
-    if (packages !== void 0) Object.assign(merged, packages);
-  }
-  return merged;
-}
-function extract_gh_registry_scope(line) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith("@")) return void 0;
-  const eq_index = trimmed.indexOf(REGISTRY_KEY);
-  if (eq_index === -1) return void 0;
-  const registry = trimmed.slice(eq_index + REGISTRY_KEY.length).trim().replace(/\/$/u, "");
-  if (registry !== `https://${GH_PACKAGES_HOST}`) return void 0;
-  return trimmed.slice(0, eq_index);
-}
-function parse_gh_scopes(npmrc) {
-  const scopes = /* @__PURE__ */ new Set();
-  for (const line of npmrc.split("\n")) {
-    const scope = extract_gh_registry_scope(line);
-    if (scope !== void 0) scopes.add(scope);
-  }
-  return scopes;
-}
-function extract_auth_token_from_line(line) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith(NPMRC_AUTH_TOKEN_PREFIX)) return void 0;
-  const value = trimmed.slice(NPMRC_AUTH_TOKEN_PREFIX.length);
-  if (value.startsWith("${") || value.length === 0) return void 0;
-  return value;
-}
-function parse_npmrc_auth_token(npmrc) {
-  for (const line of npmrc.split("\n")) {
-    const token = extract_auth_token_from_line(line);
-    if (token !== void 0) return token;
-  }
-  return void 0;
-}
-function scope_from_key(key) {
-  return key.startsWith("@") ? key.split("/", 1)[0] ?? "" : "";
-}
-function has_tarball(entry) {
-  return entry.resolution?.tarball !== void 0;
-}
-function package_path_from_key(key) {
-  const start = key.startsWith("@") ? 1 : 0;
-  const at_index = key.indexOf("@", start);
-  return at_index === -1 ? key : key.slice(0, at_index);
-}
-function package_version_from_key(key) {
-  const start = key.startsWith("@") ? 1 : 0;
-  const at_index = key.indexOf("@", start);
-  if (at_index === -1) return "";
-  return key.slice(at_index + 1).split("(", 1)[0] ?? "";
-}
-function should_fix_tarball(key, entry, scopes) {
-  if (has_tarball(entry)) return false;
-  const scope = scope_from_key(key);
-  return scope.length > 0 && scopes.has(scope);
-}
-function find_entry_start(content, package_key) {
-  const single = content.indexOf(`
-  '${package_key}':
-`);
-  if (single !== -1) return single;
-  return content.indexOf(`
-  "${package_key}":
-`);
-}
-function find_entry_end(content, entry_start) {
-  const next_match = /\n {2}['"]/u.exec(content.slice(entry_start + 1));
-  return next_match === null ? content.length : entry_start + 1 + next_match.index;
-}
-function find_integrity_eol_in_entry(entry_content) {
-  const resolution_pos = entry_content.indexOf(RESOLUTION_BLOCK);
-  if (resolution_pos === -1) return -1;
-  const integrity_pos = entry_content.indexOf(INTEGRITY_PREFIX, resolution_pos);
-  if (integrity_pos === -1) return -1;
-  return entry_content.indexOf("\n", integrity_pos);
-}
-function find_flow_resolution_brace(entry_content) {
-  const pos = entry_content.indexOf(FLOW_RESOLUTION_LINE_START);
-  if (pos === -1) return -1;
-  const line_end = entry_content.indexOf("\n", pos + 1);
-  const search_end = line_end === -1 ? entry_content.length : line_end;
-  const brace = entry_content.lastIndexOf("}", search_end);
-  if (brace <= pos) return -1;
-  return brace;
-}
-function insert_expanded_tarball(content, entry_start, entry_end, tarball) {
-  const entry_content = content.slice(entry_start, entry_end);
-  const integrity_eol = find_integrity_eol_in_entry(entry_content);
-  if (integrity_eol === -1) return void 0;
-  if (entry_content.slice(integrity_eol + 1).startsWith(TARBALL_PREFIX)) return content;
-  const patched = `${entry_content.slice(0, integrity_eol + 1)}${TARBALL_PREFIX}${tarball}
-${entry_content.slice(integrity_eol + 1)}`;
-  return content.slice(0, entry_start) + patched + content.slice(entry_end);
-}
-function insert_flow_tarball(content, entry_start, entry_end, tarball) {
-  const entry_content = content.slice(entry_start, entry_end);
-  const brace_pos = find_flow_resolution_brace(entry_content);
-  if (brace_pos === -1) return void 0;
-  const open_brace = entry_content.lastIndexOf("{", brace_pos);
-  if (open_brace === -1) return void 0;
-  const flow_body = entry_content.slice(open_brace + 1, brace_pos);
-  if (/\btarball\s*:/u.test(flow_body)) return content;
-  const patched = `${entry_content.slice(0, brace_pos)}${FLOW_TARBALL_KEY}${tarball}${entry_content.slice(brace_pos)}`;
-  return content.slice(0, entry_start) + patched + content.slice(entry_end);
-}
-function insert_tarball_for_key(content, package_key, tarball) {
-  const entry_start = find_entry_start(content, package_key);
-  if (entry_start === -1) return content;
-  const entry_end = find_entry_end(content, entry_start);
-  return insert_expanded_tarball(content, entry_start, entry_end, tarball) ?? insert_flow_tarball(content, entry_start, entry_end, tarball) ?? content;
-}
-function patch_lockfile(content, patches) {
-  let result = content;
-  for (const [key, tarball] of patches) {
-    result = insert_tarball_for_key(result, key, tarball);
-  }
-  return result;
-}
-function resolve_token(environment_token, npmrc_token, get_fallback_token) {
-  if (environment_token !== void 0 && environment_token.length > 0) return environment_token;
-  if (npmrc_token !== void 0) return npmrc_token;
-  return get_fallback_token();
-}
-var fix_gh_packages_logic = {
-  parse_gh_scopes,
-  parse_npmrc_auth_token,
-  parse_lockfile_packages,
-  package_path_from_key,
-  package_version_from_key,
-  needs_tarball_fix: should_fix_tarball,
-  insert_tarball_for_key,
-  patch_lockfile,
-  resolve_token
-};
-
-// scripts/registry-migration/migrate-logic.ts
-var SCOPE = "@joshuafolkken";
-var REGISTRY_KEY2 = `${SCOPE}:registry`;
-var PUBLIC_REGISTRY = "https://registry.npmjs.org/";
-var GITHUB_REGISTRY = "https://npm.pkg.github.com/";
-var MAPPING = `${REGISTRY_KEY2}=${PUBLIC_REGISTRY}`;
-var REGISTRY_VALUE_INDEX = 1;
-var SPLIT_LIMIT = 2;
-function normalized_registry(value) {
-  let normalized = value.trim();
-  while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
-  return `${normalized}/`;
-}
-function mapping_lines(content) {
-  return content.split(/\r?\n/u).filter((line) => line.trimStart().startsWith(`${REGISTRY_KEY2}=`));
-}
-function registry_of(content) {
-  const lines = mapping_lines(content);
-  if (lines.length !== 1) return void 0;
-  return normalized_registry(lines[0]?.split("=", SPLIT_LIMIT)[REGISTRY_VALUE_INDEX] ?? "");
-}
-function scoped_packages(lockfile) {
-  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
-  return Object.keys(packages).filter((key) => key.startsWith(`${SCOPE}/`)).map((key) => fix_gh_packages_logic.package_path_from_key(key)).filter((name, index, names) => names.indexOf(name) === index);
-}
-function scoped_versions(lockfile) {
-  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
-  return Object.keys(packages).filter((key) => key.startsWith(`${SCOPE}/`)).map(
-    (key) => [
-      fix_gh_packages_logic.package_path_from_key(key),
-      fix_gh_packages_logic.package_version_from_key(key)
-    ]
-  );
-}
-function is_github_tarball(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "https:" && url.hostname === "npm.pkg.github.com";
-  } catch {
-    return false;
-  }
-}
-function github_tarballs(lockfile) {
-  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
-  return Object.entries(packages).filter(
-    ([key, entry]) => key.startsWith(`${SCOPE}/`) && entry.resolution?.tarball !== void 0 && is_github_tarball(entry.resolution.tarball)
-  ).map(([key]) => key);
-}
-function remove_flow_tarball(line) {
-  const marker = ", tarball: https://npm.pkg.github.com/";
-  const start = line.indexOf(marker);
-  if (start === -1) return line;
-  const end = line.indexOf("}", start);
-  if (end === -1) return line;
-  return `${line.slice(0, start)}${line.slice(end)}`;
-}
-function is_package_entry(line) {
-  return /^ {2}[^ ]/u.test(line);
-}
-function is_github_tarball_line(line) {
-  return line.trimStart().startsWith("tarball: https://npm.pkg.github.com/");
-}
-function package_id(key) {
-  const name = fix_gh_packages_logic.package_path_from_key(key);
-  return `${name}@${fix_gh_packages_logic.package_version_from_key(key)}`;
-}
-function clean_scoped_line(line, id, integrities) {
-  if (!id) return line;
-  if (is_github_tarball_line(line)) return void 0;
-  const cleaned = remove_flow_tarball(line);
-  const pair = integrities.get(id);
-  if (pair === void 0) return cleaned;
-  return cleaned.split(`integrity: ${pair[0]}`).join(`integrity: ${pair[1]}`);
-}
-function next_scoped_id(line, id) {
-  if (!is_package_entry(line)) return id;
-  const prefix = `  '${SCOPE}/`;
-  if (!line.startsWith(prefix)) return "";
-  return package_id(line.slice("  '".length).split("'", 1)[0] ?? "");
-}
-function integrity_pair(old_integrity, npm_integrity) {
-  if (old_integrity === void 0 || npm_integrity === void 0) return void 0;
-  return [old_integrity, npm_integrity];
-}
-function lock_integrities(lockfile, npm_integrities) {
-  const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile);
-  const pairs = /* @__PURE__ */ new Map();
-  const scoped_entries = Object.entries(packages).filter(([key]) => key.startsWith(`${SCOPE}/`));
-  for (const [key, entry] of scoped_entries) {
-    const id = package_id(key);
-    const pair = integrity_pair(entry.resolution?.integrity, npm_integrities.get(id));
-    if (pair !== void 0) pairs.set(id, pair);
-  }
-  return pairs;
-}
-function push_if_defined(lines, cleaned) {
-  if (cleaned !== void 0) lines.push(cleaned);
-}
-function rewrite_scoped_lockfile(lockfile, npm_integrities) {
-  let id = "";
-  const lines = [];
-  const integrities = lock_integrities(lockfile, npm_integrities);
-  for (const line of lockfile.split("\n")) {
-    id = next_scoped_id(line, id);
-    const cleaned = clean_scoped_line(line, id, integrities);
-    push_if_defined(lines, cleaned);
-  }
-  return lines.join("\n");
-}
-function append_mapping(content, eol) {
-  const separator = content && !content.endsWith("\n") ? eol : "";
-  return `${content}${separator}${MAPPING}${eol}`;
-}
-function replace_mapping(content) {
-  const lines = mapping_lines(content);
-  const eol = content.includes("\r\n") ? "\r\n" : "\n";
-  if (lines.length === 0) return append_mapping(content, eol);
-  return content.split(/\r?\n/u).map((line) => line === lines[0] ? MAPPING : line).join(eol);
-}
-function unsupported_registry(project_npmrc) {
-  const registry = registry_of(project_npmrc);
-  if (registry === void 0 || [GITHUB_REGISTRY, PUBLIC_REGISTRY].includes(registry)) {
-    return void 0;
-  }
-  return `unsupported project registry: ${registry}`;
-}
-function has_duplicate_mapping(project_npmrc, user_npmrc) {
-  return mapping_lines(project_npmrc).length > 1 || mapping_lines(user_npmrc).length > 1;
-}
-function previous_registry(project_npmrc, user_npmrc) {
-  return registry_of(project_npmrc) ?? registry_of(user_npmrc) ?? "default npm";
-}
-function plan(project_npmrc, user_npmrc, lockfile) {
-  const packages = scoped_packages(lockfile);
-  const blocked = [];
-  if (has_duplicate_mapping(project_npmrc, user_npmrc)) blocked.push("duplicate registry mappings");
-  const unsupported = unsupported_registry(project_npmrc);
-  if (unsupported !== void 0) blocked.push(unsupported);
-  const before = previous_registry(project_npmrc, user_npmrc);
-  const change = `${before} \u2192 ${PUBLIC_REGISTRY}`;
-  return { content: replace_mapping(project_npmrc), packages, blocked, change };
-}
-var migrate_logic = {
-  plan,
-  github_tarballs,
-  is_github_tarball,
-  rewrite_scoped_lockfile,
-  scoped_versions
-};
-
 // scripts/version/npm-registry.ts
 import { execaSync as execaSync2 } from "execa";
 import semver3 from "semver";
-import { z as z5 } from "zod";
-var PUBLIC_REGISTRY2 = "https://registry.npmjs.org";
+import { z as z4 } from "zod";
+var PUBLIC_REGISTRY = "https://registry.npmjs.org";
 var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
 var FULL_ACCEPT = "application/json";
 var SCOPE_SEPARATOR = "/";
 var ENCODED_SCOPE_SEPARATOR = "%2f";
 var SCOPE_PATTERN = /^@[^/]+(?=\/)/u;
 var SCOPE_REGISTRY_SUFFIX = ":registry";
+var GITHUB_REGISTRY_HOST = "npm.pkg.github.com";
+var PNPM = "pnpm";
+var JSON_FLAG = "--json";
+var FAILURE_EXIT_CODE = 1;
 var github_scopes = /* @__PURE__ */ new Map();
 var FETCH_SCRIPT = [
   "const [url, accept] = process.argv.slice(1)",
@@ -1175,11 +1073,11 @@ var FETCH_SCRIPT = [
   "if (!response.ok) process.exit(1)",
   "process.stdout.write(await response.text())"
 ].join("\n");
-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 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 });
 function packument_url(package_name) {
-  return `${PUBLIC_REGISTRY2}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
+  return `${PUBLIC_REGISTRY}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
 }
 function read_packument(package_name, accept) {
   const result = execaSync2(
@@ -1190,14 +1088,22 @@ function read_packument(package_name, accept) {
   if (result.exitCode !== 0) return void 0;
   return json_value.parse_or_undefined(result.stdout);
 }
+function is_github_registry(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname === GITHUB_REGISTRY_HOST;
+  } catch {
+    return false;
+  }
+}
 function is_github_scope(scope) {
   const is_cached_github = github_scopes.get(scope);
   if (is_cached_github !== void 0) return is_cached_github;
-  const result = execaSync2("pnpm", ["config", "get", `${scope}${SCOPE_REGISTRY_SUFFIX}`], {
+  const result = execaSync2(PNPM, ["config", "get", `${scope}${SCOPE_REGISTRY_SUFFIX}`], {
     reject: false,
     timeout: FETCH_TIMEOUT_MS
   });
-  const is_github = result.exitCode === 0 && migrate_logic.is_github_tarball(result.stdout.trim());
+  const is_github = result.exitCode === 0 && is_github_registry(result.stdout.trim());
   github_scopes.set(scope, is_github);
   return is_github;
 }
@@ -1219,6 +1125,14 @@ 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 view(spec, field, format = "text") {
+  const format_arguments = format === "json" ? [JSON_FLAG] : [];
+  const result = execaSync2(PNPM, ["view", spec, field, ...format_arguments], {
+    reject: false,
+    timeout: COMMAND_TIMEOUT_MS
+  });
+  return { exit_code: result.exitCode ?? FAILURE_EXIT_CODE, stdout: result.stdout };
+}
 function valid_version(value) {
   return version_schema.safeParse(value).success ? value : void 0;
 }
@@ -1227,7 +1141,8 @@ var npm_registry = {
   packument_url,
   read_latest,
   read_release_times,
-  valid_version
+  valid_version,
+  view
 };
 
 // scripts/version/version-remote.ts
@@ -1284,38 +1199,9 @@ function fetch_release_times(versions_endpoint, package_name) {
 }
 
 // scripts/version/version-targets.ts
-import path5 from "node:path";
-
-// scripts/lib/read-file.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-var ABSENT_CODE = "ENOENT";
-function is_absent(error) {
-  return error instanceof Error && "code" in error && error.code === ABSENT_CODE;
-}
-function read_optional(path6) {
-  try {
-    return readFileSync4(path6, "utf8");
-  } catch (error) {
-    if (is_absent(error)) return void 0;
-    throw error;
-  }
-}
-function read_file_or_empty(path6) {
-  return read_optional(path6) ?? "";
-}
-function read_if_readable(path6) {
-  try {
-    return readFileSync4(path6, "utf8");
-  } catch {
-    return void 0;
-  }
-}
-var file_reader = { read_optional, read_file_or_empty, read_if_readable };
-
-// scripts/version/version-targets.ts
+import path6 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];
 }
@@ -1324,44 +1210,27 @@ function parse_global_version(stdout, package_name) {
   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(json_value.parse_or_undefined(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 path5.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 = file_reader.read_optional(package_path);
-  return parse_project_version(raw);
+  const package_directory = path6.join(cwd, NODE_MODULES2, package_name);
+  return package_manifest.read_manifest_if_valid(package_directory, package_version_schema)?.version;
 }
 function read_workspace_version(cwd) {
-  const package_path = path5.join(cwd, PACKAGE_JSON3);
-  const raw = file_reader.read_optional(package_path);
-  return parse_project_version(raw);
+  return package_manifest.read_manifest_if_valid(cwd, package_version_schema)?.version;
 }
 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: the module that already owns "where the project's manifest is"
-  // is where the name belongs.
-  PACKAGE_JSON: PACKAGE_JSON3
+  read_workspace_version
 };
 
 // scripts/version/version-commands.ts
-var FAILURE_EXIT_CODE = 1;
+var FAILURE_EXIT_CODE2 = 1;
 var ALREADY_UP_TO_DATE = "Already up to date";
 var NO_QUARANTINE_MINUTES2 = 0;
 function read_release_hold(package_config, latest, versions) {
@@ -1455,7 +1324,7 @@ function run_upgrade_step(step) {
     reject: false,
     timeout: INSTALL_TIMEOUT_MS
   });
-  return result.exitCode ?? FAILURE_EXIT_CODE;
+  return result.exitCode ?? FAILURE_EXIT_CODE2;
 }
 function run_upgrade_command(command) {
   for (const step of command.steps) {