@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/chunk-RZ4OKKPM.js

@@ -0,0 +1,1722 @@
+import {
+  pnpm_installer
+} from "./chunk-2NSB5ZYQ.js";
+import {
+  npm_registry
+} from "./chunk-2MJ4OCDL.js";
+import {
+  yaml_document
+} from "./chunk-UCI4AL3Q.js";
+import {
+  distributed_paths
+} from "./chunk-66TGK5XL.js";
+import {
+  PACKAGE_DIR,
+  PROJECT_ROOT,
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_object_schema,
+  string_array_schema,
+  string_record_schema,
+  vscode_settings_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  package_manifest
+} from "./chunk-NKKH3PBE.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/init/init-logic-sonar.ts
+var SONAR_PROJECT_KEY_PLACEHOLDER = "{{PROJECT_KEY}}";
+var SONAR_ORGANIZATION_PLACEHOLDER = "{{ORGANIZATION}}";
+var SONAR_TEMPLATE_SRC = "templates/sonar-project.properties";
+var SONAR_TEMPLATE_DEST = "sonar-project.properties";
+var PROPERTY_LINE_PATTERN = /^([\w.]+)=/u;
+var MULTICRITERIA_KEY = "sonar.issue.ignore.multicriteria";
+var MULTICRITERIA_LINE_PATTERN = /^sonar\.issue\.ignore\.multicriteria=(.*)$/mu;
+function apply_sonar_template(content, project_key, organization) {
+  return content.replaceAll(SONAR_PROJECT_KEY_PLACEHOLDER, () => project_key).replaceAll(SONAR_ORGANIZATION_PLACEHOLDER, () => organization);
+}
+function derive_sonar_identifiers(name_with_owner) {
+  const [organization, repository, ...extra] = name_with_owner.trim().split("/");
+  if (!organization || !repository || extra.length > 0) {
+    throw new Error(`Invalid GitHub repository nameWithOwner: ${name_with_owner}`);
+  }
+  return {
+    organization,
+    project_key: `${organization}_${repository}`
+  };
+}
+function get_sonar_template_source() {
+  return SONAR_TEMPLATE_SRC;
+}
+function get_sonar_template_destination() {
+  return SONAR_TEMPLATE_DEST;
+}
+function extract_properties_keys(content) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const match = PROPERTY_LINE_PATTERN.exec(line);
+    if (match?.[1] !== void 0) keys.add(match[1]);
+  }
+  return keys;
+}
+function get_multicriteria_value(content) {
+  return MULTICRITERIA_LINE_PATTERN.exec(content)?.[1];
+}
+function get_multicriteria_ids(content) {
+  return (get_multicriteria_value(content) ?? "").split(",").map((id) => id.trim()).filter(Boolean);
+}
+function get_property_value(content, key) {
+  return content.split("\n").find((line) => line.startsWith(`${key}=`))?.slice(key.length + 1);
+}
+function has_criterion_conflict(existing, template, id) {
+  return ["ruleKey", "resourceKey"].some((field) => {
+    const key = `${MULTICRITERIA_KEY}.${id}.${field}`;
+    const existing_value = get_property_value(existing, key);
+    const template_value = get_property_value(template, key);
+    return existing_value !== void 0 && template_value !== void 0 && existing_value !== template_value;
+  });
+}
+function criterion_matches(existing, template, existing_id, template_id) {
+  const template_prefix = `${MULTICRITERIA_KEY}.${template_id}`;
+  const existing_prefix = `${MULTICRITERIA_KEY}.${existing_id}`;
+  const rule = get_property_value(template, `${template_prefix}.ruleKey`);
+  const resource = get_property_value(template, `${template_prefix}.resourceKey`);
+  if (rule === void 0 || resource === void 0) return false;
+  return rule === get_property_value(existing, `${existing_prefix}.ruleKey`) && resource === get_property_value(existing, `${existing_prefix}.resourceKey`);
+}
+function allocate_criterion_id(used_ids) {
+  let next_index = 1;
+  for (const id of used_ids) {
+    const numeric_id = /^e(\d+)$/u.exec(id)?.[1];
+    if (numeric_id !== void 0) next_index = Math.max(next_index, Number(numeric_id) + 1);
+  }
+  return `e${next_index.toString()}`;
+}
+function rename_criterion(template, id, replacement_id) {
+  const ids = get_multicriteria_ids(template).map(
+    (entry) => entry === id ? replacement_id : entry
+  );
+  const updated_list = template.replace(
+    MULTICRITERIA_LINE_PATTERN,
+    () => `${MULTICRITERIA_KEY}=${ids.join(",")}`
+  );
+  return updated_list.replaceAll(
+    `${MULTICRITERIA_KEY}.${id}.`,
+    () => `${MULTICRITERIA_KEY}.${replacement_id}.`
+  );
+}
+function find_matching_criterion(existing, template, ids, id) {
+  return ids.find((candidate) => criterion_matches(existing, template, candidate, id));
+}
+function resolve_multicriteria_conflicts(existing, template) {
+  const existing_ids = get_multicriteria_ids(existing);
+  const template_ids = get_multicriteria_ids(template);
+  const reusable_ids = existing_ids.filter((id) => !template_ids.includes(id));
+  let resolved = template;
+  for (const id of template_ids) {
+    if (!existing_ids.includes(id) || !has_criterion_conflict(existing, resolved, id)) continue;
+    const matching_id = find_matching_criterion(existing, resolved, reusable_ids, id);
+    const replacement_id = matching_id ?? allocate_criterion_id(/* @__PURE__ */ new Set([...existing_ids, ...get_multicriteria_ids(resolved)]));
+    resolved = rename_criterion(resolved, id, replacement_id);
+  }
+  return resolved;
+}
+function merge_multicriteria_ids(existing, template_content) {
+  const existing_value = get_multicriteria_value(existing);
+  if (existing_value === void 0) return existing;
+  const template_value = get_multicriteria_value(template_content);
+  if (template_value === void 0) return existing;
+  const existing_ids = get_multicriteria_ids(existing);
+  const template_ids = get_multicriteria_ids(template_content);
+  const merged_ids = [.../* @__PURE__ */ new Set([...existing_ids, ...template_ids])];
+  if (merged_ids.join(",") === existing_value) return existing;
+  return existing.replace(
+    MULTICRITERIA_LINE_PATTERN,
+    () => `${MULTICRITERIA_KEY}=${merged_ids.join(",")}`
+  );
+}
+function merge_sonar_properties(existing, template_content) {
+  const resolved_template = resolve_multicriteria_conflicts(existing, template_content);
+  const merged_existing = merge_multicriteria_ids(existing, resolved_template);
+  const existing_keys = extract_properties_keys(merged_existing);
+  const lines_to_add = resolved_template.split("\n").filter((line) => {
+    const key = PROPERTY_LINE_PATTERN.exec(line)?.[1];
+    return key !== void 0 && !existing_keys.has(key);
+  });
+  if (lines_to_add.length === 0) return merged_existing;
+  const normalized = merged_existing.endsWith("\n") ? merged_existing : `${merged_existing}
+`;
+  return `${normalized}
+${lines_to_add.join("\n")}
+`;
+}
+var init_logic_sonar = {
+  apply_sonar_template,
+  derive_sonar_identifiers,
+  get_sonar_template_source,
+  get_sonar_template_destination,
+  merge_sonar_properties
+};
+
+// 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/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-deploy-vps.ts
+import semver from "semver";
+var PNPM_INSTALL_PATTERN = /npm install -g pnpm@\d[\d.]{0,19}/gu;
+var PNPM12_INSTALL = "npm install -g pnpm@12.6.0";
+var MINIMUM_PNPM_VERSION = "12.1.0";
+var OLD_PNPM_CHECK_PATTERN = /^([ \t]*)if ! command -v pnpm &> \/dev\/null(?: \|\| \[ "\$PNPM_MAJOR" -lt \d+ \])?; then$/mu;
+var OLD_MAJOR_LINE_PATTERN = /^[ \t]*PNPM_MAJOR=\$\(pnpm --version 2>\/dev\/null \| cut -d\. -f1 \|\| echo "0"\)\n/mu;
+var VERSION_CHECK_MARKER = '[ "$PNPM_MINOR" -lt 1 ]';
+var UNVERIFIED_INSTALLER = /curl -fsSL https:\/\/get\.pnpm\.io\/install\.sh \| sh -/gu;
+function replace_outdated_install(command) {
+  const version = command.slice("npm install -g pnpm@".length);
+  const valid_version = semver.valid(version);
+  if (valid_version === null) return command;
+  return semver.lt(valid_version, MINIMUM_PNPM_VERSION) ? PNPM12_INSTALL : command;
+}
+function build_version_check(indent) {
+  return [
+    `${indent}PNPM_VERSION=$(pnpm --version 2>/dev/null || echo "0.0.0")`,
+    `${indent}PNPM_MAJOR=$(echo "$PNPM_VERSION" | cut -d. -f1)`,
+    `${indent}PNPM_MINOR=$(echo "$PNPM_VERSION" | cut -d. -f2)`,
+    `${indent}if [ "$PNPM_MAJOR" -lt 12 ] || { [ "$PNPM_MAJOR" -eq 12 ] && [ "$PNPM_MINOR" -lt 1 ]; }; then`
+  ].join("\n");
+}
+function patch_deploy_vps_pnpm(content) {
+  const with_pnpm12 = content.replaceAll(UNVERIFIED_INSTALLER, () => pnpm_installer.command()).replaceAll(PNPM_INSTALL_PATTERN, (command) => replace_outdated_install(command));
+  if (with_pnpm12.includes(VERSION_CHECK_MARKER) || !OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) {
+    return with_pnpm12;
+  }
+  return with_pnpm12.replace(OLD_MAJOR_LINE_PATTERN, "").replace(OLD_PNPM_CHECK_PATTERN, (_, indent) => build_version_check(indent));
+}
+var init_logic_deploy_vps = { patch_deploy_vps_pnpm };
+
+// 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/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/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, path3) {
+  const root = parse_root(content);
+  if (root === void 0) return void 0;
+  const parent = path3.length > 1 ? findNodeAtLocation(root, path3.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, path3) {
+  const parent = resolve_parent(content, path3);
+  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, path3) {
+  const index = property_index(parent, path3.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, path3) : cut;
+}
+function remove_json_path(content, path3) {
+  const parent = resolve_parent(content, path3);
+  if (parent === void 0) return content;
+  const next = cut_property(content, parent, path3);
+  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 } 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 dump(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/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 path 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(path.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/init/kit-development-versions.ts
+import { z } from "zod";
+var kit_manifest_schema = z.object({
+  peerDependencies: z.record(z.string(), z.string()).default({}),
+  devDependencies: z.record(z.string(), z.string())
+});
+function read_kit_manifest() {
+  return package_manifest.read_manifest(PACKAGE_DIR, kit_manifest_schema);
+}
+function versions_of(names) {
+  const { devDependencies: versions } = read_kit_manifest();
+  const entries = names.map((name) => {
+    const version = versions[name];
+    if (version === void 0) throw new Error(`Missing development version for ${name}`);
+    return [name, version];
+  });
+  return Object.fromEntries(entries);
+}
+function peer_names() {
+  return Object.keys(read_kit_manifest().peerDependencies);
+}
+var kit_development_versions = { peer_names, versions_of };
+
+// scripts/init/init-logic-secretlint.ts
+var SECRETLINT_CONFIG_FILENAME = ".secretlintrc.json";
+var SECRETLINT_RULE_PRESET = "@secretlint/secretlint-rule-preset-recommend";
+var SECRETLINT_PACKAGES = ["secretlint", SECRETLINT_RULE_PRESET];
+function generate_secretlint_config() {
+  const config = { rules: [{ id: SECRETLINT_RULE_PRESET }] };
+  return `${JSON.stringify(config, void 0, "	")}
+`;
+}
+function get_secretlint_config_filename() {
+  return SECRETLINT_CONFIG_FILENAME;
+}
+function merge_secretlint_development_deps(content) {
+  return init_logic_json_merge.merge_development_dependencies(
+    content,
+    kit_development_versions.versions_of(SECRETLINT_PACKAGES)
+  );
+}
+var init_logic_secretlint = {
+  generate_secretlint_config,
+  get_secretlint_config_filename,
+  merge_secretlint_development_deps
+};
+
+// scripts/init/init-logic-templates.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import path2 from "node:path";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/init/init-logic-templates.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var ESLINT_VANILLA = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
+
+export default create_vanilla_config({
+	gitignore_path: new URL('./.gitignore', import.meta.url),
+	tsconfig_root_dir: import.meta.dirname,
+})
+`;
+var DEFAULT_TAILWIND_STYLESHEET = "./src/routes/layout.css";
+var TAILWIND_STYLESHEET_PATTERN = /tailwindStylesheet"?:\s*['"]([^'"]+)['"]/u;
+var KIT_ESLINT_IMPORT_MARKER = "@joshuafolkken/kit/eslint/";
+var VANILLA_ESLINT_MARKERS = [
+  "js.configs.recommended",
+  "ts.configs.recommended",
+  "svelte.configs.recommended"
+];
+var RULES_BLOCK_PATTERN = /rules\s*:\s*\{/gu;
+var RULES_INDENT_DEPTH = 3;
+var RULES_INDENT = "	".repeat(RULES_INDENT_DEPTH);
+var PLAYWRIGHT_TEMPLATE_PATH = package_path("playwright.config.ts");
+var VANILLA_WITH_RULES_TPL = `import { create_vanilla_config } from '@joshuafolkken/kit/eslint/vanilla'
+
+export default [
+	...create_vanilla_config({
+		gitignore_path: new URL('./.gitignore', import.meta.url),
+		tsconfig_root_dir: import.meta.dirname,
+	}),
+	{
+		rules: {
+$RULES
+		},
+	},
+]
+`;
+var RULES_PLACEHOLDER = "$RULES";
+var NOT_FOUND = -1;
+function generate_eslint_config() {
+  return ESLINT_VANILLA;
+}
+function is_vanilla_eslint_config(existing) {
+  if (existing.includes(KIT_ESLINT_IMPORT_MARKER)) return false;
+  return VANILLA_ESLINT_MARKERS.some((marker) => existing.includes(marker));
+}
+function update_brace_depth(char, depth) {
+  if (char === "{") return depth + 1;
+  if (char === "}") return depth - 1;
+  return depth;
+}
+function find_matching_close_brace(source, open_index) {
+  let depth = 0;
+  for (let index = open_index; index < source.length; index += 1) {
+    depth = update_brace_depth(source[index], depth);
+    if (depth === 0 && source[index] === "}") return index;
+  }
+  return NOT_FOUND;
+}
+function extract_block_from_open(source, open_index) {
+  const close = find_matching_close_brace(source, open_index);
+  if (close === NOT_FOUND) return void 0;
+  const inner = source.slice(open_index + 1, close).trim();
+  return inner.length > 0 ? inner : void 0;
+}
+function extract_rules_inner_blocks(existing) {
+  const blocks = [];
+  for (const match of existing.matchAll(RULES_BLOCK_PATTERN)) {
+    const open = match.index + match[0].length - 1;
+    const inner = extract_block_from_open(existing, open);
+    if (inner !== void 0) blocks.push(inner);
+  }
+  return blocks;
+}
+function indent_block(text, indent) {
+  return text.split("\n").map((line) => line.length === 0 ? line : `${indent}${line.trimStart()}`).join("\n");
+}
+function apply_rules_template(rules_body) {
+  const rules_block = indent_block(rules_body, RULES_INDENT);
+  return VANILLA_WITH_RULES_TPL.replace(RULES_PLACEHOLDER, () => rules_block);
+}
+function merge_eslint_config(existing) {
+  if (!is_vanilla_eslint_config(existing)) return existing;
+  const rules_blocks = extract_rules_inner_blocks(existing);
+  if (rules_blocks.length === 0) return generate_eslint_config();
+  return apply_rules_template(rules_blocks.join(",\n"));
+}
+function detect_tailwind_stylesheet(project_root) {
+  return existsSync2(path2.join(project_root, DEFAULT_TAILWIND_STYLESHEET)) ? DEFAULT_TAILWIND_STYLESHEET : void 0;
+}
+function generate_prettier_config(stylesheet) {
+  const stylesheet_line = stylesheet === void 0 ? "" : `	tailwindStylesheet: '${stylesheet}',
+`;
+  return `import { config } from '@joshuafolkken/kit/prettier'
+
+export default {
+	...config,
+${stylesheet_line}}
+`;
+}
+function existing_stylesheet(existing, project_root) {
+  const named = TAILWIND_STYLESHEET_PATTERN.exec(existing)?.[1];
+  return named !== void 0 && existsSync2(path2.resolve(project_root, named)) ? named : void 0;
+}
+function merge_prettier_config(existing, project_root) {
+  const stylesheet = existing_stylesheet(existing, project_root) ?? detect_tailwind_stylesheet(project_root);
+  return generate_prettier_config(stylesheet);
+}
+function generate_playwright_config() {
+  return readFileSync(PLAYWRIGHT_TEMPLATE_PATH, "utf8");
+}
+var init_logic_templates = {
+  generate_eslint_config,
+  merge_eslint_config,
+  detect_tailwind_stylesheet,
+  generate_prettier_config,
+  merge_prettier_config,
+  generate_playwright_config
+};
+
+// scripts/init/init-logic-toolchain.ts
+var CONSUMER_RESOLVED_TOOLS = [
+  "eslint",
+  "prettier",
+  "typescript",
+  "@playwright/test",
+  "@ianvs/prettier-plugin-sort-imports",
+  "prettier-plugin-svelte",
+  "prettier-plugin-tailwindcss",
+  "cspell",
+  "@types/node"
+];
+var LEFTHOOK_DEVELOPMENT_DEPENDENCY = "lefthook";
+var DECLARING_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function consumer_resolved_names(has_git) {
+  return has_git ? [...CONSUMER_RESOLVED_TOOLS, LEFTHOOK_DEVELOPMENT_DEPENDENCY] : CONSUMER_RESOLVED_TOOLS;
+}
+function get_toolchain_development_dependencies(has_git) {
+  return kit_development_versions.versions_of([
+    ...kit_development_versions.peer_names(),
+    ...consumer_resolved_names(has_git)
+  ]);
+}
+function is_declared(manifest, name) {
+  return DECLARING_FIELDS.some((field) => {
+    const dependencies = manifest[field];
+    return json_value.is_record(dependencies) && Object.hasOwn(dependencies, name);
+  });
+}
+function merge_consumer_resolved_development_deps(content, has_git) {
+  const manifest = parse_jsonc(content);
+  const missing = consumer_resolved_names(has_git).filter((name) => !is_declared(manifest, name));
+  return init_logic_json_merge.merge_development_dependencies(
+    content,
+    kit_development_versions.versions_of(missing)
+  );
+}
+var init_logic_toolchain = {
+  consumer_resolved_names,
+  get_toolchain_development_dependencies,
+  merge_consumer_resolved_development_deps
+};
+
+// scripts/init/init-logic-workspace.ts
+function extract_yaml_top_level_keys(content) {
+  return content.split("\n").flatMap((line) => {
+    const key = /^([a-zA-Z][a-zA-Z0-9_-]*):/u.exec(line)?.[1];
+    return key ?? [];
+  });
+}
+function extract_yaml_block(content, key) {
+  const pattern = new RegExp(String.raw`(^${key}:[^\n]*\n(?:(?:[ \t][^\n]*|)\n)*)`, "mu");
+  return pattern.exec(content)?.[1]?.trimEnd() ?? "";
+}
+function append_user_blocks(base, user_keys, existing) {
+  const user_blocks = user_keys.map((k) => extract_yaml_block(existing, k)).filter(Boolean).join("\n");
+  const normalized = base.endsWith("\n") ? base : `${base}
+`;
+  return `${normalized}
+${user_blocks}
+`;
+}
+var DEPRECATED_KEYS = /* @__PURE__ */ new Set(["onlyBuiltDependencies"]);
+function remove_deprecated_yaml_key(content, key) {
+  const block = extract_yaml_block(content, key);
+  if (block.length === 0) return content;
+  const removed = content.replaceAll(`${block}
+`, "");
+  return removed.replaceAll(/\n{3,}/gu, "\n\n");
+}
+function remove_deprecated_yaml_keys(content) {
+  let result = content;
+  for (const key of DEPRECATED_KEYS) {
+    result = remove_deprecated_yaml_key(result, key);
+  }
+  return `${result.trimEnd()}
+`;
+}
+var BUILD_PLACEHOLDER_PATTERN = /^([ \t]+)([^\s:#][^:#]*): set this to true or false$/gmu;
+var TEMPLATE_BUILD_PATTERN = /^[ \t]+(?<key>[^\s:#][^:#]*):[ \t]*(?<value>true|false)\b/u;
+function unquote(key) {
+  return key.trim().replaceAll(/^['"]|['"]$/gu, "");
+}
+function template_build_values(template) {
+  const lines = extract_yaml_block(template, "allowBuilds").split("\n");
+  return new Map(
+    lines.flatMap((line) => {
+      const { key, value } = TEMPLATE_BUILD_PATTERN.exec(line)?.groups ?? {};
+      return key && value ? [[unquote(key), value]] : [];
+    })
+  );
+}
+function answer_build_placeholders(existing, template) {
+  const values = template_build_values(template);
+  return existing.replaceAll(BUILD_PLACEHOLDER_PATTERN, (line, indent, key) => {
+    const value = values.get(unquote(key));
+    return value === void 0 ? line : `${indent}${key}: ${value}`;
+  });
+}
+var BUILD_ENTRY_KEY_PATTERN = /^[ \t]+(?<key>[^\s:#][^:#]*):/u;
+function build_entry_key(line) {
+  const key = BUILD_ENTRY_KEY_PATTERN.exec(line)?.groups?.["key"];
+  return key === void 0 ? void 0 : unquote(key);
+}
+function build_entry_keys(block) {
+  return new Set(block.split("\n").flatMap((line) => build_entry_key(line) ?? []));
+}
+var BLOCK_MAPPING_HEADER_PATTERN = /^allowBuilds:[ \t]*(?:#[^\n]*)?(?:\n|$)/u;
+var LEADING_INDENT_PATTERN = /^[ \t]+/u;
+function block_entry_indent(block) {
+  const entry = block.split("\n").find((line) => build_entry_key(line) !== void 0);
+  return entry === void 0 ? void 0 : LEADING_INDENT_PATTERN.exec(entry)?.[0];
+}
+function reindent(line, indent) {
+  return indent === void 0 ? line : line.replace(LEADING_INDENT_PATTERN, () => indent);
+}
+function add_missing_build_entries(existing, template) {
+  const block = extract_yaml_block(existing, "allowBuilds");
+  if (!BLOCK_MAPPING_HEADER_PATTERN.test(block)) return existing;
+  const present = build_entry_keys(block);
+  const indent = block_entry_indent(block);
+  const missing = extract_yaml_block(template, "allowBuilds").split("\n").filter((line) => {
+    const key = build_entry_key(line);
+    return key !== void 0 && !present.has(key);
+  }).map((line) => reindent(line, indent));
+  if (missing.length === 0) return existing;
+  return existing.replace(block, () => [block, ...missing].join("\n"));
+}
+var MOVED_NPMRC_SETTINGS = [
+  { npmrc_key: "minimum-release-age", workspace_key: "minimumReleaseAge", value_pattern: /^\d+$/u },
+  { npmrc_key: "engine-strict", workspace_key: "engineStrict", value_pattern: /^(?:true|false)$/u }
+];
+function npmrc_value(npmrc, key) {
+  const pattern = new RegExp(String.raw`^[ \t]*${key}[ \t]*=[ \t]*(\S+)[ \t]*$`, "gmu");
+  return [...npmrc.matchAll(pattern)].at(-1)?.[1];
+}
+function carry_npmrc_setting(template, npmrc, setting) {
+  const value = npmrc_value(npmrc, setting.npmrc_key);
+  if (value === void 0 || !setting.value_pattern.test(value)) return template;
+  const line_pattern = new RegExp(`^${setting.workspace_key}:.*$`, "mu");
+  return template.replace(line_pattern, () => `${setting.workspace_key}: ${value}`);
+}
+var KIT_ONLY_REGION_PATTERN = /^[ \t]*# kit-only:start\b.*\n(?:.*\n)*?[ \t]*# kit-only:end\b.*\n/gmu;
+function drop_kit_only_regions(template) {
+  return template.replaceAll(KIT_ONLY_REGION_PATTERN, "").replaceAll(/\n{3,}/gu, "\n\n");
+}
+function carry_npmrc_settings(template, npmrc) {
+  let result = template;
+  for (const setting of MOVED_NPMRC_SETTINGS) {
+    result = carry_npmrc_setting(result, npmrc, setting);
+  }
+  return result;
+}
+function merge_workspace_yaml(existing, template) {
+  if (!existing.trim()) return template;
+  const normalized = existing.endsWith("\n") ? existing : `${existing}
+`;
+  const answered = answer_build_placeholders(remove_deprecated_yaml_keys(normalized), template);
+  const cleaned = add_missing_build_entries(answered, template);
+  if (!cleaned.trim()) return template;
+  const existing_keys = new Set(extract_yaml_top_level_keys(cleaned));
+  const new_keys = extract_yaml_top_level_keys(template).filter((k) => !existing_keys.has(k));
+  if (new_keys.length === 0) return cleaned;
+  return append_user_blocks(cleaned, new_keys, template);
+}
+var init_logic_workspace = {
+  carry_npmrc_settings,
+  drop_kit_only_regions,
+  extract_yaml_block,
+  merge_workspace_yaml,
+  template_build_values
+};
+
+// scripts/init/init-logic-yaml-merge.ts
+var CSPELL_IMPORT_FIELD = "import";
+var LEFTHOOK_EXTENDS_FIELD = "extends";
+var CSPELL_IMPORT_POSITION = { after: "version" };
+var CSPELL_QUOTE_STYLE = "double";
+function merge_yaml_list_entry(content, key, value) {
+  return config_merge.patch_yaml_list_field(content, {
+    field: key,
+    ensure: [value],
+    position: "front"
+  });
+}
+function merge_lefthook_extends(content, value) {
+  const entries = config_merge.read_yaml_list_field(content, LEFTHOOK_EXTENDS_FIELD);
+  if (kit_base_preset.is_lefthook_base_present(entries)) return content;
+  return merge_yaml_list_entry(content, LEFTHOOK_EXTENDS_FIELD, value);
+}
+function merge_cspell_import(content, value) {
+  const entries = config_merge.read_yaml_list_field(content, CSPELL_IMPORT_FIELD);
+  if (kit_base_preset.is_cspell_base_present(entries)) return content;
+  return config_merge.patch_yaml_list_field(content, {
+    field: CSPELL_IMPORT_FIELD,
+    ensure: [value],
+    position: CSPELL_IMPORT_POSITION,
+    quote_style: CSPELL_QUOTE_STYLE
+  });
+}
+var init_logic_yaml_merge = {
+  merge_yaml_list_entry,
+  merge_lefthook_extends,
+  merge_cspell_import
+};
+
+// scripts/init/init-logic.ts
+var DEV_ENGINES_VALUE = {
+  packageManager: { name: "pnpm", version: ">=12.1.0", onFail: "download" }
+};
+var LEGACY_NPMRC_LINES = /* @__PURE__ */ new Set([
+  "engine-strict=true",
+  "minimum-release-age=1440",
+  "confirmModulesPurge=false",
+  "lockfile-include-tarball-url=true"
+]);
+var CSPELL_IMPORT = "@joshuafolkken/kit/cspell";
+var LEFTHOOK_INSTALL_CMD = "lefthook install";
+var { SAFE_CHAIN_CMD: SAFE_CHAIN_CMD2 } = safe_chain_preinstall;
+var FIX_GH_PACKAGES_CMD = "tsx node_modules/@joshuafolkken/kit/scripts/gh/fix-gh-packages.ts";
+var FIX_GH_PACKAGES_MARKER = "fix-gh-packages";
+var PREPARE_KEY = "prepare";
+var LEGACY_POSTINSTALL_KEY = "postinstall";
+var HOOK_INSTALL_WARNING = "lefthook install failed: git hooks are NOT installed. A set core.hooksPath is the usual cause. See https://github.com/joshuafolkken/kit/blob/main/docs/init.md#corehookspath-stops-lefthook-installing-anything";
+var LEFTHOOK_BINARY_GUARD = "command -v lefthook >/dev/null 2>&1";
+var GUARDED_LEFTHOOK_CMD = `${LEFTHOOK_BINARY_GUARD} && { ${LEFTHOOK_INSTALL_CMD} || echo '${HOOK_INSTALL_WARNING}' >&2; }`;
+var LEGACY_GUARDED_LEFTHOOK_CMD = `${LEFTHOOK_BINARY_GUARD} && ${LEFTHOOK_INSTALL_CMD}`;
+var GUARDED_FIX_GH_PACKAGES_CMD = `command -v tsx >/dev/null 2>&1 && ${FIX_GH_PACKAGES_CMD}`;
+var PREPARE_CMD = `(${GUARDED_LEFTHOOK_CMD} || true) && (${GUARDED_FIX_GH_PACKAGES_CMD} || true)`;
+var AI_COPY_FILES = [
+  "AGENTS.md",
+  "GEMINI.md",
+  "CODE_OF_CONDUCT.md",
+  ".cursorrules",
+  ".coderabbit.yaml",
+  ".gitattributes",
+  ".mcp.json",
+  ".prettierignore",
+  "SECURITY.md",
+  "pnpm-workspace.yaml",
+  "tsconfig.sonar.json",
+  ".github/workflows/auto-tag.yml",
+  ".github/workflows/production.yml",
+  ".github/workflows/sonar-qube.yml",
+  ".github/workflows/pr-classification.yml",
+  // Called by `ci.yml` and `pr-classification.yml` as `uses: ./.github/actions/setup-pnpm`; without
+  // it the consumer's jobs cannot resolve the action and their checks fail.
+  ".github/actions/setup-pnpm/action.yml",
+  // The one place the workflows' Node.js version is written, called by every distributed workflow
+  // that sets Node.js up.
+  ".github/actions/setup-node/action.yml",
+  ".github/actions/change-scope/action.yml",
+  "scripts/gate/change-scope-action.ts",
+  "scripts/gate/path-glob.ts",
+  "scripts/gate/toolchain-inputs.ts",
+  ".github/pull_request_template.md",
+  ".github/release.yml",
+  ".claude/settings.json",
+  ".codex/config.toml",
+  ".codex/hooks.json"
+];
+var AI_COPY_FILE_MAPPINGS = [
+  { src: "templates/workflows/ci.yml", dest: ".github/workflows/ci.yml" },
+  // A template rather than a copy of kit's own file: kit groups its github-actions bumps, which a
+  // consumer's auto-merge would hold whole once one bump touches an upstream-managed workflow.
+  { src: "templates/dependabot.yml", dest: ".github/dependabot.yml" },
+  // The counterpart to the distributed `.github/dependabot.yml`: without it a consumer receives
+  // the machinery that opens Dependabot pull requests and none of the machinery that closes them,
+  // so every github-actions bump sits green and unmerged.
+  {
+    src: "templates/workflows/dependabot-auto-merge.yml",
+    dest: ".github/workflows/dependabot-auto-merge.yml"
+  },
+  // A template rather than a copy of kit's own file: kit releases from its publish.yml, so the file
+  // must not run in kit as well. Repositories public npm carries also receive kit's publish.yml
+  // (npm-publish-files.ts), which skips its GitHub Release steps where this file exists.
+  { src: "templates/workflows/github-release.yml", dest: ".github/workflows/github-release.yml" }
+];
+var AI_COPY_DIRECTORIES = [];
+var LEFTHOOK_EXTENDS = "node_modules/@joshuafolkken/kit/lefthook/vanilla.yml";
+var TSCONFIG_EXTENDS = "./node_modules/@joshuafolkken/kit/tsconfig/base.json";
+var TSCONFIG_PRESET_FILENAME = "base.json";
+var TSCONFIG_EXCLUDE_FIELD = "exclude";
+var TSCONFIG_GENERATED_OUTPUT_EXCLUDE = [
+  "node_modules",
+  "build",
+  "dist",
+  "playwright-report",
+  "test-results"
+];
+var TSCONFIG_SVELTEKIT_EXCLUDE = [
+  "src/service-worker.js",
+  "src/service-worker/**/*.js",
+  "src/service-worker.ts",
+  "src/service-worker/**/*.ts",
+  "src/service-worker.d.ts",
+  "src/service-worker/**/*.d.ts"
+];
+var TSCONFIG_EXCLUDE = [
+  ...TSCONFIG_GENERATED_OUTPUT_EXCLUDE,
+  ...TSCONFIG_SVELTEKIT_EXCLUDE
+];
+var VSCODE_EXTENSIONS_FILENAME = "extensions.json";
+var VSCODE_SETTINGS_FILENAME = "settings.json";
+var KIT_ONLY_VSCODE_SETTINGS_KEYS = /* @__PURE__ */ new Set([
+  "sonarlint.connectedMode.project"
+]);
+var SUGGESTED_SCRIPTS_COMMON = {
+  preinstall: SAFE_CHAIN_CMD2,
+  prepare: PREPARE_CMD,
+  josh: "josh"
+};
+function generate_tsconfig() {
+  return json_format.format_json({
+    extends: TSCONFIG_EXTENDS,
+    compilerOptions: { types: ["node"] },
+    [TSCONFIG_EXCLUDE_FIELD]: TSCONFIG_EXCLUDE
+  });
+}
+function merge_tsconfig_exclude(content) {
+  const field = TSCONFIG_EXCLUDE_FIELD;
+  return init_logic_json_merge.merge_json_array_field(content, field, TSCONFIG_EXCLUDE);
+}
+function generate_lefthook_config() {
+  return `extends:
+  - ${LEFTHOOK_EXTENDS}
+`;
+}
+function generate_cspell_config() {
+  return `version: "0.2"
+import:
+  - "${CSPELL_IMPORT}"
+words: []
+ignorePaths: []
+`;
+}
+function append_missing_lines(existing, missing) {
+  if (missing.length === 0) return existing;
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? `${existing}
+` : existing;
+  return `${prefix}${missing.join("\n")}
+`;
+}
+function merge_npmrc(content) {
+  const lines = content.split("\n");
+  const kept = lines.filter((line) => !LEGACY_NPMRC_LINES.has(line.trim()));
+  return kept.length === lines.length ? content : kept.join("\n");
+}
+function is_gitignore_pattern(line) {
+  const trimmed = line.trim();
+  return trimmed.length > 0 && !trimmed.startsWith("#");
+}
+function merge_gitignore(existing, template) {
+  const existing_lines = new Set(existing.split("\n"));
+  const missing = template.split("\n").filter((line) => is_gitignore_pattern(line) && !existing_lines.has(line));
+  return append_missing_lines(existing, missing);
+}
+function get_tsconfig_extends_entry() {
+  return TSCONFIG_EXTENDS;
+}
+function get_tsconfig_preset_filename() {
+  return TSCONFIG_PRESET_FILENAME;
+}
+function get_tsconfig_exclude_entries() {
+  return TSCONFIG_EXCLUDE;
+}
+function get_lefthook_extends_value() {
+  return LEFTHOOK_EXTENDS;
+}
+function get_cspell_import_value() {
+  return CSPELL_IMPORT;
+}
+function get_vscode_settings_filename() {
+  return VSCODE_SETTINGS_FILENAME;
+}
+function strip_kit_only_vscode_settings(settings) {
+  const entries = Object.entries(settings).filter(
+    ([key]) => !KIT_ONLY_VSCODE_SETTINGS_KEYS.has(key)
+  );
+  return Object.fromEntries(entries);
+}
+function strip_kit_only_vscode_settings_content(raw) {
+  const parsed = vscode_settings_schema.parse(JSON.parse(raw));
+  const stripped = strip_kit_only_vscode_settings(parsed);
+  if (Object.keys(stripped).length === Object.keys(parsed).length) return raw;
+  return json_format.format_json(stripped);
+}
+function get_development_engines_value() {
+  return DEV_ENGINES_VALUE;
+}
+function get_ai_copy_files() {
+  return AI_COPY_FILES;
+}
+function get_ai_copy_file_mappings() {
+  return AI_COPY_FILE_MAPPINGS;
+}
+function get_ai_copy_directories() {
+  return AI_COPY_DIRECTORIES;
+}
+function get_suggested_scripts() {
+  return SUGGESTED_SCRIPTS_COMMON;
+}
+function get_suggested_scripts_for_content(content) {
+  const scripts = get_suggested_scripts();
+  const has_fix = init_logic_json_merge.has_package_scripts_marker(content, FIX_GH_PACKAGES_MARKER);
+  if (!has_fix) return scripts;
+  return Object.fromEntries(Object.entries(scripts).filter(([key]) => key !== PREPARE_KEY));
+}
+function upgrade_prepare_lefthook_warning(content) {
+  return init_logic_json_merge.replace_in_package_script(
+    content,
+    PREPARE_KEY,
+    LEGACY_GUARDED_LEFTHOOK_CMD,
+    GUARDED_LEFTHOOK_CMD
+  );
+}
+function merge_prepare_lifecycle_cmd(content) {
+  const has_fix = init_logic_json_merge.has_package_scripts_marker(content, FIX_GH_PACKAGES_MARKER);
+  if (has_fix) return content;
+  return init_logic_json_merge.merge_package_script_suffix(content, PREPARE_KEY, PREPARE_CMD);
+}
+function strip_managed_postinstall(content) {
+  return init_logic_json_merge.remove_script_with_marker(
+    content,
+    LEGACY_POSTINSTALL_KEY,
+    FIX_GH_PACKAGES_CMD
+  );
+}
+var init_logic = {
+  ...init_logic_templates,
+  ...init_logic_workspace,
+  ...init_logic_sonar,
+  ...init_logic_json_merge,
+  ...init_logic_secretlint,
+  ...init_logic_toolchain,
+  ...init_logic_yaml_merge,
+  ...init_logic_deploy_vps,
+  ...distributed_paths,
+  generate_tsconfig,
+  merge_tsconfig_exclude,
+  get_tsconfig_exclude_entries,
+  generate_lefthook_config,
+  generate_cspell_config,
+  merge_npmrc,
+  merge_gitignore,
+  get_tsconfig_extends_entry,
+  get_tsconfig_preset_filename,
+  get_lefthook_extends_value,
+  get_cspell_import_value,
+  get_vscode_settings_filename,
+  strip_kit_only_vscode_settings,
+  strip_kit_only_vscode_settings_content,
+  VSCODE_EXTENSIONS_FILENAME,
+  SAFE_CHAIN_CMD: SAFE_CHAIN_CMD2,
+  GUARDED_LEFTHOOK_CMD,
+  upgrade_prepare_lefthook_warning,
+  get_development_engines_value,
+  get_ai_copy_files,
+  get_ai_copy_file_mappings,
+  get_ai_copy_directories,
+  get_suggested_scripts,
+  get_suggested_scripts_for_content,
+  merge_prepare_lifecycle_cmd,
+  strip_managed_postinstall
+};
+
+// scripts/init/npm-publish-files.ts
+var PUBLISH_WORKFLOW = ".github/workflows/publish.yml";
+function can_take_workflow(shape) {
+  return shape?.profile !== "basic" && shape?.has_github !== false;
+}
+function files(shape) {
+  if (!can_take_workflow(shape)) return [];
+  return npm_registry.published_package_name(PROJECT_ROOT) === void 0 ? [] : [PUBLISH_WORKFLOW];
+}
+var npm_publish_files = { files, PUBLISH_WORKFLOW };
+
+// scripts/sync/plugin-skill-directories.ts
+var PLUGIN_SKILL_DIRECTORIES = [
+  ".claude/skills/workflow-commands",
+  ".claude/skills/epic-commands",
+  ".claude/skills/dependency-update",
+  ".claude/skills/verify-ui"
+];
+
+// scripts/sync/synced-paths.ts
+var SYNCED_ARTIFACT_PATHS = [
+  "prettier.config.js",
+  "playwright.config.ts",
+  ".github/workflows/deploy-vps.yml"
+];
+var SYNCED_CONFIG_PATHS = [
+  ".npmrc",
+  ".gitignore",
+  "eslint.config.js",
+  "tsconfig.json",
+  "cspell.config.yaml",
+  "lefthook.yml",
+  ".secretlintrc.json",
+  ".vscode/extensions.json",
+  ".vscode/settings.json",
+  ".vscode/tasks.json"
+];
+function get_synced_paths() {
+  return [
+    ...SYNCED_ARTIFACT_PATHS,
+    ...SYNCED_CONFIG_PATHS,
+    init_logic.get_sonar_template_destination()
+  ];
+}
+var synced_paths = { get_synced_paths };
+
+// scripts/sync/managed-config-scope.ts
+var AI_COPY_FILES_LIST = "AI_COPY_FILES";
+var AI_COPY_FILE_MAPPINGS_LIST = "AI_COPY_FILE_MAPPINGS";
+var AI_COPY_DIRECTORIES_LIST = "AI_COPY_DIRECTORIES";
+var SYNCED_PATHS_LIST = "SYNCED_PATHS";
+var PLUGIN_SKILL_DIRECTORIES_LIST = "PLUGIN_SKILL_DIRECTORIES";
+var NPM_PUBLISH_FILES_LIST = "NPM_PUBLISH_FILES";
+var PATH_SEPARATOR = "/";
+function is_inside(path3, directory) {
+  return path3 === directory || path3.startsWith(`${directory}${PATH_SEPARATOR}`);
+}
+function matches_file(path3) {
+  return init_logic.get_ai_copy_files().includes(path3);
+}
+function matches_mapping(path3) {
+  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path3 || mapping.dest === path3);
+}
+function matches_directory(path3) {
+  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path3, directory));
+}
+function matches_plugin_skill(path3) {
+  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path3, directory));
+}
+function matches_synced_path(path3) {
+  return synced_paths.get_synced_paths().includes(path3);
+}
+function matches_npm_publish_file(path3) {
+  return path3 === npm_publish_files.PUBLISH_WORKFLOW;
+}
+var MATCHERS = [
+  { list: AI_COPY_FILES_LIST, matches: matches_file },
+  { list: AI_COPY_FILE_MAPPINGS_LIST, matches: matches_mapping },
+  { list: AI_COPY_DIRECTORIES_LIST, matches: matches_directory },
+  { list: PLUGIN_SKILL_DIRECTORIES_LIST, matches: matches_plugin_skill },
+  { list: SYNCED_PATHS_LIST, matches: matches_synced_path },
+  { list: NPM_PUBLISH_FILES_LIST, matches: matches_npm_publish_file }
+];
+function find_list(path3) {
+  return MATCHERS.find((matcher) => matcher.matches(path3))?.list;
+}
+function to_hit(path3) {
+  const list = find_list(path3);
+  return list === void 0 ? void 0 : { path: path3, list };
+}
+function find_managed_paths(paths) {
+  return paths.flatMap((path3) => to_hit(path3) ?? []);
+}
+function has_managed_path(paths) {
+  return paths.some((path3) => find_list(path3) !== void 0);
+}
+function format_hit(hit) {
+  return `${hit.path} (${hit.list})`;
+}
+function format_hits(hits) {
+  return hits.map((hit) => format_hit(hit)).join("\n");
+}
+var managed_config_scope = {
+  find_managed_paths,
+  has_managed_path,
+  format_hit,
+  format_hits
+};
+
+export {
+  json_format,
+  parse_jsonc,
+  patch_json_key,
+  init_logic_json_merge,
+  init_logic_sonar,
+  init_logic_workspace,
+  init_logic,
+  npm_publish_files,
+  PLUGIN_SKILL_DIRECTORIES,
+  managed_config_scope
+};