@joshuafolkken/kit 1.1010.0 → 1.1050.0

package/dist/version/index.js

@@ -557,6 +557,12 @@ var agent_session_environment = {
   removed_proxy_environment
 };
 
+// scripts/lib/error-message.ts
+function message_of(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var error_text = { message_of };
+
 // scripts/git/git-gh-exec.ts
 import { execa as execa2, execaSync } from "execa";
 
@@ -664,8 +670,12 @@ 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() };
+function to_spawn_options(timeout_ms, cwd) {
+  return {
+    ...to_timeout_option(timeout_ms),
+    ...direct_environment(),
+    ...cwd !== void 0 && { cwd }
+  };
 }
 var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
 function has_stderr_field(error) {
@@ -677,13 +687,10 @@ function has_stdout_field(error) {
 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 summary = stderr.length > 0 ? stderr : error_text.message_of(error);
   const detail = stdout.length > 0 ? `${summary}
 ${stdout}` : summary;
   return gh_failure.attach(
@@ -691,10 +698,11 @@ ${stdout}` : summary;
     gh_failure.classify_stdout(stdout)
   );
 }
-async function exec_gh_command(arguments_, timeout_ms) {
+async function exec_gh_command(arguments_, timeout_ms, cwd) {
   await check_gh_installed();
+  const options = to_spawn_options(timeout_ms, cwd);
   try {
-    const { stdout } = await execa2("gh", arguments_, to_spawn_options(timeout_ms));
+    const { stdout } = await execa2("gh", arguments_, options);
     return stdout.trimEnd();
   } catch (error) {
     throw to_gh_error(error);
@@ -702,7 +710,7 @@ async function exec_gh_command(arguments_, timeout_ms) {
 }
 async function exec_gh_command_with_stdin(input) {
   await check_gh_installed();
-  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms) };
+  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
   try {
     const { stdout } = await execa2("gh", input.args, options);
     return stdout.trimEnd();
@@ -715,6 +723,9 @@ function parse_status_line(output) {
   const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
   return status === void 0 ? void 0 : Number(status);
 }
+function status_of_failure(error) {
+  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+}
 async function exec_gh_api_status(path5, timeout_ms) {
   const options = to_spawn_options(timeout_ms);
   try {
@@ -722,7 +733,16 @@ async function exec_gh_api_status(path5, timeout_ms) {
     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;
+    return status_of_failure(error);
+  }
+}
+function exec_gh_api_status_sync(path5, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path5], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return status_of_failure(error);
   }
 }
 var METHOD_FLAG = "--method";
@@ -749,16 +769,19 @@ function to_gh_api_args(request) {
 }
 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);
+  if (request.body === void 0) {
+    return await exec_gh_command(args, request.timeout_ms, request.cwd);
+  }
   return await exec_gh_command_with_stdin({
     args,
     stdin_body: request.body,
-    timeout_ms: request.timeout_ms
+    timeout_ms: request.timeout_ms,
+    cwd: request.cwd
   });
 }
 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) };
+  const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
   try {
     const { stdout } = execaSync("gh", to_gh_api_args(request), options);
     return stdout.trimEnd();
@@ -766,19 +789,393 @@ function exec_gh_api_sync(request) {
     throw to_gh_error(error);
   }
 }
+function read_gh_api_sync(request) {
+  try {
+    return exec_gh_api_sync(request);
+  } catch {
+    return void 0;
+  }
+}
 var git_gh_exec = {
   direct_environment,
   exec_gh_command,
   exec_gh_command_with_stdin,
   exec_gh_api,
   exec_gh_api_sync,
+  read_gh_api_sync,
   exec_gh_api_status,
+  exec_gh_api_status_sync,
   parse_status_line
 };
 
-// scripts/version/version-remote.ts
+// scripts/gh/fix-gh-packages-logic.ts
+import { loadAll } 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 loadAll(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 clean_kit_line(line, version, integrities) {
+  if (!version) return line;
+  if (is_github_tarball_line(line)) return void 0;
+  const cleaned = remove_flow_tarball(line);
+  const pair = integrities.get(version);
+  if (pair === void 0) return cleaned;
+  return cleaned.split(`integrity: ${pair[0]}`).join(`integrity: ${pair[1]}`);
+}
+function next_kit_version(line, version) {
+  if (!is_package_entry(line)) return version;
+  const prefix = "  '@joshuafolkken/kit@";
+  return line.startsWith(prefix) ? line.slice(prefix.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 kit_entries = Object.entries(packages).filter(([key]) => key.startsWith(`${SCOPE}/kit@`));
+  for (const [key, entry] of kit_entries) {
+    const version = fix_gh_packages_logic.package_version_from_key(key);
+    const pair = integrity_pair(entry.resolution?.integrity, npm_integrities.get(version));
+    if (pair !== void 0) pairs.set(version, pair);
+  }
+  return pairs;
+}
+function push_if_defined(lines, cleaned) {
+  if (cleaned !== void 0) lines.push(cleaned);
+}
+function rewrite_kit_lockfile(lockfile, npm_integrities) {
+  let kit_version = "";
+  const lines = [];
+  const integrities = lock_integrities(lockfile, npm_integrities);
+  for (const line of lockfile.split("\n")) {
+    kit_version = next_kit_version(line, kit_version);
+    const cleaned = clean_kit_line(line, kit_version, 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 = packages.filter((name) => name !== `${SCOPE}/kit`);
+  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_kit_lockfile,
+  registry_of,
+  scoped_packages,
+  scoped_versions
+};
+
+// scripts/version/npm-registry.ts
 import { execaSync as execaSync2 } from "execa";
-var GH_FAILURE_FALLBACK = "gh api failed";
+import { z as z5 } from "zod";
+var PUBLIC_REGISTRY2 = "https://registry.npmjs.org";
+var ABBREVIATED_ACCEPT = "application/vnd.npm.install-v1+json";
+var FULL_ACCEPT = "application/json";
+var REQUEST_TIMEOUT_MS = 1e4;
+var SCOPE_SEPARATOR = "/";
+var ENCODED_SCOPE_SEPARATOR = "%2f";
+var SCOPE_PATTERN = /^@[^/]+(?=\/)/u;
+var SCOPE_REGISTRY_SUFFIX = ":registry";
+var github_scopes = /* @__PURE__ */ new Map();
+var FETCH_SCRIPT = [
+  "const [url, accept] = process.argv.slice(1)",
+  "const response = await fetch(url, { headers: { accept } })",
+  "if (!response.ok) process.exit(1)",
+  "process.stdout.write(await response.text())"
+].join("\n");
+var latest_schema = z5.looseObject({ "dist-tags": z5.looseObject({ latest: z5.string() }) });
+var times_schema = z5.looseObject({ time: release_age.release_times_schema });
+function packument_url(package_name) {
+  return `${PUBLIC_REGISTRY2}/${package_name.replace(SCOPE_SEPARATOR, () => ENCODED_SCOPE_SEPARATOR)}`;
+}
+function read_packument(package_name, accept) {
+  const result = execaSync2(
+    process.execPath,
+    ["--input-type=module", "-e", FETCH_SCRIPT, packument_url(package_name), accept],
+    { reject: false, timeout: REQUEST_TIMEOUT_MS }
+  );
+  if (result.exitCode !== 0) return void 0;
+  return safe_json_parse(result.stdout);
+}
+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}`], {
+    reject: false,
+    timeout: REQUEST_TIMEOUT_MS
+  });
+  const is_github = result.exitCode === 0 && migrate_logic.is_github_tarball(result.stdout.trim());
+  github_scopes.set(scope, is_github);
+  return is_github;
+}
+function is_public_source(package_name) {
+  const scope = SCOPE_PATTERN.exec(package_name)?.[0];
+  return scope === void 0 || !is_github_scope(scope);
+}
+function read_latest(package_name) {
+  if (!is_public_source(package_name)) return void 0;
+  const parsed = latest_schema.safeParse(read_packument(package_name, ABBREVIATED_ACCEPT));
+  return parsed.success ? parsed.data["dist-tags"].latest : void 0;
+}
+function read_release_times(package_name) {
+  if (!is_public_source(package_name)) return void 0;
+  const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT));
+  return parsed.success ? parsed.data.time : void 0;
+}
+var npm_registry = { packument_url, read_latest, read_release_times };
+
+// scripts/version/version-remote.ts
 var TIMES_PAGE_SIZE = 100;
 var TIMES_JQ = "[.[] | {(.name): .created_at}] | add";
 function require_endpoint(versions_endpoint, package_name) {
@@ -787,21 +1184,21 @@ function require_endpoint(versions_endpoint, package_name) {
     `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)}`
-  );
+  const public_latest = npm_registry.read_latest(package_name);
+  if (public_latest !== void 0) return public_latest;
+  try {
+    return git_gh_exec.exec_gh_api_sync({ path: endpoint, jq_filter: ".[0].name" }).trim();
+  } catch (error) {
+    const detail = error_text.message_of(error);
+    throw new Error(
+      `Failed to fetch latest version for ${package_name} via ${endpoint}: ${detail}`,
+      {
+        cause: error
+      }
+    );
+  }
 }
 function with_page_size(endpoint, page_size) {
   const separator = endpoint.indexOf("?");
@@ -810,21 +1207,48 @@ function with_page_size(endpoint, page_size) {
   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;
+function read_github_release_times(versions_endpoint) {
   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));
+  const stdout = git_gh_exec.read_gh_api_sync({ path: endpoint, jq_filter: TIMES_JQ });
+  if (stdout === void 0) return void 0;
+  const parsed = release_age.release_times_schema.safeParse(safe_json_parse(stdout));
   return parsed.success ? parsed.data : void 0;
 }
+function fetch_release_times(versions_endpoint, package_name) {
+  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
+  return npm_registry.read_release_times(package_name) ?? read_github_release_times(versions_endpoint);
+}
 
 // scripts/version/version-targets.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 import path4 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(path5) {
+  try {
+    return readFileSync4(path5, "utf8");
+  } catch (error) {
+    if (is_absent(error)) return void 0;
+    throw error;
+  }
+}
+function read_file_or_empty(path5) {
+  return read_optional(path5) ?? "";
+}
+function read_if_readable(path5) {
+  try {
+    return readFileSync4(path5, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var file_reader = { read_optional, read_file_or_empty, read_if_readable };
+
+// scripts/version/version-targets.ts
 import { execaSync as execaSync3 } from "execa";
 var NODE_MODULES2 = "node_modules";
 var PACKAGE_JSON3 = "package.json";
@@ -850,12 +1274,12 @@ function project_package_path(cwd, package_name) {
 }
 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;
+  const raw = file_reader.read_optional(package_path);
   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;
+  const raw = file_reader.read_optional(package_path);
   return parse_project_version(raw);
 }
 var version_targets = {
@@ -876,12 +1300,12 @@ var version_targets = {
 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) {
+function read_release_hold(package_config, 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),
+    fetch_release_times(package_config.versions_endpoint, package_config.package_name),
     latest,
     minimum_age_minutes,
     Date.now()
@@ -938,7 +1362,7 @@ function read_upstream_report(upstream, config, snapshot, is_hold_wanted) {
   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;
+  const hold = is_hold_wanted ? read_release_hold(upstream, latest, [report.effective?.version]) : void 0;
   if (hold !== void 0) report.hold = hold;
   return report;
 }

package/eslint/base.js

@@ -29,13 +29,10 @@ import {
 import { typescript_rules } from './rules/typescript.js'
 import { unicorn_rules } from './rules/unicorn.js'
 
-const SCRIPTS_AI_PATTERNS = ['scripts-ai/**/*.ts', 'scripts-ai/**/*.js']
-
 const FILE_PATTERNS = {
 	d_ts: ['**/*.d.ts'],
 	typescript: ['**/*.ts', '**/*.tsx'],
-	scripts_ai: SCRIPTS_AI_PATTERNS,
-	scripts: ['scripts/**/*.ts', 'scripts/**/*.js', ...SCRIPTS_AI_PATTERNS],
+	scripts: ['scripts/**/*.ts', 'scripts/**/*.js'],
 	// joshuafolkken/kit#1414: `**/*.spec.ts` is deliberately absent. The same config bans that name
 	// outright, so handing it the test relaxation (`max-lines-per-function` 35 and the rest) is the
 	// config contradicting itself, and it is what makes `*.spec.ts` read as supported. A banned file
@@ -160,7 +157,7 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			files: FILE_PATTERNS.scripts,
 			rules: {
 				'unicorn/no-process-exit': 'off',
-				// scripts under scripts/ and scripts-ai/ are dual-purpose: shebang-executable
+				// scripts under scripts/ are dual-purpose: shebang-executable
 				// (run via tsx) AND importable namespace modules (consumed via #scripts/* and
 				// in tests). unicorn/no-exports-in-scripts flags exports in any shebang file,
 				// which conflicts with the kit export { module } convention, so disable it here.
@@ -173,12 +170,6 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 				'@typescript-eslint/unbound-method': 'off',
 			},
 		},
-		{
-			files: FILE_PATTERNS.scripts_ai,
-			rules: {
-				'@typescript-eslint/no-restricted-imports': 'off',
-			},
-		},
 		{
 			files: FILE_PATTERNS.tests,
 			rules: {