@3fn/core 14.0.0 → 15.0.0

package/dist/mcp/product-mcp.js

@@ -29,6 +29,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -2981,7 +2982,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -3008,7 +3009,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3639,7 +3640,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3897,7 +3898,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -6916,12 +6917,12 @@ var require_resolvePackageRoot = __commonJS({
       isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
       mod
     ));
-    var __toCommonJS = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var resolvePackageRoot_exports = {};
     __export2(resolvePackageRoot_exports, {
       resolvePackageRoot: () => resolvePackageRoot2
     });
-    module2.exports = __toCommonJS(resolvePackageRoot_exports);
+    module2.exports = __toCommonJS2(resolvePackageRoot_exports);
     var path7 = __toESM3(require("path"));
     var fs8 = __toESM3(require("fs"));
     function resolvePackageRoot2(fromDir) {
@@ -6967,14 +6968,17 @@ var require_mcpDataRoots = __commonJS({
       isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
       mod
     ));
-    var __toCommonJS = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var mcpDataRoots_exports = {};
     __export2(mcpDataRoots_exports, {
+      resolveComponentRoots: () => resolveComponentRoots,
       resolveConsumerOwnedRoot: () => resolveConsumerOwnedRoot,
       resolvePackageOwnedRoot: () => resolvePackageOwnedRoot,
-      resolvePackageRoot: () => import_resolvePackageRoot.resolvePackageRoot
+      resolvePackageRoot: () => import_resolvePackageRoot.resolvePackageRoot,
+      resolveProductRoot: () => resolveProductRoot,
+      resolveTokenIndexRoot: () => resolveTokenIndexRoot
     });
-    module2.exports = __toCommonJS(mcpDataRoots_exports);
+    module2.exports = __toCommonJS2(mcpDataRoots_exports);
     var path7 = __toESM3(require("path"));
     var fs8 = __toESM3(require("fs"));
     var import_resolvePackageRoot = require_resolvePackageRoot();
@@ -7008,10 +7012,412 @@ var require_mcpDataRoots = __commonJS({
         return false;
       }
     }
+    function isAbsentOrEmptyDir(p) {
+      try {
+        const stat = fs8.statSync(p);
+        if (stat.isDirectory()) {
+          return fs8.readdirSync(p).length === 0;
+        }
+        return false;
+      } catch {
+        return true;
+      }
+    }
+    function resolveComponentRoots(opts) {
+      const roots = [];
+      const sources = [];
+      if (opts.envValue) {
+        roots.push(path7.resolve(opts.envValue));
+        sources.push("env");
+      } else if (opts.dsRoot.state === "born" && opts.dsRoot.root) {
+        roots.push(path7.join(opts.dsRoot.root, "src", "components"));
+        sources.push("cwd");
+      }
+      roots.push(path7.resolve(opts.packageRoot, "src", "components", "core"));
+      sources.push("package");
+      return { roots, sources };
+    }
+    function resolveTokenIndexRoot(opts) {
+      if (opts.envValue !== void 0) {
+        if (opts.envValue === "") {
+          return { ok: false, reason: "empty-env-value" };
+        }
+        const resolved = path7.resolve(opts.envValue);
+        if (isAbsentOrEmptyDir(resolved)) {
+          return { ok: false, reason: "empty-env-value" };
+        }
+        return { ok: true, path: resolved, source: "env" };
+      }
+      switch (opts.dsRoot.state) {
+        case "born": {
+          const indexPath = path7.join(opts.dsRoot.root, "token-index");
+          if (isAbsentOrEmptyDir(indexPath)) return { ok: false, reason: "run-generate" };
+          return { ok: true, path: indexPath, source: "cwd" };
+        }
+        case "package-mode": {
+          const indexPath = path7.join(opts.dsRoot.root, "token-index");
+          if (isAbsentOrEmptyDir(indexPath)) return { ok: false, reason: "run-generate" };
+          return { ok: true, path: indexPath, source: "cwd", tokenOrigin: "designerpunk-package-mode" };
+        }
+        case "partial":
+          return { ok: false, reason: "partial", partialCase: opts.dsRoot.partialCase };
+        case "unborn":
+        default:
+          return {
+            ok: true,
+            path: path7.resolve(opts.packageRoot, "token-index"),
+            source: "package-consume",
+            tokenOrigin: "designerpunk-reference"
+          };
+      }
+    }
+    function resolveProductRoot(opts) {
+      if (opts.envValue) {
+        return { path: path7.resolve(opts.envValue), source: "env" };
+      }
+      if (opts.dsRoot.state !== "unborn" && opts.dsRoot.root) {
+        return { path: path7.join(opts.dsRoot.root, "product"), source: "cwd" };
+      }
+      return { path: path7.resolve(opts.cwd, "product"), source: "cwd" };
+    }
+  }
+});
+
+// dist/cli/shared/bornRepo.js
+var require_bornRepo = __commonJS({
+  "dist/cli/shared/bornRepo.js"(exports2, module2) {
+    "use strict";
+    var __create3 = Object.create;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __getProtoOf3 = Object.getPrototypeOf;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp3(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps3 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps3(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var bornRepo_exports = {};
+    __export2(bornRepo_exports, {
+      findDesignSystemRoot: () => findDesignSystemRoot,
+      isDesignerPunkTier: () => isDesignerPunkTier
+    });
+    module2.exports = __toCommonJS2(bornRepo_exports);
+    var path7 = __toESM3(require("path"));
+    var fs8 = __toESM3(require("fs"));
+    var import_resolvePackageRoot = require_resolvePackageRoot();
+    var CONFIG_FILE = "designerpunk.config.ts";
+    var MANIFEST_FILE = "designerpunk.manifest.json";
+    var LEGACY_MANIFEST_RELPATH = path7.join(".kiro", "sync-manifest.json");
+    var TOKEN_SOURCE_RELPATH = path7.join("src", "tokens");
+    var GIT_MARKER = ".git";
+    function hasNodeModulesSegment(dir) {
+      return dir.split(path7.sep).includes("node_modules");
+    }
+    function isGitBoundary(dir) {
+      return fs8.existsSync(path7.join(dir, GIT_MARKER));
+    }
+    function exportsTextually(source, exportName) {
+      const escaped = exportName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const functionForm = new RegExp(`export\\s+(?:async\\s+)?function\\s*\\*?\\s*${escaped}\\b`);
+      const constLetForm = new RegExp(`export\\s+(?:const|let)\\s+${escaped}\\b`);
+      const reExportForm = new RegExp(`export\\s*\\{[^}]*\\b${escaped}\\b[^}]*\\}\\s*from\\s*['"\`]`);
+      return functionForm.test(source) || constLetForm.test(source) || reExportForm.test(source);
+    }
+    function readFileTextSafe(filePath) {
+      try {
+        const text = fs8.readFileSync(filePath, "utf8");
+        return typeof text === "string" ? text : null;
+      } catch {
+        return null;
+      }
+    }
+    function isDesignerPunkTier(dir) {
+      const indexText = readFileTextSafe(path7.join(dir, "index.ts"));
+      if (indexText === null || !exportsTextually(indexText, "getAllPrimitiveTokens")) return false;
+      const semanticIndexText = readFileTextSafe(path7.join(dir, "semantic", "index.ts"));
+      if (semanticIndexText === null || !exportsTextually(semanticIndexText, "getAllSemanticTokens")) return false;
+      return true;
+    }
+    function readConfigTokenSource(configPath) {
+      const text = readFileTextSafe(configPath);
+      if (text === null) return { present: false };
+      const uncommented = text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
+      const literalMatch = uncommented.match(/\btokenSource\s*:\s*['"`]([^'"`]+)['"`]/);
+      if (literalMatch) return { present: true, literal: true, value: literalMatch[1] };
+      if (/\btokenSource\s*:/.test(uncommented)) return { present: true, literal: false };
+      return { present: false };
+    }
+    function readManifestPosture(manifestPath) {
+      const text = readFileTextSafe(manifestPath);
+      if (text === null) return null;
+      try {
+        const parsed = JSON.parse(text);
+        return typeof parsed.posture === "string" ? parsed.posture : null;
+      } catch {
+        return null;
+      }
+    }
+    function evaluateDirectory(dir, packageRoot) {
+      const configPath = path7.join(dir, CONFIG_FILE);
+      const hasConfig = fs8.existsSync(configPath);
+      const tokenSourceRead = hasConfig ? readConfigTokenSource(configPath) : { present: false };
+      const hasTokenSource = tokenSourceRead.present;
+      const localTierDir = path7.join(dir, TOKEN_SOURCE_RELPATH);
+      const localBarrelIsTier = isDesignerPunkTier(localTierDir);
+      const tokenSourceRoot = tokenSourceRead.present && tokenSourceRead.literal ? path7.resolve(dir, tokenSourceRead.value) : null;
+      const tierPresentAtTokenSource = tokenSourceRoot !== null && isDesignerPunkTier(tokenSourceRoot);
+      const packageOwnedTierDir = path7.resolve(packageRoot, TOKEN_SOURCE_RELPATH);
+      const manifestPath = path7.join(dir, MANIFEST_FILE);
+      const manifestExists = fs8.existsSync(manifestPath);
+      const manifestPosture = manifestExists ? readManifestPosture(manifestPath) : null;
+      const manifestSignal = manifestExists && manifestPosture !== "consume";
+      const legacyManifestSignal = fs8.existsSync(path7.join(dir, LEGACY_MANIFEST_RELPATH));
+      const isSteward = path7.resolve(dir) === path7.resolve(packageRoot);
+      let state;
+      let partialCase;
+      let tierDir = null;
+      if (hasConfig && hasTokenSource) {
+        if (tierPresentAtTokenSource) {
+          state = "born";
+          tierDir = tokenSourceRoot;
+        } else {
+          state = "partial";
+          partialCase = "config-no-tier";
+        }
+      } else if (hasConfig) {
+        if (localBarrelIsTier && !isSteward) {
+          state = "partial";
+          partialCase = "unused-local-tier";
+        } else {
+          state = "package-mode";
+          tierDir = packageOwnedTierDir;
+        }
+      } else if (localBarrelIsTier) {
+        state = "partial";
+        partialCase = "tier-no-config";
+      } else if (manifestSignal) {
+        state = "partial";
+        partialCase = "manifest-only";
+      } else {
+        state = "unborn";
+      }
+      const anySignal = hasConfig || localBarrelIsTier || manifestSignal;
+      const tierSignal = localBarrelIsTier || tierPresentAtTokenSource;
+      const attemptedTokenSource = partialCase === "config-no-tier" && tokenSourceRoot !== null ? tokenSourceRoot : void 0;
+      return {
+        anySignal,
+        state,
+        partialCase,
+        tierDir,
+        attemptedTokenSource,
+        signals: {
+          config: hasConfig,
+          tier: tierSignal,
+          manifest: manifestSignal,
+          legacyManifest: legacyManifestSignal
+        }
+      };
+    }
+    function resolveOwnPackageRoot() {
+      let dir = __dirname;
+      while (true) {
+        if (fs8.existsSync(path7.join(dir, "package.json"))) return dir;
+        const parent = path7.dirname(dir);
+        if (parent === dir) return (0, import_resolvePackageRoot.resolvePackageRoot)(path7.dirname(__dirname));
+        dir = parent;
+      }
+    }
+    var UNBORN_RESULT = {
+      state: "unborn",
+      root: null,
+      tierDir: null,
+      signals: { config: false, tier: false, manifest: false, legacyManifest: false }
+    };
+    function findDesignSystemRoot(startDir) {
+      const packageRoot = resolveOwnPackageRoot();
+      let dir = path7.resolve(startDir);
+      while (true) {
+        if (!hasNodeModulesSegment(dir)) {
+          const evaluation = evaluateDirectory(dir, packageRoot);
+          if (evaluation.anySignal) {
+            return {
+              state: evaluation.state,
+              root: dir,
+              tierDir: evaluation.tierDir,
+              partialCase: evaluation.partialCase,
+              attemptedTokenSource: evaluation.attemptedTokenSource,
+              signals: evaluation.signals
+            };
+          }
+        }
+        if (isGitBoundary(dir)) {
+          break;
+        }
+        const parent = path7.dirname(dir);
+        if (parent === dir) {
+          break;
+        }
+        dir = parent;
+      }
+      return UNBORN_RESULT;
+    }
+  }
+});
+
+// dist/cli/shared/errorCatalog.js
+var require_errorCatalog = __commonJS({
+  "dist/cli/shared/errorCatalog.js"(exports2, module2) {
+    "use strict";
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp3(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps3 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var errorCatalog_exports = {};
+    __export2(errorCatalog_exports, {
+      attachUnbornRepoMessage: () => attachUnbornRepoMessage,
+      bornIndexAbsentMessage: () => bornIndexAbsentMessage,
+      cloneHatchMessage: () => cloneHatchMessage,
+      componentTokenFamilyMismatchMessage: () => componentTokenFamilyMismatchMessage,
+      componentTokenFileLoadFailedMessage: () => componentTokenFileLoadFailedMessage,
+      consumerDegradationMessage: () => consumerDegradationMessage,
+      existingMcpEntryMessage: () => existingMcpEntryMessage,
+      explicitTokenIndexMissingMessage: () => explicitTokenIndexMissingMessage,
+      initBornRepoMessage: () => initBornRepoMessage,
+      jestConfigCollisionMessage: () => jestConfigCollisionMessage,
+      managedRegionEditedInsideMessage: () => managedRegionEditedInsideMessage,
+      managedRegionMarkersMissingMessage: () => managedRegionMarkersMissingMessage,
+      packageModeIndexAbsentMessage: () => packageModeIndexAbsentMessage,
+      partialCaseMessage: () => partialCaseMessage,
+      partialConfigNoTierMessage: () => partialConfigNoTierMessage,
+      partialManifestOnlyMessage: () => partialManifestOnlyMessage,
+      partialTierNoConfigMessage: () => partialTierNoConfigMessage,
+      partialUnusedLocalTierMessage: () => partialUnusedLocalTierMessage,
+      personalNoteNamingMessage: () => personalNoteNamingMessage,
+      restartLineNowMessage: () => restartLineNowMessage,
+      restartLineSequencedMessage: () => restartLineSequencedMessage
+    });
+    module2.exports = __toCommonJS2(errorCatalog_exports);
+    function partialConfigNoTierMessage(root, tokenSource) {
+      const tokenSourceSlot = tokenSource ?? "(a non-literal tokenSource value in designerpunk.config.ts)";
+      return `found designerpunk.config.ts at ${root} but no DesignerPunk token tier at ${tokenSourceSlot} \u2014 this repo looks partly initialized. Refusing rather than guessing. Inspect it, or complete it deliberately: npx designerpunk init --re-scaffold`;
+    }
+    function partialUnusedLocalTierMessage(root) {
+      return `found a token tier at ${root}/src/tokens but your config omits tokenSource, so generate would use DesignerPunk's tokens, not yours. Add tokenSource: './src/tokens' to designerpunk.config.ts. (Refusing to generate until then.)`;
+    }
+    function partialTierNoConfigMessage(root) {
+      return `found a DesignerPunk token tier at ${root}/src/tokens but no designerpunk.config.ts \u2014 refusing to generate or serve DesignerPunk's reference index as yours. Restore the config, or run: npx designerpunk init --re-scaffold`;
+    }
+    function partialManifestOnlyMessage(root) {
+      return `found designerpunk.manifest.json at ${root} but no config or token tier \u2014 the design system files are missing. Restore them from version control, or run: npx designerpunk init --re-scaffold`;
+    }
+    function partialCaseMessage(root, partialCase, attemptedTokenSource) {
+      switch (partialCase) {
+        case "config-no-tier":
+          return partialConfigNoTierMessage(root, attemptedTokenSource);
+        case "unused-local-tier":
+          return partialUnusedLocalTierMessage(root);
+        case "tier-no-config":
+          return partialTierNoConfigMessage(root);
+        case "manifest-only":
+          return partialManifestOnlyMessage(root);
+      }
+    }
+    function packageModeIndexAbsentMessage() {
+      return `this repo runs in package mode (designerpunk.config.ts has no tokenSource), so its token index is DesignerPunk's tokens \u2014 run 'npx designerpunk generate' to build it. To make a design system of your own: npx designerpunk init --re-scaffold`;
+    }
+    function bornIndexAbsentMessage(root) {
+      return `no token index in this design system (${root}/token-index is absent or empty) \u2014 run 'npx designerpunk generate'`;
+    }
+    function explicitTokenIndexMissingMessage(explicitPath) {
+      return `TOKEN_INDEX_DIR is set to ${explicitPath}, which is absent or empty \u2014 unset it, or run generate`;
+    }
+    function initBornRepoMessage(root) {
+      return `this repo already has a design system (${root}) \u2014 init is the birth event and runs once. To join it: npm install \u2192 npx designerpunk generate \u2192 fill in .designerpunk/personal-note.local.md (generate creates it) \u2192 restart your agent session (approve DesignerPunk's MCP servers if asked). Using a different agent tool than this repo was set up for? Also run: npx designerpunk attach --target=<cc|kiro> to attach a harness (agents + MCP config + approvals). To deliberately re-scaffold: npx designerpunk init --re-scaffold`;
+    }
+    function restartLineSequencedMessage() {
+      return `when the steps above are done, restart your agent session \u2014 DesignerPunk's MCP servers and your personal note load when a session starts, so this session cannot see them yet (approve the servers if your tool asks)`;
+    }
+    function cloneHatchMessage() {
+      return `want to own the engine too? Clone github.com/3fn/DesignerPunk \u2014 init already made the token language yours; the clone adds the engine and the components`;
+    }
+    function personalNoteNamingMessage() {
+      return `fill in .designerpunk/personal-note.local.md \u2014 who you are and how you want to be worked with; your agents read it every session (it stays on your machine)`;
+    }
+    function jestConfigCollisionMessage() {
+      return `skipped: jest.config.js (already exists) \u2014 the DesignerPunk jest preset is not applied; to test your own forked components with @3fn/core/testing, add ...require('@3fn/core/jest-preset') to your config`;
+    }
+    function consumerDegradationMessage(member, where, consequence) {
+      return `warning: ${member} is missing from the installed @3fn/core (${where}) \u2014 ${consequence}. Generation continued without it. If a clean reinstall (remove node_modules, then npm install) does not restore it, the package you installed does not contain it.`;
+    }
+    function managedRegionMarkersMissingMessage(file2) {
+      return `the DesignerPunk-managed region in ${file2} is missing its markers \u2014 not rewriting the file. Restore the markers (see install doc \xA7 "Your agent layer") or re-run attach`;
+    }
+    function managedRegionEditedInsideMessage(file2) {
+      return `you edited inside the DesignerPunk-managed region of ${file2} \u2014 those edits will be replaced. Move them outside the region; not applying without --apply`;
+    }
+    function attachUnbornRepoMessage() {
+      return `no design system here. To create one: npx designerpunk init. Only reading DesignerPunk's docs and components? No init needed: npx designerpunk attach --target=<cc|kiro> --reference`;
+    }
+    function restartLineNowMessage() {
+      return `restart your agent session now \u2014 DesignerPunk's MCP servers load when a session starts, so this session cannot see them yet (approve them if your tool asks)`;
+    }
+    function existingMcpEntryMessage(configFile, key, target) {
+      return `${configFile} already has '${key}' entry; left unchanged. If it is outdated, delete the entry and re-run: npx designerpunk attach --target=${target} \u2014 or update it by hand.`;
+    }
+    function componentTokenFamilyMismatchMessage(file2, guardMessage) {
+      let alternative = "";
+      if (file2.startsWith("src/tokens/")) {
+        alternative = ` Or, if an earlier DesignerPunk init copied this file, replace it with the package's version at node_modules/@3fn/core/${file2} and change its '../../build/tokens' import to '@3fn/core/build'.`;
+      } else if (file2.startsWith("src/components/core/")) {
+        alternative = ` Or, if this is an unedited copy an earlier DesignerPunk init made, delete it \u2014 its component tokens then leave your generated ComponentTokens.* files.`;
+      }
+      return `generate stopped \u2014 ${file2} declares a component token in the wrong family's defineComponentTokens() call. ${guardMessage} To fix it, split that file's defineComponentTokens() into one call per token family.${alternative} Nothing was written.`;
+    }
+    function componentTokenFileLoadFailedMessage(file2, reason) {
+      const firstLine = reason.split(/\r?\n/, 1)[0].trim();
+      return `generate stopped \u2014 ${file2} could not be loaded: ${firstLine} Fix the file and run generate again. Nothing was written.`;
+    }
   }
 });
 
 // product-mcp-server/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  resolveTokenIndexUnavailableMessage: () => resolveTokenIndexUnavailableMessage,
+  tools: () => tools
+});
+module.exports = __toCommonJS(index_exports);
 var fs7 = __toESM(require("fs"));
 
 // node_modules/zod/v3/helpers/util.js
@@ -19800,7 +20206,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -19817,7 +20223,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -19895,7 +20301,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -20156,12 +20562,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -21031,12 +21437,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -23507,26 +23913,66 @@ var ReverseIndexBuilder = class {
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 var SERVER_NAME2 = "mcp-product-server";
+var LEGACY_LEVEL_DIR = "core";
+var META_FILE = "component-meta.yaml";
+function normalizeRoots(componentDirs) {
+  const list = Array.isArray(componentDirs) ? componentDirs : [componentDirs];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of list) {
+    if (!r) continue;
+    const abs = path2.resolve(r);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    out.push(abs);
+  }
+  return out;
+}
 var GapDetector = class {
-  constructor(componentDir, oneOffNames) {
+  /**
+   * @param componentDirs the component root set in precedence order (consumer first,
+   *   package last), or a single root (legacy form).
+   */
+  constructor(componentDirs, oneOffNames) {
     this.catalog = /* @__PURE__ */ new Set();
-    this.componentDir = componentDir;
+    this.componentRoots = normalizeRoots(componentDirs);
     this.oneOffNames = oneOffNames;
   }
-  /** Read component-meta.yaml files from componentDir and build name catalog. */
+  /**
+   * Read component-meta.yaml files across the root set and build the name catalog (the union).
+   * Gap detection is disabled only when NO root exists; a missing lower- or higher-precedence
+   * root alongside an existing one is normal (e.g. an unborn repo has no consumer root).
+   */
   loadCatalog() {
     this.catalog.clear();
-    if (!fs2.existsSync(this.componentDir)) {
+    const existing = this.componentRoots.filter((r) => fs2.existsSync(r));
+    if (existing.length === 0) {
       console.error(
-        `[${SERVER_NAME2}] Component directory not found: ${this.componentDir} \u2014 gap detection disabled`
+        `[${SERVER_NAME2}] Component directory not found: ${this.componentRoots.join(", ")} \u2014 gap detection disabled`
       );
       return;
     }
-    for (const entry of fs2.readdirSync(this.componentDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const metaPath = path2.join(this.componentDir, entry.name, "component-meta.yaml");
-      if (fs2.existsSync(metaPath)) {
-        this.catalog.add(entry.name);
+    const rootSet = new Set(this.componentRoots);
+    for (const root of existing) {
+      for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const dirPath = path2.join(root, entry.name);
+        if (entry.name === LEGACY_LEVEL_DIR) {
+          if (rootSet.has(dirPath)) continue;
+          if (!this.isComponentDir(dirPath)) {
+            const nested = this.componentChildren(dirPath);
+            if (nested.length > 0) {
+              console.error(
+                `[${SERVER_NAME2}] Legacy component level: ${dirPath} holds ${nested.length} component(s) in the pre-123 'core/' layout \u2014 counted for gap detection; move them up to ${root}`
+              );
+              for (const name of nested) this.catalog.add(name);
+              continue;
+            }
+          }
+        }
+        if (this.isComponentDir(dirPath)) {
+          this.catalog.add(entry.name);
+        }
       }
     }
   }
@@ -23539,6 +23985,13 @@ var GapDetector = class {
   getCatalogSize() {
     return this.catalog.size;
   }
+  /** A component directory is recognized by its component-meta.yaml. */
+  isComponentDir(dirPath) {
+    return fs2.existsSync(path2.join(dirPath, META_FILE));
+  }
+  componentChildren(dirPath) {
+    return fs2.readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory() && this.isComponentDir(path2.join(dirPath, d.name))).map((d) => d.name);
+  }
 };
 
 // product-mcp-server/src/indexer/ProductTokenIndexer.ts
@@ -24420,26 +24873,31 @@ var filterSchema = {
 var tools = [
   {
     name: "get_product_overview",
+    annotations: { readOnlyHint: true },
     description: "Get product context, configuration, and principles.",
     inputSchema: { type: "object", properties: {} }
   },
   {
     name: "get_brand_context",
+    annotations: { readOnlyHint: true },
     description: 'Get product brand identity: personality, voice, tone, anti-references, register. Returns structured "not configured" response if brand fields are absent.',
     inputSchema: { type: "object", properties: {} }
   },
   {
     name: "find_screens",
+    annotations: { readOnlyHint: true },
     description: "Find screens by component usage, token usage, domain object usage, status, platform, or context. All filters are conjunctive (AND). No params returns all screens.",
     inputSchema: { type: "object", properties: filterSchema }
   },
   {
     name: "list_experience_map",
+    annotations: { readOnlyHint: true },
     description: "List experience map entries with referenced components, domain objects, and blocked reasons. Supports same filters as find_screens.",
     inputSchema: { type: "object", properties: filterSchema }
   },
   {
     name: "get_screen_spec",
+    annotations: { readOnlyHint: true },
     description: "Get full spec for a screen (UI tree, state model, data sources, accessibility, status). Includes _componentGaps for unmatched components. Optional platform filter.",
     inputSchema: {
       type: "object",
@@ -24452,6 +24910,7 @@ var tools = [
   },
   {
     name: "get_screen_state_model",
+    annotations: { readOnlyHint: true },
     description: "Get just the state model of a screen (data, states, actions, transitions) without the full spec.",
     inputSchema: {
       type: "object",
@@ -24463,6 +24922,7 @@ var tools = [
   },
   {
     name: "get_product_component",
+    annotations: { readOnlyHint: true },
     description: "Get a product-specific (one-off) component by name \u2014 schema, contracts, and composition details.",
     inputSchema: {
       type: "object",
@@ -24474,6 +24934,7 @@ var tools = [
   },
   {
     name: "get_domain_object",
+    annotations: { readOnlyHint: true },
     description: "Get domain object definition and list of screens that reference it.",
     inputSchema: {
       type: "object",
@@ -24485,6 +24946,7 @@ var tools = [
   },
   {
     name: "find_principles",
+    annotations: { readOnlyHint: true },
     description: "Find design principles by keyword.",
     inputSchema: {
       type: "object",
@@ -24496,6 +24958,7 @@ var tools = [
   },
   {
     name: "find_templates",
+    annotations: { readOnlyHint: true },
     description: "Find product templates by category or by which screen uses them.",
     inputSchema: {
       type: "object",
@@ -24507,16 +24970,19 @@ var tools = [
   },
   {
     name: "list_product_templates",
+    annotations: { readOnlyHint: true },
     description: "List all product-specific layout and content patterns.",
     inputSchema: { type: "object", properties: {} }
   },
   {
     name: "get_product_health",
+    annotations: { readOnlyHint: true },
     description: "Get index status, data counts, reverse index sizes, gap counts, and warnings.",
     inputSchema: { type: "object", properties: {} }
   },
   {
     name: "get_product_tokens",
+    annotations: { readOnlyHint: true },
     description: "Get product tokens by category, name, or platform. Returns structured values with resolved system token references. All filters optional and conjunctive.",
     inputSchema: {
       type: "object",
@@ -24530,6 +24996,7 @@ var tools = [
   },
   {
     name: "rebuild_product_index",
+    annotations: { readOnlyHint: false },
     description: "Re-index all product data. Returns new health status.",
     inputSchema: { type: "object", properties: {} }
   }
@@ -24801,6 +25268,16 @@ var ProductMCPServer = class {
     }
   }
 };
+function resolveTokenIndexUnavailableMessage(reason, dsRoot, packageRoot, errorCatalog, explicitTokenIndexDirEnv) {
+  switch (reason) {
+    case "empty-env-value":
+      return errorCatalog.explicitTokenIndexMissingMessage(explicitTokenIndexDirEnv ?? "");
+    case "run-generate":
+      return dsRoot.state === "package-mode" ? errorCatalog.packageModeIndexAbsentMessage() : errorCatalog.bornIndexAbsentMessage(dsRoot.root ?? packageRoot);
+    case "partial":
+      return dsRoot.partialCase ? errorCatalog.partialCaseMessage(dsRoot.root ?? packageRoot, dsRoot.partialCase, dsRoot.attemptedTokenSource) : `token index unavailable: partial state with no named sub-case`;
+  }
+}
 if (require.main === module) {
   const logRoot = (label, root, note = "") => {
     console.error(`[${SERVER_NAME4}] Data root ${label}: ${root.path} (source: ${root.source})${note}`);
@@ -24810,31 +25287,47 @@ if (require.main === module) {
   let tokenIndexDir = process.env.TOKEN_INDEX_DIR || DEFAULT_TOKEN_INDEX_DIR;
   try {
     const shared = require_mcpDataRoots();
+    const bornRepo = require_bornRepo();
+    const errorCatalog = require_errorCatalog();
     const packageRoot = shared.resolvePackageRoot(__dirname);
-    const product = shared.resolveConsumerOwnedRoot({
+    const dsRoot = bornRepo.findDesignSystemRoot(process.cwd());
+    const product = shared.resolveProductRoot({
       envValue: process.env.PRODUCT_DIR,
-      relPath: DEFAULT_PRODUCT_DIR
+      dsRoot,
+      cwd: process.cwd()
     });
-    const component = shared.resolveConsumerOwnedRoot({
+    const componentRoots = shared.resolveComponentRoots({
       envValue: process.env.COMPONENT_DIR,
-      relPath: DEFAULT_COMPONENT_DIR,
+      dsRoot,
       packageRoot
     });
-    const tokenIndex = shared.resolveConsumerOwnedRoot({
+    const tokenIndex = shared.resolveTokenIndexRoot({
       envValue: process.env.TOKEN_INDEX_DIR,
-      relPath: DEFAULT_TOKEN_INDEX_DIR,
+      dsRoot,
       packageRoot
     });
+    console.error(`[${SERVER_NAME4}] Design-system root: ${dsRoot.state}${dsRoot.partialCase ? ` (${dsRoot.partialCase})` : ""}`);
     logRoot("product", product);
-    logRoot("components", component);
-    logRoot(
-      "token-index",
-      tokenIndex,
-      tokenIndex.source === "package" ? " \u2014 package token snapshot in use; if this project customizes tokens, run 'npx designerpunk generate' to build a local token-index" : ""
-    );
+    componentRoots.roots.forEach((r, i) => logRoot(`components[${i}]`, { path: r, source: componentRoots.sources[i] }));
+    if (tokenIndex.ok) {
+      logRoot(
+        "token-index",
+        { path: tokenIndex.path, source: tokenIndex.source },
+        tokenIndex.tokenOrigin ? ` (tokenOrigin: ${tokenIndex.tokenOrigin})` : ""
+      );
+    } else {
+      const message = resolveTokenIndexUnavailableMessage(
+        tokenIndex.reason,
+        dsRoot,
+        packageRoot,
+        errorCatalog,
+        process.env.TOKEN_INDEX_DIR
+      );
+      console.error(`[${SERVER_NAME4}] ${message}`);
+    }
     productDir = product.path;
-    componentDir = component.path;
-    tokenIndexDir = tokenIndex.path;
+    componentDir = componentRoots.roots;
+    tokenIndexDir = tokenIndex.ok ? tokenIndex.path : DEFAULT_TOKEN_INDEX_DIR;
   } catch {
     console.error(
       `[${SERVER_NAME4}] WARNING: shared data-root resolution unavailable (root dist not built?) \u2014 using legacy env/cwd-relative defaults`
@@ -24846,6 +25339,11 @@ if (require.main === module) {
     process.exit(1);
   });
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveTokenIndexUnavailableMessage,
+  tools
+});
 /*! Bundled license information:
 
 js-yaml/dist/js-yaml.mjs: