@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-NOSODWWK.js

@@ -0,0 +1,1132 @@
+import {
+  yaml_document
+} from "./chunk-UCI4AL3Q.js";
+import {
+  json_object_schema,
+  string_array_schema,
+  string_record_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/config-merge/json-format.ts
+var PRINT_WIDTH = 100;
+var TAB_WIDTH = 2;
+var ARRAY_CLOSE = /^\t*\],?$/u;
+function is_array_open(line) {
+  return line.endsWith("[");
+}
+function is_leaf_element(line) {
+  return !line.endsWith("{") && !line.endsWith("[");
+}
+function line_width(line) {
+  const tabs = line.length - line.trimStart().length;
+  return tabs * TAB_WIDTH + (line.length - tabs);
+}
+function flatten_elements(elements) {
+  const scalars = elements.map((line) => line.trim().replace(/,$/u, ""));
+  return `[${scalars.join(", ")}]`;
+}
+function collect_block(lines, start) {
+  const close = lines.findIndex((line, index) => index > start && ARRAY_CLOSE.test(line));
+  if (close === -1) return void 0;
+  const elements = lines.slice(start + 1, close);
+  if (elements.some((line) => !is_leaf_element(line))) return void 0;
+  return { elements, close: lines[close] ?? "", end: close };
+}
+function try_inline(open, block) {
+  const trailing_comma = block.close.trimStart() === "]," ? "," : "";
+  const inlined = `${open.slice(0, -1)}${flatten_elements(block.elements)}${trailing_comma}`;
+  return line_width(inlined) <= PRINT_WIDTH ? inlined : void 0;
+}
+function rewrite_at(lines, index, line) {
+  const verbatim = { lines: [line], next: index + 1 };
+  const block = is_array_open(line) ? collect_block(lines, index) : void 0;
+  if (block === void 0) return verbatim;
+  const inlined = try_inline(line, block);
+  if (inlined === void 0) return verbatim;
+  return { lines: [inlined], next: block.end + 1 };
+}
+function inline_short_arrays(text) {
+  const lines = text.split("\n");
+  const output = [];
+  let index = 0;
+  while (index < lines.length) {
+    const rewrite = rewrite_at(lines, index, lines[index] ?? "");
+    output.push(...rewrite.lines);
+    index = rewrite.next;
+  }
+  return output.join("\n");
+}
+function format_json(value) {
+  return `${inline_short_arrays(JSON.stringify(value, void 0, "	"))}
+`;
+}
+function format_package_json(value) {
+  return `${JSON.stringify(value, void 0, "	")}
+`;
+}
+var json_format = {
+  format_json,
+  format_package_json
+};
+
+// scripts/registry-migration/migrate-lock.ts
+import path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+
+// scripts/gh/fix-gh-packages-logic.ts
+import { loadAll } from "js-yaml";
+import { z } 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 = z.looseObject({
+  integrity: z.string().optional(),
+  tarball: z.string().optional()
+});
+var lockfile_package_schema = z.looseObject({
+  resolution: lockfile_resolution_schema.optional()
+});
+var lockfile_document_schema = z.looseObject({
+  packages: z.record(z.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 registry_entry(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("@")) return void 0;
+  const eq_index = trimmed.indexOf("=");
+  const key = trimmed.slice(0, eq_index).trim();
+  if (eq_index === -1 || !key.endsWith(REGISTRY_KEY)) return void 0;
+  return [key.slice(0, -REGISTRY_KEY.length), trimmed.slice(eq_index + 1).trim()];
+}
+function parse_scope_registries(npmrc2) {
+  const registries = /* @__PURE__ */ new Map();
+  for (const line of npmrc2.split("\n")) {
+    const entry = registry_entry(line);
+    if (entry !== void 0) registries.set(...entry);
+  }
+  return registries;
+}
+function parse_gh_scopes(npmrc2) {
+  const entries = [...parse_scope_registries(npmrc2)];
+  return new Set(
+    entries.filter(([, registry]) => registry.replace(/\/$/u, "") === `https://${GH_PACKAGES_HOST}`).map(([scope]) => scope)
+  );
+}
+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(npmrc2) {
+  for (const line of npmrc2.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_end2 = entry_content.indexOf("\n", pos + 1);
+  const search_end = line_end2 === -1 ? entry_content.length : line_end2;
+  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_scope_registries,
+  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-lock.ts
+import { dump } from "js-yaml";
+var SCOPE = "@joshuafolkken/";
+var KIT = `${SCOPE}kit`;
+var REGISTRY = "https://registry.npmjs.org/";
+var PNPM_VERSION = "12.17.0";
+function scoped_artifacts(content) {
+  return Object.entries(fix_gh_packages_logic.parse_lockfile_packages(content)).filter(([key]) => key.startsWith(SCOPE)).map(([key, entry]) => ({
+    name: fix_gh_packages_logic.package_path_from_key(key),
+    version: fix_gh_packages_logic.package_version_from_key(key),
+    integrity: entry.resolution?.integrity
+  }));
+}
+function importer_manifests(content) {
+  return yaml_document.parse_yaml_documents(content).flatMap(
+    (document) => yaml_document.is_mapping_document(document["importers"]) ? Object.keys(document["importers"]) : []
+  ).map((importer) => path.join(importer, "package.json"));
+}
+function non_npm_resolution(content) {
+  const entries = Object.entries(fix_gh_packages_logic.parse_lockfile_packages(content)).filter(
+    ([key]) => key.startsWith(SCOPE)
+  );
+  for (const [key, entry] of entries) {
+    const tarball = entry.resolution?.tarball;
+    if (tarball !== void 0 && !tarball.startsWith(REGISTRY)) return key;
+  }
+  return void 0;
+}
+function has_npm_sources(content) {
+  return non_npm_resolution(content) === void 0;
+}
+function assert_npm_sources(content) {
+  const key = non_npm_resolution(content);
+  if (key !== void 0) throw new Error(`Non-npm resolution remains: ${key}`);
+}
+function npmrc(content) {
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const lines = content.split(/\r?\n/u).filter((line) => !/^\s*@joshuafolkken:registry\s*=/u.test(line));
+  while (lines.at(-1) === "") lines.pop();
+  lines.push(`@joshuafolkken:registry=${REGISTRY}`, "");
+  return lines.join(newline);
+}
+function strip_tarball(resolution) {
+  if (yaml_document.is_mapping_document(resolution)) delete resolution["tarball"];
+}
+function strip_resolutions(document) {
+  if (!yaml_document.is_mapping_document(document["packages"])) return;
+  const scoped = Object.entries(document["packages"]).filter(([key]) => key.startsWith(SCOPE));
+  for (const [, entry] of scoped) {
+    if (yaml_document.is_mapping_document(entry)) strip_tarball(entry["resolution"]);
+  }
+}
+function graph(content) {
+  const documents = yaml_document.parse_yaml_documents(content);
+  for (const document of documents) strip_resolutions(document);
+  return documents;
+}
+function assert_preserved(before, after) {
+  if (before === "") return;
+  if (!isDeepStrictEqual(graph(before), graph(after))) {
+    throw new Error(
+      "Resolution changed the dependency graph or unrelated metadata; no files changed"
+    );
+  }
+}
+function restore_checksum(original, resolved) {
+  const checksum = original["pnpmfileChecksum"];
+  if (checksum === void 0 || resolved["pnpmfileChecksum"] !== void 0) return false;
+  resolved["pnpmfileChecksum"] = checksum;
+  return true;
+}
+function restore_pnpmfile_checksum(before, after) {
+  const originals = yaml_document.parse_yaml_documents(before);
+  const resolved = yaml_document.parse_yaml_documents(after);
+  const restored = resolved.map(
+    (document, index) => restore_checksum(originals[index] ?? {}, document)
+  );
+  const prefix = after.startsWith("---") ? "---\n" : "";
+  return restored.includes(true) ? prefix + resolved.map((document) => dump(document)).join("---\n") : after;
+}
+var migrate_lock = {
+  SCOPE,
+  KIT,
+  REGISTRY,
+  PNPM_VERSION,
+  scoped_artifacts,
+  npmrc,
+  assert_preserved,
+  restore_pnpmfile_checksum,
+  assert_npm_sources,
+  has_npm_sources,
+  importer_manifests
+};
+
+// scripts/registry-migration/npm-acquisition.ts
+import path3 from "node:path";
+
+// scripts/config-merge/parse-jsonc.ts
+import { parseTree, printParseErrorCode } from "jsonc-parser";
+function property_key(property) {
+  return String(property.children?.[0]?.value);
+}
+function node_value(node) {
+  if (node === void 0) return void 0;
+  const children = node.children ?? [];
+  if (node.type === "array") return children.map((child) => node_value(child));
+  if (node.type !== "object") return node.value;
+  return Object.fromEntries(
+    children.map((property) => [property_key(property), node_value(property.children?.[1])])
+  );
+}
+function parse_jsonc(content) {
+  const errors = [];
+  const tree = parseTree(content, errors, { allowTrailingComma: true });
+  const [first_error] = errors;
+  if (first_error !== void 0) {
+    throw new SyntaxError(
+      `Invalid JSONC: ${printParseErrorCode(first_error.error)} at offset ${String(first_error.offset)}`
+    );
+  }
+  return json_object_schema.parse(node_value(tree));
+}
+
+// scripts/config-merge/list-patch.ts
+function is_matching(entry, matchers) {
+  return matchers.some(
+    (matcher) => typeof matcher === "string" ? matcher === entry : matcher.test(entry)
+  );
+}
+function apply_remove(existing, remove) {
+  if (remove === void 0 || remove.length === 0) return existing;
+  return existing.filter((entry) => !is_matching(entry, remove));
+}
+function collect_additions(kept, ensure) {
+  if (ensure === void 0) return [];
+  return ensure.filter((entry) => !kept.includes(entry));
+}
+function apply_list_patch(existing, patch) {
+  const kept = apply_remove(existing, patch.remove);
+  const additions = collect_additions(kept, patch.ensure);
+  const is_changed = additions.length > 0 || kept.length !== existing.length;
+  return { next: [...additions, ...kept], is_changed };
+}
+var list_patch = {
+  is_matching,
+  apply_list_patch
+};
+
+// scripts/config-merge/patch-json-key.ts
+import {
+  createScanner,
+  findNodeAtLocation,
+  getNodeValue,
+  parseTree as parseTree2,
+  stripComments
+} from "jsonc-parser";
+var DOCUMENT_SUFFIX = "\n}\n";
+var DEFAULT_INDENT = "	";
+var LEADING_BLANKS = /^[\t ]*/u;
+var PREVIOUS_LINE_OFFSET = 2;
+var CRLF = "\r\n";
+var COMMA_PROBE_VALUE = 0;
+function render_value(key, value, has_trailing_comma) {
+  const probe_key = `${key} `;
+  const probe = has_trailing_comma ? { [key]: value, [probe_key]: COMMA_PROBE_VALUE } : { [key]: value };
+  const document = json_format.format_json(probe);
+  const prefix = `{
+	${JSON.stringify(key)}: `;
+  const suffix = has_trailing_comma ? `,
+	${JSON.stringify(probe_key)}: ${String(COMMA_PROBE_VALUE)}${DOCUMENT_SUFFIX}` : DOCUMENT_SUFFIX;
+  return document.slice(prefix.length, document.length - suffix.length);
+}
+function parse_root(content) {
+  const root = parseTree2(content);
+  return root?.type === "object" ? root : void 0;
+}
+function replace_range(content, range, text) {
+  return content.slice(0, range.offset) + text + content.slice(range.offset + range.length);
+}
+function insert_at(content, offset, text) {
+  return replace_range(content, { offset, length: 0 }, text);
+}
+function render_indent(value_text, unit) {
+  if (unit === DEFAULT_INDENT || unit.length === 0) return value_text;
+  return value_text.replaceAll(/^\t+/gmu, (tabs) => unit.repeat(tabs.length));
+}
+function eol_of(content) {
+  return content.includes(CRLF) ? CRLF : "\n";
+}
+function fit_value(content, value_text, indent) {
+  const indented = render_indent(value_text, indent);
+  if (eol_of(content) === "\n") return indented;
+  return indented.split("\n").join(CRLF);
+}
+function line_indent(content, offset) {
+  const line_start = content.lastIndexOf("\n", offset - 1) + 1;
+  return LEADING_BLANKS.exec(content.slice(line_start, offset))?.[0] ?? "";
+}
+function line_end(content, offset) {
+  const index = content.indexOf("\n", offset);
+  if (index === -1) return content.length;
+  return index > offset && content[index - 1] === "\r" ? index - 1 : index;
+}
+function render_property(content, key, value_text, indent) {
+  return `${JSON.stringify(key)}: ${fit_value(content, value_text, indent)}`;
+}
+function insertion_offset(content, root, value_end) {
+  return Math.min(line_end(content, value_end), root.offset + root.length - 1);
+}
+function separator_offset(content, offset, limit) {
+  const scanner = createScanner(content, true);
+  scanner.setPosition(offset);
+  scanner.scan();
+  const at = scanner.getTokenOffset();
+  return at < limit && content[at] === "," ? at : -1;
+}
+function has_separator_after(content, offset, limit) {
+  return separator_offset(content, offset, limit) !== -1;
+}
+function property_key2(property) {
+  const key = property.children?.[0]?.value;
+  return typeof key === "string" ? key : void 0;
+}
+function target_value_end(property) {
+  const value_node = property?.children?.[1];
+  return value_node === void 0 ? void 0 : value_node.offset + value_node.length;
+}
+function contains_comment(content, node) {
+  const text = content.slice(node.offset, node.offset + node.length);
+  return stripComments(text) !== text;
+}
+function rebalanced_value(content, key, value_node, has_trailing_comma) {
+  if (contains_comment(content, value_node)) return void 0;
+  const indent = line_indent(content, value_node.offset);
+  const rendered = fit_value(
+    content,
+    render_value(key, getNodeValue(value_node), has_trailing_comma),
+    indent
+  );
+  const current = content.slice(value_node.offset, value_node.offset + value_node.length);
+  return rendered === current ? void 0 : rendered;
+}
+function rebalance(content, property, has_trailing_comma) {
+  const key = property_key2(property);
+  const value_node = property.children?.[1];
+  if (key === void 0 || value_node === void 0) return content;
+  const rendered = rebalanced_value(content, key, value_node, has_trailing_comma);
+  return rendered === void 0 ? content : replace_range(content, value_node, rendered);
+}
+function append_after(content, root, last, property) {
+  const value_end = last.offset + last.length;
+  const closing_brace = root.offset + root.length - 1;
+  const separator = has_separator_after(content, value_end, closing_brace) ? "" : ",";
+  const with_property = insert_at(content, insertion_offset(content, root, value_end), property);
+  return insert_at(with_property, value_end, separator);
+}
+function insert_only_property(content, root, property) {
+  const closing_brace = root.offset + root.length - 1;
+  const lead = content[closing_brace - 1] === "\n" ? "" : eol_of(content);
+  return insert_at(content, closing_brace, `${lead}${DEFAULT_INDENT}${property}${eol_of(content)}`);
+}
+function insert_property(content, root, key, value_text) {
+  const last = root.children?.at(-1);
+  if (last === void 0) {
+    const only = render_property(content, key, value_text, DEFAULT_INDENT);
+    return insert_only_property(content, root, only);
+  }
+  const indent = line_indent(content, last.offset);
+  const property = `${eol_of(content)}${indent}${render_property(content, key, value_text, indent)}`;
+  return rebalance(append_after(content, root, last, property), last, true);
+}
+function end_of_trailing_comment(content, end) {
+  const stop = line_end(content, end);
+  return content.slice(end, stop).trimStart().startsWith("//") ? stop : end;
+}
+function start_of_leading_comments(content, line_start, floor) {
+  let start = line_start;
+  while (start > floor) {
+    const previous = content.lastIndexOf("\n", start - PREVIOUS_LINE_OFFSET) + 1;
+    const is_comment_line = content.slice(previous, start).trimStart().startsWith("//");
+    if (!is_comment_line || previous < floor) return start;
+    start = previous;
+  }
+  return start;
+}
+function end_of_line_break(content, offset) {
+  if (content[offset] === "\r" && content[offset + 1] === "\n") return offset + PREVIOUS_LINE_OFFSET;
+  return content[offset] === "\n" ? offset + 1 : offset;
+}
+function body_range(content, root, target, separator_limit) {
+  const value_end = target.offset + target.length;
+  const comma = separator_limit === -1 ? -1 : separator_offset(content, value_end, separator_limit);
+  const end = end_of_trailing_comment(content, comma === -1 ? value_end : comma + 1);
+  const line_start = content.lastIndexOf("\n", target.offset - 1) + 1;
+  const is_own_line = content.slice(line_start, target.offset).trim().length === 0;
+  if (!is_own_line) return { offset: target.offset, length: end - target.offset };
+  const start = start_of_leading_comments(content, line_start, root.offset + 1);
+  return { offset: start, length: end_of_line_break(content, end) - start };
+}
+function ranges_for_last_property(content, root, previous, target) {
+  const comma = separator_offset(content, previous.offset + previous.length, target.offset);
+  const body = body_range(content, root, target, -1);
+  return comma === -1 ? [body] : [{ offset: comma, length: 1 }, body];
+}
+function removal_ranges(content, root, index) {
+  const children = root.children ?? [];
+  const target = children[index];
+  if (target === void 0) return [];
+  const next = children[index + 1];
+  if (next !== void 0) return [body_range(content, root, target, next.offset)];
+  const previous = children[index - 1];
+  if (previous === void 0) return [{ offset: root.offset, length: root.length }];
+  return ranges_for_last_property(content, root, previous, target);
+}
+function property_index(root, key) {
+  return (root.children ?? []).findIndex((child) => child.children?.[0]?.value === key);
+}
+function with_trailing_newline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function is_followed_by_comma(content, root, key) {
+  const children = root.children ?? [];
+  const index = property_index(root, key);
+  if (index < 0) return false;
+  if (index < children.length - 1) return true;
+  const value_end = target_value_end(children[index]);
+  return value_end !== void 0 && has_separator_after(content, value_end, root.offset + root.length);
+}
+function set_json_key(content, key, value) {
+  const root = parse_root(content);
+  if (root === void 0) return content;
+  const existing = findNodeAtLocation(root, [key]);
+  const value_text = render_value(
+    key,
+    value,
+    existing !== void 0 && is_followed_by_comma(content, root, key)
+  );
+  if (existing === void 0) {
+    return with_trailing_newline(insert_property(content, root, key, value_text));
+  }
+  const indented = fit_value(content, value_text, line_indent(content, existing.offset));
+  return with_trailing_newline(replace_range(content, existing, indented));
+}
+function resolve_parent(content, path4) {
+  const root = parse_root(content);
+  if (root === void 0) return void 0;
+  const parent = path4.length > 1 ? findNodeAtLocation(root, path4.slice(0, -1)) : root;
+  return parent?.type === "object" ? parent : void 0;
+}
+function cut_ranges(content, parent, ranges) {
+  const ordered = ranges.toSorted((left, right) => right.offset - left.offset);
+  let next = content;
+  for (const range of ordered) {
+    next = replace_range(next, range, range.offset === parent.offset ? "{}" : "");
+  }
+  return next;
+}
+function rebalance_new_last(content, path4) {
+  const parent = resolve_parent(content, path4);
+  const last = parent?.children?.at(-1);
+  if (parent === void 0 || last === void 0) return content;
+  return rebalance(content, last, has_separator_after(content, parent.offset, parent.offset));
+}
+function cut_property(content, parent, path4) {
+  const index = property_index(parent, path4.at(-1) ?? "");
+  const ranges = removal_ranges(content, parent, index);
+  if (ranges.length === 0) return content;
+  const cut = cut_ranges(content, parent, ranges);
+  const did_end_object = index === (parent.children ?? []).length - 1;
+  return did_end_object ? rebalance_new_last(cut, path4) : cut;
+}
+function remove_json_path(content, path4) {
+  const parent = resolve_parent(content, path4);
+  if (parent === void 0) return content;
+  const next = cut_property(content, parent, path4);
+  return next === content ? content : with_trailing_newline(next);
+}
+function remove_json_key(content, key) {
+  return remove_json_path(content, [key]);
+}
+var patch_json_key = {
+  set_json_key,
+  remove_json_key,
+  remove_json_path,
+  eol_of,
+  fit_value,
+  line_indent
+};
+
+// scripts/config-merge/patch-json-list.ts
+function normalize_list(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.map(String);
+  return [];
+}
+function patch_json_list_field(content, options) {
+  const parsed = parse_jsonc(content);
+  const existing = normalize_list(parsed[options.field]);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  return patch_json_key.set_json_key(content, options.field, [...next]);
+}
+var json_list = {
+  patch_json_list_field
+};
+
+// scripts/config-merge/patch-yaml-list.ts
+import { dump as dump2 } from "js-yaml";
+var { parse_yaml } = yaml_document;
+function read_yaml_list_field(content, field) {
+  const raw = parse_yaml(content)[field];
+  if (typeof raw === "string") return [raw];
+  return Array.isArray(raw) ? string_array_schema.parse(raw) : [];
+}
+function replace_field(parsed, field, value) {
+  return Object.fromEntries(
+    Object.entries(parsed).map(([key, entry]) => [key, key === field ? [...value] : entry])
+  );
+}
+function insert_after(parsed, field, value, anchor) {
+  const entries = Object.entries(parsed);
+  const index = entries.findIndex(([key]) => key === anchor);
+  if (index === -1) return { ...parsed, [field]: [...value] };
+  return Object.fromEntries([
+    ...entries.slice(0, index + 1),
+    [field, [...value]],
+    ...entries.slice(index + 1)
+  ]);
+}
+function insert_new_field(parsed, field, value, position) {
+  if (position === "front") return { [field]: [...value], ...parsed };
+  if (position === "end") return { ...parsed, [field]: [...value] };
+  return insert_after(parsed, field, value, position.after);
+}
+function place_field(parsed, field, value, position) {
+  if (Object.hasOwn(parsed, field)) return replace_field(parsed, field, value);
+  return insert_new_field(parsed, field, value, position);
+}
+function patch_yaml_list_field(content, options) {
+  const parsed = parse_yaml(content);
+  const existing = read_yaml_list_field(content, options.field);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  const placed = place_field(parsed, options.field, next, options.position ?? "front");
+  return dump2(placed, options.quote_style === void 0 ? {} : { quoteStyle: options.quote_style });
+}
+var yaml_list = {
+  patch_yaml_list_field,
+  read_yaml_list_field
+};
+
+// scripts/config-merge/index.ts
+var config_merge = {
+  patch_yaml_list_field: yaml_list.patch_yaml_list_field,
+  read_yaml_list_field: yaml_list.read_yaml_list_field,
+  patch_json_list_field: json_list.patch_json_list_field
+};
+
+// scripts/safe-chain/preinstall-command.ts
+var INSTALL_GUIDE_ANCHOR = "installing-safe-chain";
+var INSTALL_GUIDE_URL = `https://github.com/joshuafolkken/kit/blob/main/SECURITY.md#${INSTALL_GUIDE_ANCHOR}`;
+var INTEGRATION_HINT = `Warning: safe-chain (@aikidosec/safe-chain) is not scanning this install because its shell integration is not active. Install it with the hash-verified steps at ${INSTALL_GUIDE_URL} - then restart your terminal.`;
+var LOCAL_INTEGRATION_CHECK_SOURCE = `if(!process.env.CI&&!process.env.GLOBAL_AGENT_HTTP_PROXY)console.warn('${INTEGRATION_HINT}')`;
+var SAFE_CHAIN_CMD = `node -e "${LOCAL_INTEGRATION_CHECK_SOURCE}"`;
+var LEGACY_PREINSTALL_RE = /^pnpm dlx @aikidosec\/safe-chain(?:@\S+)? setup-ci(?: && node -e "[^"]*")?$/u;
+function migrate_preinstall(value) {
+  return LEGACY_PREINSTALL_RE.test(value) ? SAFE_CHAIN_CMD : value;
+}
+var safe_chain_preinstall = {
+  SAFE_CHAIN_CMD,
+  LOCAL_INTEGRATION_CHECK_SOURCE,
+  INTEGRATION_HINT,
+  INSTALL_GUIDE_ANCHOR,
+  migrate_preinstall
+};
+
+// scripts/init/init-logic-migrate.ts
+function migrate_scripts(scripts) {
+  const current = scripts["preinstall"];
+  if (current === void 0) return scripts;
+  return { ...scripts, preinstall: safe_chain_preinstall.migrate_preinstall(current) };
+}
+var init_logic_migrate = { migrate_scripts };
+
+// scripts/init/init-logic-package-key-order.ts
+var PACKAGE_JSON_KEY_ORDER = [
+  "name",
+  "version",
+  "description",
+  "keywords",
+  "homepage",
+  "bugs",
+  "license",
+  "author",
+  "contributors",
+  "funding",
+  "files",
+  "main",
+  "browser",
+  "exports",
+  "imports",
+  "bin",
+  "man",
+  "directories",
+  "repository",
+  "type",
+  "types",
+  "typings",
+  "typesVersions",
+  "publishConfig",
+  "private",
+  "scripts",
+  "config",
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "peerDependenciesMeta",
+  "bundleDependencies",
+  "bundledDependencies",
+  "optionalDependencies",
+  "overrides",
+  "resolutions",
+  "packageManager",
+  "engines",
+  "devEngines",
+  "os",
+  "cpu",
+  "size-limit",
+  "pnpm"
+];
+
+// scripts/init/kit-base-preset.ts
+var KIT_LEFTHOOK_PRESET = /@joshuafolkken\/[^/]+\/lefthook\//u;
+var KIT_CSPELL_PRESET = /@joshuafolkken\/[^/]+\/cspell(?:\/|$)/u;
+var KIT_TSCONFIG_PRESET = /@joshuafolkken\/[^/]+\/tsconfig\//u;
+var SVELTEKIT_PRESET = /(?<![\w-])sveltekit(?![\w-])/u;
+function has_match(entries, pattern) {
+  return entries.some((entry) => pattern.test(entry));
+}
+function is_base_present(entries, subsystem_pattern) {
+  return has_match(entries, subsystem_pattern) || has_match(entries, SVELTEKIT_PRESET);
+}
+function is_lefthook_base_present(entries) {
+  return is_base_present(entries, KIT_LEFTHOOK_PRESET);
+}
+function is_cspell_base_present(entries) {
+  return is_base_present(entries, KIT_CSPELL_PRESET);
+}
+function is_tsconfig_base_present(entries) {
+  return is_base_present(entries, KIT_TSCONFIG_PRESET);
+}
+var kit_base_preset = {
+  is_lefthook_base_present,
+  is_cspell_base_present,
+  is_tsconfig_base_present
+};
+
+// scripts/init/tsconfig-preset-migration.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+var LEGACY_PRESET_ENTRY = /@joshuafolkken\/[^/]+\/tsconfig\/[^/]+\.jsonc$/u;
+var LEGACY_SUFFIX = ".jsonc";
+var CURRENT_SUFFIX = ".json";
+var EXTENDS_FIELD = "extends";
+function is_migration_target_present(base_directory, entry) {
+  return existsSync(path2.resolve(base_directory, entry));
+}
+function migrate_entry(base_directory, entry) {
+  if (!LEGACY_PRESET_ENTRY.test(entry)) return entry;
+  const migrated = `${entry.slice(0, -LEGACY_SUFFIX.length)}${CURRENT_SUFFIX}`;
+  return is_migration_target_present(base_directory, migrated) ? migrated : entry;
+}
+function migrate_extends_value(base_directory, raw) {
+  if (typeof raw === "string") return migrate_entry(base_directory, raw);
+  if (Array.isArray(raw)) {
+    return string_array_schema.parse(raw).map((entry) => migrate_entry(base_directory, entry));
+  }
+  return raw;
+}
+function migrate_preset_paths(content, base_directory) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed[EXTENDS_FIELD];
+  const migrated = migrate_extends_value(base_directory, raw);
+  if (JSON.stringify(migrated) === JSON.stringify(raw)) return content;
+  return patch_json_key.set_json_key(content, EXTENDS_FIELD, migrated);
+}
+var tsconfig_preset_migration = {
+  migrate_preset_paths
+};
+
+// scripts/init/init-logic-json-merge.ts
+function merge_json_extends(content, entry) {
+  return config_merge.patch_json_list_field(content, { field: EXTENDS_FIELD, ensure: [entry] });
+}
+function read_extends_entries(content) {
+  const raw = parse_jsonc(content)[EXTENDS_FIELD];
+  if (typeof raw === "string") return [raw];
+  if (Array.isArray(raw)) return string_array_schema.parse(raw);
+  return [];
+}
+function merge_tsconfig_extends(content, entry, base_directory) {
+  const migrated = tsconfig_preset_migration.migrate_preset_paths(content, base_directory);
+  if (kit_base_preset.is_tsconfig_base_present(read_extends_entries(migrated))) return migrated;
+  return merge_json_extends(migrated, entry);
+}
+function extract_compiler_options(content) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["compilerOptions"];
+  if (raw === void 0) return {};
+  return json_object_schema.parse(raw);
+}
+function is_redundant_option(value, key, base_options) {
+  if (!Object.hasOwn(base_options, key)) return false;
+  return JSON.stringify(base_options[key]) === JSON.stringify(value);
+}
+var COMPILER_OPTIONS_FIELD = "compilerOptions";
+function drop_redundant_options(content, redundant) {
+  let current = content;
+  for (const key of redundant) {
+    current = patch_json_key.remove_json_path(current, [COMPILER_OPTIONS_FIELD, key]);
+  }
+  return current;
+}
+function serialize_stripped(content, kept, redundant) {
+  if (Object.keys(kept).length === 0) {
+    return patch_json_key.remove_json_key(content, COMPILER_OPTIONS_FIELD);
+  }
+  return drop_redundant_options(content, redundant);
+}
+function redundant_option_keys(current, base_options) {
+  return Object.entries(current).filter(([key, value]) => is_redundant_option(value, key, base_options)).map(([key]) => key);
+}
+function strip_redundant_compiler_options(content, base_options) {
+  const raw = parse_jsonc(content)[COMPILER_OPTIONS_FIELD];
+  if (raw === void 0) return content;
+  const current = json_object_schema.parse(raw);
+  const redundant = redundant_option_keys(current, base_options);
+  if (redundant.length === 0) return content;
+  const kept = Object.entries(current).filter(([key]) => !redundant.includes(key));
+  return serialize_stripped(content, Object.fromEntries(kept), redundant);
+}
+function merge_json_array_field(content, key, values) {
+  const parsed = parse_jsonc(content);
+  const existing = Object.hasOwn(parsed, key) ? string_array_schema.parse(parsed[key]) : [];
+  const to_add = values.filter((value) => !existing.includes(value));
+  if (to_add.length === 0) return content;
+  return patch_json_key.set_json_key(content, key, [...existing, ...to_add]);
+}
+function missing_entries(existing, additions) {
+  return Object.entries(additions).filter(([key]) => !Object.hasOwn(existing, key));
+}
+function merge_owned_entries(current, update) {
+  const current_object = json_object_schema.safeParse(current);
+  const update_object = json_object_schema.safeParse(update);
+  if (!current_object.success || !update_object.success) return void 0;
+  const owned = current_object.data;
+  const missing = missing_entries(owned, update_object.data);
+  if (missing.length === 0) return void 0;
+  return { ...owned, ...Object.fromEntries(missing) };
+}
+function collect_applicable_updates(parsed, updates) {
+  const resolved = Object.entries(updates).map(([key, value]) => [
+    key,
+    Object.hasOwn(parsed, key) ? merge_owned_entries(parsed[key], value) : value
+  ]);
+  return Object.fromEntries(resolved.filter(([, merged]) => merged !== void 0));
+}
+function merge_json_object(content, updates) {
+  const parsed = parse_jsonc(content);
+  const applicable = collect_applicable_updates(parsed, updates);
+  if (Object.keys(applicable).length === 0) return content;
+  let current = content;
+  for (const [key, value] of Object.entries(applicable)) {
+    current = patch_json_key.set_json_key(current, key, value);
+  }
+  return current;
+}
+function serialize_package_json(value) {
+  return json_format.format_package_json(value);
+}
+var SCRIPTS_PREPEND_KEYS = /* @__PURE__ */ new Set(["preinstall"]);
+function merge_package_scripts(content, scripts) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  const existing = raw === void 0 ? {} : string_record_schema.parse(raw);
+  const migrated = init_logic_migrate.migrate_scripts(existing);
+  const to_add = missing_entries(migrated, scripts);
+  const did_migrate = JSON.stringify(migrated) !== JSON.stringify(existing);
+  if (!did_migrate && to_add.length === 0) return content;
+  const prepend = Object.fromEntries(to_add.filter(([k]) => SCRIPTS_PREPEND_KEYS.has(k)));
+  const append = Object.fromEntries(to_add.filter(([k]) => !SCRIPTS_PREPEND_KEYS.has(k)));
+  return serialize_package_json({ ...parsed, scripts: { ...prepend, ...migrated, ...append } });
+}
+function upgrade_safe_chain_preinstall(content) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const current = scripts["preinstall"];
+  if (current === void 0) return content;
+  const migrated = safe_chain_preinstall.migrate_preinstall(current);
+  if (migrated === current) return content;
+  return serialize_package_json({ ...parsed, scripts: { ...scripts, preinstall: migrated } });
+}
+function merge_development_dependencies(content, additions) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["devDependencies"];
+  const existing = raw === void 0 ? {} : string_record_schema.parse(raw);
+  const to_add = missing_entries(existing, additions);
+  if (to_add.length === 0) return content;
+  return serialize_package_json({
+    ...parsed,
+    devDependencies: { ...existing, ...Object.fromEntries(to_add) }
+  });
+}
+function merge_package_manager(content, value) {
+  if (value.length === 0) return content;
+  const parsed = parse_jsonc(content);
+  if ("packageManager" in parsed) return content;
+  return serialize_package_json({ ...parsed, packageManager: value });
+}
+function merge_development_engines(content, value) {
+  const parsed = parse_jsonc(content);
+  if ("devEngines" in parsed) return content;
+  return serialize_package_json({ ...parsed, devEngines: value });
+}
+function has_package_scripts_marker(content, marker) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return false;
+  const scripts = string_record_schema.parse(raw);
+  return Object.values(scripts).some((cmd) => cmd.includes(marker));
+}
+function merge_package_script_suffix(content, key, cmd) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const existing = scripts[key];
+  if (existing === void 0 || existing.includes(cmd)) return content;
+  const updated_value = existing.trim().length === 0 ? cmd : `${existing} && ${cmd}`;
+  return serialize_package_json({ ...parsed, scripts: { ...scripts, [key]: updated_value } });
+}
+function replace_in_package_script(content, key, from, to) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  const existing = scripts[key];
+  if (!existing?.includes(from)) return content;
+  return serialize_package_json({
+    ...parsed,
+    // The replacer is a function so `to` is inserted verbatim: passed as a string, a `$&` or `$1`
+    // inside it would be read as a substitution pattern rather than as the text it is.
+    scripts: { ...scripts, [key]: existing.replace(from, () => to) }
+  });
+}
+function remove_script_with_marker(content, key, marker) {
+  const parsed = parse_jsonc(content);
+  const raw = parsed["scripts"];
+  if (raw === void 0) return content;
+  const scripts = string_record_schema.parse(raw);
+  if (!scripts[key]?.includes(marker)) return content;
+  const rest = Object.fromEntries(Object.entries(scripts).filter(([k]) => k !== key));
+  return serialize_package_json({ ...parsed, scripts: rest });
+}
+function sort_package_json_keys(content) {
+  const parsed = parse_jsonc(content);
+  const all_keys = Object.keys(parsed);
+  const known = PACKAGE_JSON_KEY_ORDER.filter((k) => Object.hasOwn(parsed, k));
+  const unknown = all_keys.filter((k) => !PACKAGE_JSON_KEY_ORDER.includes(k));
+  const ordered = Object.fromEntries([...known, ...unknown].map((k) => [k, parsed[k]]));
+  const serialized = serialize_package_json(ordered);
+  const current = serialize_package_json(parsed);
+  if (serialized === current) return content;
+  return serialized;
+}
+var init_logic_json_merge = {
+  merge_json_extends,
+  merge_tsconfig_extends,
+  extract_compiler_options,
+  strip_redundant_compiler_options,
+  merge_json_array_field,
+  merge_json_object,
+  merge_package_scripts,
+  upgrade_safe_chain_preinstall,
+  merge_package_script_suffix,
+  replace_in_package_script,
+  remove_script_with_marker,
+  has_package_scripts_marker,
+  merge_development_dependencies,
+  merge_package_manager,
+  merge_development_engines,
+  sort_package_json_keys
+};
+
+// scripts/registry-migration/npm-acquisition.ts
+import { z as z2 } from "zod";
+var NPM = "https://registry.npmjs.org/";
+var SCOPE2 = "@joshuafolkken";
+var LOCKFILE = "pnpm-lock.yaml";
+var SCRIPTS = ["prepare", "postinstall"];
+var dependency_schema = z2.record(z2.string(), z2.string()).optional();
+var manifest_schema = z2.object({
+  dependencies: dependency_schema,
+  devDependencies: dependency_schema,
+  optionalDependencies: dependency_schema,
+  peerDependencies: dependency_schema
+});
+var scripts_schema = z2.looseObject({ scripts: z2.record(z2.string(), z2.string()).optional() });
+function read(root, name) {
+  return file_reader.read_file_or_empty(path3.join(root, name));
+}
+function is_npm(content) {
+  const registry = fix_gh_packages_logic.parse_scope_registries(content).get(SCOPE2);
+  return registry === NPM || registry === NPM.slice(0, -1);
+}
+function is_project_npm(root = process.cwd()) {
+  return is_npm(read(root, ".npmrc")) && migrate_lock.has_npm_sources(read(root, LOCKFILE));
+}
+function is_npm_only(root) {
+  const npmrc2 = read(root, ".npmrc");
+  return is_project_npm(root) && fix_gh_packages_logic.parse_gh_scopes(npmrc2).size === 0;
+}
+function has_scoped_name(dependencies) {
+  return Object.keys(dependencies ?? {}).some((name) => name.startsWith(migrate_lock.SCOPE));
+}
+function has_scoped_dependencies(content) {
+  const manifest = manifest_schema.parse(parse_jsonc(content || "{}"));
+  return Object.values(manifest).some((dependencies) => has_scoped_name(dependencies));
+}
+function can_initialize(root) {
+  return read(root, "pnpm-workspace.yaml") === "" && !has_scoped_dependencies(read(root, "package.json")) && migrate_lock.scoped_artifacts(read(root, LOCKFILE)).length === 0;
+}
+function can_manage(root) {
+  const content = read(root, ".npmrc");
+  return is_npm(content) || !fix_gh_packages_logic.parse_scope_registries(content).has(SCOPE2) && can_initialize(root);
+}
+function merge_npmrc(content, root) {
+  if (is_npm(content)) return migrate_lock.npmrc(content);
+  if (fix_gh_packages_logic.parse_scope_registries(content).has(SCOPE2)) return content;
+  if (can_initialize(root)) return migrate_lock.npmrc(content);
+  return content;
+}
+function is_script_value(content, key, value) {
+  return scripts_schema.parse(parse_jsonc(content)).scripts?.[key] === value;
+}
+function strip_script(content, key, command) {
+  const script = scripts_schema.parse(parse_jsonc(content)).scripts?.[key];
+  if (script === void 0) return content;
+  const suffix = ` && (${command} || true)`;
+  if (!script.endsWith(suffix)) return content;
+  return init_logic_json_merge.replace_in_package_script(
+    content,
+    key,
+    script,
+    script.slice(0, -suffix.length)
+  );
+}
+function merge_lifecycle(content, root, command) {
+  if (!is_npm_only(root)) return content;
+  let merged = content;
+  for (const key of SCRIPTS) merged = strip_script(merged, key, command);
+  return merged;
+}
+var npm_acquisition = {
+  is_npm,
+  is_project_npm,
+  is_npm_only,
+  is_script_value,
+  can_manage,
+  merge_npmrc,
+  merge_lifecycle
+};
+
+export {
+  json_format,
+  parse_jsonc,
+  patch_json_key,
+  config_merge,
+  safe_chain_preinstall,
+  kit_base_preset,
+  init_logic_json_merge,
+  migrate_lock,
+  npm_acquisition
+};