@clearlydev/nx-archweave 0.1.1 → 0.2.0

package/dist/generators/add-backend/generator.js

@@ -47,13 +47,26 @@ function packageManagerCommands(pm, flavor = "classic") {
 }
 
 // ../template-engine/dist/backend/eslint-boundaries.js
-var SCOPE_CONSTRAINTS = [
-  { sourceTag: "scope:frontend", notDependOnLibsWithTags: ["scope:backend"] },
-  { sourceTag: "scope:backend", notDependOnLibsWithTags: ["scope:frontend"] },
-  { sourceTag: "scope:shared", notDependOnLibsWithTags: ["scope:frontend", "scope:backend"] }
-];
+var DEFAULT_BOUNDARY_TAGS = { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" };
+function readBoundaryTags(config) {
+  const boundaries = config?.["boundaries"];
+  const tags = typeof boundaries === "object" && boundaries !== null ? boundaries["tags"] : void 0;
+  const pick = (role) => {
+    const value = typeof tags === "object" && tags !== null ? tags[role] : void 0;
+    return typeof value === "string" && value.trim() !== "" ? value : DEFAULT_BOUNDARY_TAGS[role];
+  };
+  return { frontend: pick("frontend"), backend: pick("backend"), shared: pick("shared") };
+}
+function scopeConstraints(tags = DEFAULT_BOUNDARY_TAGS) {
+  return [
+    { sourceTag: tags.frontend, notDependOnLibsWithTags: [tags.backend] },
+    { sourceTag: tags.backend, notDependOnLibsWithTags: [tags.frontend] },
+    { sourceTag: tags.shared, notDependOnLibsWithTags: [tags.frontend, tags.backend] }
+  ];
+}
+var SCOPE_CONSTRAINTS = scopeConstraints();
 var ESLINT_CONFIG_CANDIDATES = ["eslint.config.mjs", "eslint.config.js", "eslint.config.cjs"];
-var APPLIED_MARKER = "sourceTag: 'scope:frontend'";
+var appliedMarker = (tags) => `sourceTag: '${tags.frontend}'`;
 var ALLOW_ALL_BLOCK = /depConstraints:\s*\[\s*\{\s*sourceTag:\s*'\*',\s*onlyDependOnLibsWithTags:\s*\[\s*'\*'\s*\],?\s*\},?\s*\]/g;
 function maskComments(text) {
   const out = text.split("");
@@ -106,17 +119,17 @@ function findAllowAllMatches(masked) {
   }
   return matches;
 }
-function classifyBoundaryConstraints(configText) {
+function classifyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
   const masked = maskComments(configText);
-  if (masked.includes(APPLIED_MARKER))
+  if (masked.includes(appliedMarker(tags)))
     return "enforced";
   if (findAllowAllMatches(masked).length > 0)
     return "allow-all";
   return "unknown";
 }
-function renderConstraintsBlock(indent, eol) {
-  const renderList = (tags) => tags.map((t) => `'${t}'`).join(", ");
-  const inner = SCOPE_CONSTRAINTS.map((c) => {
+function renderConstraintsBlock(indent, eol, tags) {
+  const renderList = (list) => list.map((t) => `'${t}'`).join(", ");
+  const inner = scopeConstraints(tags).map((c) => {
     const field = c.notDependOnLibsWithTags ? `notDependOnLibsWithTags: [${renderList(c.notDependOnLibsWithTags)}]` : `onlyDependOnLibsWithTags: [${renderList(c.onlyDependOnLibsWithTags ?? [])}]`;
     return [`${indent}  {`, `${indent}    sourceTag: '${c.sourceTag}',`, `${indent}    ${field},`, `${indent}  },`].join(eol);
   }).join(eol);
@@ -134,8 +147,8 @@ function renderConstraintsBlock(indent, eol) {
     `${indent}]`
   ].join(eol);
 }
-function applyBoundaryConstraints(configText) {
-  const classification = classifyBoundaryConstraints(configText);
+function applyBoundaryConstraints(configText, tags = DEFAULT_BOUNDARY_TAGS) {
+  const classification = classifyBoundaryConstraints(configText, tags);
   if (classification === "enforced")
     return { status: "already-applied" };
   if (classification === "unknown")
@@ -149,17 +162,17 @@ function applyBoundaryConstraints(configText) {
   const eol = configText.includes("\r\n") ? "\r\n" : "\n";
   const lineStart = configText.lastIndexOf("\n", match.index) + 1;
   const indent = /^[ \t]*/.exec(configText.slice(lineStart, match.index))?.[0] ?? "";
-  const replacement = renderConstraintsBlock(indent, eol);
+  const replacement = renderConstraintsBlock(indent, eol, tags);
   const text = configText.slice(0, match.index) + replacement + configText.slice(match.index + match.length);
   return { status: "applied", text };
 }
-function buildBoundarySnippet() {
+function buildBoundarySnippet(tags = DEFAULT_BOUNDARY_TAGS) {
   return [
     "// nx-archweave project boundaries \u2014 merge these entries into the depConstraints",
     "// array of the '@nx/enforce-module-boundaries' rule in your root ESLint config.",
     "// They ride on top of your existing entries: constraints apply conjunctively,",
     "// so the allow-all baseline can stay.",
-    renderConstraintsBlock("", "\n")
+    renderConstraintsBlock("", "\n", tags)
   ].join("\n");
 }
 
@@ -179,7 +192,7 @@ function sharedTypesApiTypesContent() {
     ""
   ].join("\n");
 }
-function sharedTypesPackageJsonContent(packageName) {
+function sharedTypesPackageJsonContent(packageName, sharedTag = "scope:shared") {
   return `${JSON.stringify({
     name: packageName,
     version: "0.0.1",
@@ -196,7 +209,7 @@ function sharedTypesPackageJsonContent(packageName) {
     },
     nx: {
       projectType: "library",
-      tags: ["scope:shared"],
+      tags: [sharedTag],
       targets: {}
     }
   }, null, 2)}
@@ -204,21 +217,36 @@ function sharedTypesPackageJsonContent(packageName) {
 }
 
 // ../template-engine/dist/backend/compose-backend-wiring.js
+var DEFAULT_SHARED_TYPES_ROOT = "libs/shared-types";
+function readSharedTypesConfig(config) {
+  const value = config?.["sharedTypes"];
+  if (value === false)
+    return false;
+  if (typeof value !== "object" || value === null)
+    return { path: DEFAULT_SHARED_TYPES_ROOT };
+  const record = value;
+  const path = typeof record["path"] === "string" && record["path"].trim() !== "" ? record["path"].replace(/\/+$/, "") : DEFAULT_SHARED_TYPES_ROOT;
+  const importPath = typeof record["importPath"] === "string" && record["importPath"].trim() !== "" ? record["importPath"] : void 0;
+  return importPath === void 0 ? { path } : { path, importPath };
+}
 function composeBackendWiring(input) {
   const scoped = /^@([^/]+)\//.exec(input.workspaceName);
   const scope = scoped ? `@${scoped[1]}` : `@${input.workspaceName.split("/").pop() || "workspace"}`;
-  const sharedTypesPackageName = `${scope}/shared-types`;
+  const sharedTypesRoot = input.sharedTypes?.path ?? DEFAULT_SHARED_TYPES_ROOT;
+  const sharedTypesPackageName = input.sharedTypes?.importPath ?? `${scope}/shared-types`;
+  const tagByRole = input.tags ?? DEFAULT_BOUNDARY_TAGS;
   return {
     sharedTypesFiles: [
-      { filePath: "libs/shared-types/package.json", content: sharedTypesPackageJsonContent(sharedTypesPackageName) },
-      { filePath: "libs/shared-types/src/index.ts", content: sharedTypesIndexContent() },
-      { filePath: "libs/shared-types/src/lib/api-types.ts", content: sharedTypesApiTypesContent() }
+      { filePath: `${sharedTypesRoot}/package.json`, content: sharedTypesPackageJsonContent(sharedTypesPackageName, tagByRole.shared) },
+      { filePath: `${sharedTypesRoot}/src/index.ts`, content: sharedTypesIndexContent() },
+      { filePath: `${sharedTypesRoot}/src/lib/api-types.ts`, content: sharedTypesApiTypesContent() }
     ],
     sharedTypesPackageName,
-    tagByRole: { frontend: "scope:frontend", backend: "scope:backend", shared: "scope:shared" }
+    sharedTypesRoot,
+    tagByRole
   };
 }
-function addSharedTypesNpmWorkspace(packageJsonText) {
+function addSharedTypesNpmWorkspace(packageJsonText, entry = DEFAULT_SHARED_TYPES_ROOT) {
   let parsed;
   try {
     parsed = JSON.parse(packageJsonText);
@@ -239,19 +267,19 @@ function addSharedTypesNpmWorkspace(packageJsonText) {
   } else {
     return { status: "unrecognized" };
   }
-  if (target.some((entry) => entry === "libs/shared-types" || entry === "libs/*"))
+  const parentGlob = `${entry.split("/").slice(0, -1).join("/")}/*`;
+  if (target.some((existing) => existing === entry || existing === parentGlob))
     return { status: "present" };
-  const surgical = insertSharedTypesWorkspace(packageJsonText, field === void 0 ? "absent" : Array.isArray(field) ? "array" : "object");
+  const surgical = insertSharedTypesWorkspace(packageJsonText, field === void 0 ? "absent" : Array.isArray(field) ? "array" : "object", JSON.stringify(entry));
   if (surgical !== null)
     return { status: "added", text: surgical };
   if (field === void 0)
     pkg["workspaces"] = target;
-  target.push("libs/shared-types");
+  target.push(entry);
   const indent = /\n([ \t]+)"/.exec(packageJsonText)?.[1] ?? "  ";
   const trailing = packageJsonText.endsWith("\n") ? "\n" : "";
   return { status: "added", text: `${JSON.stringify(pkg, null, indent)}${trailing}` };
 }
-var SHARED_TYPES_ENTRY = '"libs/shared-types"';
 function skipJsonValue(text, start) {
   if (text[start] === '"') {
     let i = start + 1;
@@ -309,20 +337,20 @@ function objectMembers(text, open) {
     i = valueEnd;
   }
 }
-function appendToArray(text, open, close, eol) {
+function appendToArray(text, open, close, eol, quoted) {
   const inner = text.slice(open + 1, close - 1);
   if (inner.trim() === "")
-    return `${text.slice(0, open + 1)}${SHARED_TYPES_ENTRY}${text.slice(close - 1)}`;
+    return `${text.slice(0, open + 1)}${quoted}${text.slice(close - 1)}`;
   if (!inner.includes("\n")) {
     const body = inner.replace(/\s+$/, "");
-    return `${text.slice(0, open + 1)}${body}, ${SHARED_TYPES_ENTRY}${inner.slice(body.length)}${text.slice(close - 1)}`;
+    return `${text.slice(0, open + 1)}${body}, ${quoted}${inner.slice(body.length)}${text.slice(close - 1)}`;
   }
   const lastEntryLineStart = text.lastIndexOf("\n", open + 1 + inner.trimEnd().length - 1) + 1;
   const itemIndent = /^[ \t]*/.exec(text.slice(lastEntryLineStart))?.[0] ?? "  ";
   const bodyEnd = open + 1 + inner.trimEnd().length;
-  return `${text.slice(0, bodyEnd)},${eol}${itemIndent}${SHARED_TYPES_ENTRY}${text.slice(bodyEnd)}`;
+  return `${text.slice(0, bodyEnd)},${eol}${itemIndent}${quoted}${text.slice(bodyEnd)}`;
 }
-function insertSharedTypesWorkspace(text, form) {
+function insertSharedTypesWorkspace(text, form, quoted) {
   const eol = text.includes("\r\n") ? "\r\n" : "\n";
   const rootOpen = text.indexOf("{");
   if (rootOpen === -1)
@@ -336,26 +364,28 @@ function insertSharedTypesWorkspace(text, form) {
     const indent = /\n([ \t]+)"/.exec(text)?.[1] ?? "  ";
     if (last === void 0) {
       const close = skipJsonValue(text, rootOpen) - 1;
-      return `${text.slice(0, rootOpen + 1)}${eol}${indent}"workspaces": [${SHARED_TYPES_ENTRY}]${eol}${text.slice(close)}`;
+      return `${text.slice(0, rootOpen + 1)}${eol}${indent}"workspaces": [${quoted}]${eol}${text.slice(close)}`;
     }
-    return `${text.slice(0, last.valueEnd)},${eol}${indent}"workspaces": [${SHARED_TYPES_ENTRY}]${text.slice(last.valueEnd)}`;
+    return `${text.slice(0, last.valueEnd)},${eol}${indent}"workspaces": [${quoted}]${text.slice(last.valueEnd)}`;
   }
   if (workspaces === void 0)
     return null;
   if (form === "array") {
     if (text[workspaces.valueStart] !== "[")
       return null;
-    return appendToArray(text, workspaces.valueStart, workspaces.valueEnd, eol);
+    return appendToArray(text, workspaces.valueStart, workspaces.valueEnd, eol, quoted);
   }
   if (text[workspaces.valueStart] !== "{")
     return null;
   const packages = objectMembers(text, workspaces.valueStart)?.find((member) => member.key === "packages");
   if (packages === void 0 || text[packages.valueStart] !== "[")
     return null;
-  return appendToArray(text, packages.valueStart, packages.valueEnd, eol);
+  return appendToArray(text, packages.valueStart, packages.valueEnd, eol, quoted);
 }
-function addSharedTypesWorkspaceGlob(yamlText) {
-  if (/^\s*-\s*['"]?(libs\/shared-types|libs\/\*)['"]?\s*$/m.test(yamlText)) {
+function addSharedTypesWorkspaceGlob(yamlText, entry = DEFAULT_SHARED_TYPES_ROOT) {
+  const escape = (value) => value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+  const parentGlob = `${entry.split("/").slice(0, -1).join("/")}/*`;
+  if (new RegExp(`^\\s*-\\s*['"]?(${escape(entry)}|${escape(parentGlob)})['"]?\\s*$`, "m").test(yamlText)) {
     return { status: "present" };
   }
   const lines = yamlText.split("\n");
@@ -375,7 +405,7 @@ function addSharedTypesWorkspaceGlob(yamlText) {
   if (lastEntry === packagesIndex)
     return { status: "unrecognized" };
   const indent = /^(\s+)-/.exec(lines[lastEntry])?.[1] ?? "  ";
-  lines.splice(lastEntry + 1, 0, `${indent}- 'libs/shared-types'`);
+  lines.splice(lastEntry + 1, 0, `${indent}- '${entry}'`);
   return { status: "added", text: lines.join("\n") };
 }
 
@@ -384,8 +414,933 @@ function resolveDryRun(options) {
   return process.env["NX_DRY_RUN"] === "true" || (options.dryRun ?? false);
 }
 
-// src/generators/shared/toolkit-config-file.ts
-var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: void 0 };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return void 0;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return void 0;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return void 0;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return void 0;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parseTree2 = parseTree;
+var findNodeAtLocation2 = findNodeAtLocation;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/generators/shared/json-edit.ts
 function detectIndent(raw) {
   for (const line of raw.split("\n")) {
     const match = /^(\t+| +)/.exec(line);
@@ -393,6 +1348,98 @@ function detectIndent(raw) {
   }
   return "  ";
 }
+function styleOf(raw) {
+  return { eol: raw.includes("\r\n") ? "\r\n" : "\n", unit: detectIndent(raw) };
+}
+function lineIndentAt(raw, offset) {
+  const lineStart = raw.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(raw.slice(lineStart))?.[0] ?? "";
+}
+function isMultiline(raw, node) {
+  return raw.slice(node.offset, node.offset + node.length).includes("\n");
+}
+function isPrimitive(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function renderValue(value, indent, style) {
+  if (isPrimitive(value)) return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (value.every(isPrimitive)) return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+    const inner2 = `${indent}${style.unit}`;
+    return `[${style.eol}${value.map((item) => `${inner2}${renderValue(item, inner2, style)}`).join(`,${style.eol}`)}${style.eol}${indent}]`;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
+  const inner = `${indent}${style.unit}`;
+  const body = entries.map(([key, item]) => `${inner}${JSON.stringify(key)}: ${renderValue(item, inner, style)}`).join(`,${style.eol}`);
+  return `{${style.eol}${body}${style.eol}${indent}}`;
+}
+function splice(raw, start, end, text) {
+  return raw.slice(0, start) + text + raw.slice(end);
+}
+function nest(keys, value) {
+  return keys.reduceRight((inner, key) => ({ [key]: inner }), value);
+}
+function insertProperty(raw, object, key, value, style) {
+  const properties = object.children ?? [];
+  const objectIndent = lineIndentAt(raw, object.offset);
+  if (properties.length === 0) {
+    const inner = `${objectIndent}${style.unit}`;
+    const text = `{${style.eol}${inner}${JSON.stringify(String(key))}: ${renderValue(value, inner, style)}${style.eol}${objectIndent}}`;
+    return splice(raw, object.offset, object.offset + object.length, text);
+  }
+  const last = properties[properties.length - 1];
+  const end = last.offset + last.length;
+  if (!isMultiline(raw, object)) {
+    return splice(raw, end, end, `, ${JSON.stringify(String(key))}: ${renderValue(value, "", style)}`);
+  }
+  const indent = lineIndentAt(raw, last.offset);
+  return splice(raw, end, end, `,${style.eol}${indent}${JSON.stringify(String(key))}: ${renderValue(value, indent, style)}`);
+}
+function setJsonValue(raw, path, value) {
+  const style = styleOf(raw);
+  const root = parseTree2(raw);
+  if (root === void 0) throw new Error("setJsonValue: not a JSON document");
+  const existing = findNodeAtLocation2(root, path);
+  if (existing !== void 0) {
+    return splice(raw, existing.offset, existing.offset + existing.length, renderValue(value, lineIndentAt(raw, existing.offset), style));
+  }
+  for (let depth = path.length - 1; depth >= 0; depth--) {
+    const parent = depth === 0 ? root : findNodeAtLocation2(root, path.slice(0, depth));
+    if (parent === void 0) continue;
+    if (parent.type !== "object") throw new Error(`setJsonValue: ${path.slice(0, depth).join(".") || "the root"} is not an object`);
+    return insertProperty(raw, parent, path[depth], nest(path.slice(depth + 1), value), style);
+  }
+  throw new Error("setJsonValue: unreachable");
+}
+function appendJsonArrayItem(raw, path, item) {
+  const style = styleOf(raw);
+  const root = parseTree2(raw);
+  const array = root === void 0 ? void 0 : findNodeAtLocation2(root, path);
+  if (array === void 0) return setJsonValue(raw, path, [item]);
+  if (array.type !== "array") throw new Error(`appendJsonArrayItem: ${path.join(".")} is not an array`);
+  const items = array.children ?? [];
+  if (items.length === 0) return splice(raw, array.offset, array.offset + array.length, renderValue([item], "", style));
+  const last = items[items.length - 1];
+  const end = last.offset + last.length;
+  if (!isMultiline(raw, array)) {
+    const separator = items.length >= 2 ? raw.slice(items[0].offset + items[0].length, items[1].offset) : ", ";
+    return splice(raw, end, end, `${separator}${renderValue(item, "", style)}`);
+  }
+  const indent = lineIndentAt(raw, last.offset);
+  return splice(raw, end, end, `,${style.eol}${indent}${renderValue(item, indent, style)}`);
+}
+function applyJsonEdits(raw, edits) {
+  if (raw === null) {
+    let text = "{}\n";
+    for (const [path, value] of edits) text = setJsonValue(text, path, value);
+    return text;
+  }
+  return edits.reduce((text, [path, value]) => setJsonValue(text, path, value), raw);
+}
+
+// src/generators/shared/toolkit-config-file.ts
+var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
 function readToolkitConfigFile(tree) {
   const raw = tree.read(TOOLKIT_CONFIG_PATH, "utf-8");
   if (raw === null) return { raw: null, parsed: null };
@@ -480,8 +1527,9 @@ function renderAddBackendBody(report) {
   }
   if (report.packageManagerNote !== void 0) lines.push(`  note: ${report.packageManagerNote}`);
   lines.push(`  frontend project: ${report.frontendProject ?? "none (backend-only workspace)"}`);
+  const libPath = report.sharedTypesRoot ?? "libs/shared-types";
   lines.push(
-    report.sharedTypes === "created" ? `  libs/shared-types: created (import it as ${report.sharedTypesPackage})` : "  libs/shared-types: already exists \u2014 skipped"
+    report.sharedTypes === "created" ? `  ${libPath}: created (import it as ${report.sharedTypesPackage})` : report.sharedTypes === "disabled" ? "  shared-types lib: none (sharedTypes: false in toolkit.config.json)" : `  ${libPath}: already exists \u2014 skipped`
   );
   if (report.config !== void 0 && report.config !== "unchanged") {
     lines.push(`  toolkit.config.json: backend "${report.backend}" recorded (${report.config}) \u2014 doctor's backend checks now run`);
@@ -491,11 +1539,11 @@ function renderAddBackendBody(report) {
     const registry = packageManagerCommands(pmName).workspaceRegistration;
     lines.push(
       {
-        added: `  ${registry}: 'libs/shared-types' registered \u2014 run \`${pmName} install\` once to link it`,
-        present: `  ${registry}: already covers libs/shared-types`,
+        added: `  ${registry}: '${libPath}' registered \u2014 run \`${pmName} install\` once to link it`,
+        present: `  ${registry}: already covers ${libPath}`,
         unrecognized: (
           // an integrated layout lists no workspace packages: the paths alias below links it
-          report.tsconfigPaths === "added" || report.tsconfigPaths === "present" ? `  ${registry}: no workspace package list (integrated layout) \u2014 the tsconfig paths alias links libs/shared-types` : `  ${registry}: shape not recognized \u2014 add 'libs/shared-types' to its workspace list yourself`
+          report.tsconfigPaths === "added" || report.tsconfigPaths === "present" ? `  ${registry}: no workspace package list (integrated layout) \u2014 the tsconfig paths alias links ${libPath}` : `  ${registry}: shape not recognized \u2014 add '${libPath}' to its workspace list yourself`
         )
       }[report.workspaceGlob]
     );
@@ -508,7 +1556,8 @@ function renderAddBackendBody(report) {
       added: `  tsconfig.base.json paths: ${report.sharedTypesPackage} added (a classic or integrated setup \u2014 libs resolve through paths)`,
       present: "  tsconfig.base.json paths: already wired",
       "workspace-link": "  tsconfig paths: not needed \u2014 the workspace package link is the wiring",
-      unrecognized: "  tsconfig.base.json: could not be parsed \u2014 left untouched"
+      unrecognized: "  tsconfig.base.json: could not be parsed \u2014 left untouched",
+      none: "  tsconfig paths: nothing to wire (no shared-types lib)"
     }[report.tsconfigPaths]
   );
   switch (report.eslint) {
@@ -538,7 +1587,6 @@ function renderAddBackendReport(report, dryRun) {
 }
 
 // src/generators/add-backend/generator.ts
-var SHARED_TYPES_ROOT = "libs/shared-types";
 function runAddBackend(tree, options) {
   const backend = options.backend;
   const apiName = options.apiName ?? "api";
@@ -613,8 +1661,9 @@ function runAddBackend(tree, options) {
       } catch {
       }
     }
-    const frontendParent = (projects.get(frontendProject)?.root ?? "").split("/").slice(0, -1).join("/");
-    const apiDirectory = `${frontendParent === "" || frontendParent === "." ? "apps" : frontendParent}/${apiName}`;
+    const frontendRoot = projects.get(frontendProject)?.root ?? "";
+    const frontendParent = frontendRoot.split("/").slice(0, -1).join("/");
+    const apiDirectory = frontendRoot === "" || frontendRoot === "." ? `apps/${apiName}` : `${frontendParent === "" ? "" : `${frontendParent}/`}${apiName}`;
     const expressAlignment = backend === "express" && !expressDeclared ? readExpressPeerRange(tree) : void 0;
     const quotedExpress = expressAlignment ? `"express@${expressAlignment}"` : void 0;
     return {
@@ -630,16 +1679,21 @@ function runAddBackend(tree, options) {
       ...refusalShape
     };
   }
-  const sharedTypesExists = tree.exists(`${SHARED_TYPES_ROOT}/package.json`) || tree.exists(`${SHARED_TYPES_ROOT}/project.json`);
+  const recordedConfig = readToolkitConfigFile(tree).parsed;
+  const boundaryTags = readBoundaryTags(recordedConfig);
+  const sharedTypesConfig = readSharedTypesConfig(recordedConfig);
+  const withSharedTypes = sharedTypesConfig !== false;
+  const sharedTypesRoot = sharedTypesConfig === false ? "" : sharedTypesConfig.path;
+  const sharedTypesExists = withSharedTypes && (tree.exists(`${sharedTypesRoot}/package.json`) || tree.exists(`${sharedTypesRoot}/project.json`));
   const rootPackageJson = tree.read("package.json", "utf-8");
   const workspaceName = rootPackageJson ? JSON.parse(rootPackageJson).name ?? "workspace" : "workspace";
-  const wiring = composeBackendWiring({ workspaceName });
+  const wiring = composeBackendWiring({ workspaceName, tags: boundaryTags, ...sharedTypesConfig === false ? {} : { sharedTypes: sharedTypesConfig } });
   const [apiProjectName, apiConfig] = apiEntry;
   const tagTargets = [
     ...frontendProject === void 0 ? [] : [{ project: frontendProject, root: projects.get(frontendProject)?.root ?? `apps/${frontendProject}` }],
     { project: apiProjectName, root: apiConfig.root }
   ];
-  if (sharedTypesExists) tagTargets.push({ project: wiring.sharedTypesPackageName, root: SHARED_TYPES_ROOT });
+  if (sharedTypesExists) tagTargets.push({ project: wiring.sharedTypesPackageName, root: sharedTypesRoot });
   const parsedTargets = /* @__PURE__ */ new Map();
   const invalidProjects = [];
   for (const target of tagTargets) {
@@ -661,7 +1715,7 @@ function runAddBackend(tree, options) {
   if (invalidProjects.length > 0) {
     return { ...base, refused: "invalid-project-json", frontendProject, invalidProjects, ...refusalShape };
   }
-  const sharedTypes = sharedTypesExists ? "skipped" : "created";
+  const sharedTypes = !withSharedTypes ? "disabled" : sharedTypesExists ? "skipped" : "created";
   if (sharedTypes === "created" && write) {
     for (const file of wiring.sharedTypesFiles) tree.write(file.filePath, file.content);
   }
@@ -672,20 +1726,19 @@ function runAddBackend(tree, options) {
     const existing = configParsed ?? {};
     if (parseOk && existing["backend"] !== backend) {
       configOutcome = configRaw === null ? "created" : "updated";
-      const indent = configRaw === null ? "  " : detectIndent(configRaw);
-      if (write) tree.write(TOOLKIT_CONFIG_PATH, `${JSON.stringify({ ...existing, backend }, null, indent)}
-`);
+      if (write) tree.write(TOOLKIT_CONFIG_PATH, applyJsonEdits(configRaw, [[["backend"], backend]]));
     }
   }
-  let workspaceGlob = "unrecognized";
-  const workspaceYaml = tree.read("pnpm-workspace.yaml", "utf-8");
-  if (workspaceYaml !== null) {
-    const globResult = addSharedTypesWorkspaceGlob(workspaceYaml);
+  let workspaceGlob = withSharedTypes ? "unrecognized" : void 0;
+  const workspaceYaml = withSharedTypes ? tree.read("pnpm-workspace.yaml", "utf-8") : null;
+  if (!withSharedTypes) {
+  } else if (workspaceYaml !== null) {
+    const globResult = addSharedTypesWorkspaceGlob(workspaceYaml, sharedTypesRoot);
     workspaceGlob = globResult.status;
     if (globResult.status === "added" && write) tree.write("pnpm-workspace.yaml", globResult.text);
   } else if ((detectedPm === "npm" || detectedPm === "yarn" || detectedPm === "bun") && rootPackageJson !== null) {
     const yarnNeedsPrivate = detectedPm === "yarn" && JSON.parse(rootPackageJson).private !== true;
-    const npmResult = yarnNeedsPrivate ? { status: "unrecognized" } : addSharedTypesNpmWorkspace(rootPackageJson);
+    const npmResult = yarnNeedsPrivate ? { status: "unrecognized" } : addSharedTypesNpmWorkspace(rootPackageJson, sharedTypesRoot);
     workspaceGlob = npmResult.status;
     if (npmResult.status === "added" && write) tree.write("package.json", npmResult.text);
   }
@@ -696,17 +1749,17 @@ function runAddBackend(tree, options) {
     const tags2 = holder.tags ?? [];
     if (tags2.includes(tag)) return { project, action: "present" };
     holder.tags = [...tags2, tag];
-    if (write) tree.write(target.path, `${JSON.stringify(target.parsed, null, detectIndent(target.raw))}
-`);
+    target.raw = appendJsonArrayItem(target.raw, target.kind === "project" ? ["tags"] : ["nx", "tags"], tag);
+    if (write) tree.write(target.path, target.raw);
     return { project, action: "added" };
   };
   const tags = [
     ...frontendProject === void 0 ? [] : [mergeTag(frontendProject, wiring.tagByRole.frontend)],
     mergeTag(apiProjectName, wiring.tagByRole.backend),
-    mergeTag(wiring.sharedTypesPackageName, wiring.tagByRole.shared)
+    ...withSharedTypes ? [mergeTag(wiring.sharedTypesPackageName, wiring.tagByRole.shared)] : []
   ];
-  let tsconfigPaths = "workspace-link";
-  const tsconfigRaw = tree.read("tsconfig.base.json", "utf-8");
+  let tsconfigPaths = withSharedTypes ? "workspace-link" : "none";
+  const tsconfigRaw = withSharedTypes ? tree.read("tsconfig.base.json", "utf-8") : null;
   if (tsconfigRaw !== null) {
     try {
       const tsconfig = JSON.parse(tsconfigRaw);
@@ -717,10 +1770,8 @@ function runAddBackend(tree, options) {
           tsconfigPaths = "present";
         } else {
           tsconfigPaths = "added";
-          paths[wiring.sharedTypesPackageName] = [`${baseUrl ? "" : "./"}${SHARED_TYPES_ROOT}/src/index.ts`];
-          tsconfig.compilerOptions.paths = paths;
-          if (write) tree.write("tsconfig.base.json", `${JSON.stringify(tsconfig, null, detectIndent(tsconfigRaw))}
-`);
+          const entry = [`${baseUrl ? "" : "./"}${sharedTypesRoot}/src/index.ts`];
+          if (write) tree.write("tsconfig.base.json", setJsonValue(tsconfigRaw, ["compilerOptions", "paths", wiring.sharedTypesPackageName], entry));
         }
       }
     } catch {
@@ -731,11 +1782,11 @@ function runAddBackend(tree, options) {
   let snippet;
   if (!applyEslint) {
     eslint = "snippet-only";
-    snippet = buildBoundarySnippet();
+    snippet = buildBoundarySnippet(boundaryTags);
   } else {
     const configPath = ESLINT_CONFIG_CANDIDATES.find((candidate) => tree.exists(candidate));
     const configText = configPath ? tree.read(configPath, "utf-8") : null;
-    const result = configText !== null ? applyBoundaryConstraints(configText) : { status: "unrecognized" };
+    const result = configText !== null ? applyBoundaryConstraints(configText, boundaryTags) : { status: "unrecognized" };
     if (result.status === "applied") {
       eslint = "applied";
       if (write && configPath) tree.write(configPath, result.text);
@@ -743,7 +1794,7 @@ function runAddBackend(tree, options) {
       eslint = "already-applied";
     } else {
       eslint = "degraded-unrecognized";
-      snippet = buildBoundarySnippet();
+      snippet = buildBoundarySnippet(boundaryTags);
     }
   }
   return {
@@ -755,7 +1806,8 @@ function runAddBackend(tree, options) {
     tsconfigPaths,
     eslint,
     snippet,
-    sharedTypesPackage: wiring.sharedTypesPackageName,
+    sharedTypesPackage: withSharedTypes ? wiring.sharedTypesPackageName : void 0,
+    sharedTypesRoot: withSharedTypes ? sharedTypesRoot : void 0,
     config: configOutcome,
     packageManager,
     ...packageManagerNote !== void 0 ? { packageManagerNote } : {}