@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-XT3W32DO.js

@@ -0,0 +1,977 @@
+import {
+  config_merge,
+  init_logic_json_merge,
+  json_format,
+  kit_base_preset,
+  npm_acquisition,
+  parse_jsonc,
+  safe_chain_preinstall
+} from "./chunk-6OUQZC6V.js";
+import {
+  pnpm_installer
+} from "./chunk-2NSB5ZYQ.js";
+import {
+  npm_registry
+} from "./chunk-5GI5GLC4.js";
+import {
+  distributed_paths
+} from "./chunk-3MQTOUXT.js";
+import {
+  PACKAGE_DIR,
+  PROJECT_ROOT,
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+import {
+  vscode_settings_schema
+} from "./chunk-RBU2NKHF.js";
+import {
+  package_manifest
+} from "./chunk-WB4T3VY2.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/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/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, readFileSync } from "node:fs";
+import path 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 existsSync(path.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 && existsSync(path.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_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",
+  "scripts/gate/change-scope-action.integration.test.ts",
+  "scripts/gate/path-glob.test.ts",
+  "scripts/gate/toolchain-inputs.consumer.test.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_CMD,
+  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, root) {
+  const lines = content.split("\n");
+  const kept = lines.filter((line) => !LEGACY_NPMRC_LINES.has(line.trim()));
+  const merged = kept.length === lines.length ? content : kept.join("\n");
+  return root === void 0 ? merged : npm_acquisition.merge_npmrc(merged, root);
+}
+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, is_npm = false) {
+  const scripts = is_npm ? { ...get_suggested_scripts(), prepare: `(${GUARDED_LEFTHOOK_CMD} || true)` } : get_suggested_scripts();
+  const has_fix = init_logic_json_merge.has_package_scripts_marker(content, FIX_GH_PACKAGES_MARKER);
+  if (!has_fix || is_npm) 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, is_npm = false) {
+  const has_fix = init_logic_json_merge.has_package_scripts_marker(content, FIX_GH_PACKAGES_MARKER);
+  if (has_fix && !is_npm) return content;
+  const command = is_npm ? `(${GUARDED_LEFTHOOK_CMD} || true)` : PREPARE_CMD;
+  return init_logic_json_merge.merge_package_script_suffix(content, PREPARE_KEY, command);
+}
+function strip_managed_postinstall(content) {
+  const legacy = `${LEGACY_GUARDED_LEFTHOOK_CMD}; ${GUARDED_FIX_GH_PACKAGES_CMD}; true`;
+  if (!npm_acquisition.is_script_value(content, LEGACY_POSTINSTALL_KEY, legacy)) return content;
+  return init_logic_json_merge.remove_script_with_marker(
+    content,
+    LEGACY_POSTINSTALL_KEY,
+    FIX_GH_PACKAGES_CMD
+  );
+}
+function upgrade_npm_lifecycle(content, root) {
+  if (!npm_acquisition.is_npm_only(root)) return content;
+  const stripped = strip_managed_postinstall(content);
+  const prepared = stripped === content ? content : init_logic_json_merge.merge_package_scripts(stripped, {
+    prepare: `(${GUARDED_LEFTHOOK_CMD} || true)`
+  });
+  const merged = stripped === content ? prepared : merge_prepare_lifecycle_cmd(prepared, true);
+  return npm_acquisition.merge_lifecycle(merged, root, GUARDED_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,
+  GUARDED_LEFTHOOK_CMD,
+  GUARDED_FIX_GH_PACKAGES_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,
+  upgrade_npm_lifecycle
+};
+
+// 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(path2, directory) {
+  return path2 === directory || path2.startsWith(`${directory}${PATH_SEPARATOR}`);
+}
+function matches_file(path2) {
+  return init_logic.get_ai_copy_files().includes(path2);
+}
+function matches_mapping(path2) {
+  return init_logic.get_ai_copy_file_mappings().some((mapping) => mapping.src === path2 || mapping.dest === path2);
+}
+function matches_directory(path2) {
+  return init_logic.get_ai_copy_directories().some((directory) => is_inside(path2, directory));
+}
+function matches_plugin_skill(path2) {
+  return PLUGIN_SKILL_DIRECTORIES.some((directory) => is_inside(path2, directory));
+}
+function matches_synced_path(path2) {
+  return synced_paths.get_synced_paths().includes(path2);
+}
+function matches_npm_publish_file(path2) {
+  return path2 === 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(path2) {
+  return MATCHERS.find((matcher) => matcher.matches(path2))?.list;
+}
+function to_hit(path2) {
+  const list = find_list(path2);
+  return list === void 0 ? void 0 : { path: path2, list };
+}
+function find_managed_paths(paths) {
+  return paths.flatMap((path2) => to_hit(path2) ?? []);
+}
+function has_managed_path(paths) {
+  return paths.some((path2) => find_list(path2) !== 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 {
+  init_logic_sonar,
+  init_logic_workspace,
+  init_logic,
+  npm_publish_files,
+  PLUGIN_SKILL_DIRECTORIES,
+  managed_config_scope
+};