@3fn/core 14.0.0 → 15.0.0

package/dist/cli/loadComponentTokens.js

@@ -56,7 +56,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentTokenFileLoadError = void 0;
 exports.loadComponentTokens = loadComponentTokens;
+exports.harvestZeroWarning = harvestZeroWarning;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const scopedTsRequire_1 = require("../config/scopedTsRequire");
@@ -85,21 +87,33 @@ function loadComponentTokens(config, loadModule = scopedTsRequire_1.scopedTsRequ
     // order; per-branded-array authored order). Deduped by token `name` across modules.
     const harvested = [];
     const seenNames = new Set();
+    // Harvest-zero lint instrumentation (Spec 123 C11, Req 8). `brandedCountByFile` records
+    // a per-file branded-export count — incremented independent of `seenNames`'s cross-module
+    // dedupe, so a fully branded file whose token names were already harvested from an
+    // earlier-scanned module still counts non-zero (Req 8.1, Lina R2's false-positive fix:
+    // "harvests zero net tokens" is NOT the trigger; "exports no branded value" is).
+    // `scannedTokenFiles` records every file matching the `tokens.ts` / `*.tokens.ts` naming
+    // convention the lint targets, from either discovery source.
+    const brandedCountByFile = new Map();
+    const scannedTokenFiles = new Set();
     // Source 1: Auto-discover from {tokenSourceRoot}/component/
     const componentSubdir = path.join(config.tokenSourceRoot, 'component');
     if (fs.existsSync(componentSubdir)) {
         const files = fs.readdirSync(componentSubdir)
             .filter(f => f.endsWith('.ts') && !f.endsWith('.test.ts') && !f.endsWith('.d.ts'));
         for (const file of files) {
-            const mod = loadModule(path.join(componentSubdir, file), __filename);
-            harvestModule(mod, harvested, seenNames);
+            const fullPath = path.join(componentSubdir, file);
+            if (isTokenFileName(file))
+                scannedTokenFiles.add(fullPath);
+            const mod = loadTokenModule(loadModule, fullPath);
+            harvestModule(mod, harvested, seenNames, fullPath, brandedCountByFile);
         }
     }
     // Source 2: Explicit componentTokens directories (*.tokens.ts / tokens.ts pattern)
     for (const dir of config.componentTokenDirs) {
         if (!fs.existsSync(dir))
             continue;
-        scanForTokenFiles(dir, loadModule, harvested, seenNames);
+        scanForTokenFiles(dir, loadModule, harvested, seenNames, scannedTokenFiles, brandedCountByFile);
     }
     // Sole writer to the canonical registry (Spec 124, R5 AC2), in traversal order so that
     // ComponentTokenRegistry.getAll() (Map-insertion order) feeds generateTokenIndex in the
@@ -107,8 +121,68 @@ function loadComponentTokens(config, loadModule = scopedTsRequire_1.scopedTsRequ
     for (const token of harvested) {
         ComponentTokenRegistry_1.ComponentTokenRegistry.register(token);
     }
+    // The harvest-zero lint (Spec 123 C11, Req 8): a `tokens.ts` / `*.tokens.ts` file that
+    // exported no `defineComponentTokens`-branded value very likely wears the wrong
+    // filename — a plain semantic-reference map, not a value-registration file (124's
+    // authoring-convention seed, Lina's Q8 call). Reuses the SAME brand signal the harvest
+    // above already computed (Req 8.2 — no second detection mechanism). A warning, never an
+    // error: `generate` still runs (Req 8.1; Task 5's migration report promises this).
+    for (const file of scannedTokenFiles) {
+        if ((brandedCountByFile.get(file) ?? 0) === 0) {
+            console.warn(harvestZeroWarning(file));
+        }
+    }
     return ComponentTokenRegistry_1.ComponentTokenRegistry.getAll();
 }
+/**
+ * A component-token module threw while it loaded — most often `defineComponentTokens`'s
+ * own guard (e.g. the family-mismatch guard, #127) rejecting a call at module scope.
+ * Carries the FILE, which the guard's message does not name (it names the component), so
+ * `generate` can report the file in a catalogued message instead of escaping to the CLI's
+ * "Unexpected error" stack trace (`.kiro/issues/2026-10-02-generate-stack-trace-on-component-token-family-mismatch.md`).
+ * `name` is set explicitly so callers may recognise it without `instanceof`.
+ */
+class ComponentTokenFileLoadError extends Error {
+    constructor(file, reason) {
+        super(`component-token file ${file} failed to load: ${reason}`);
+        this.name = 'ComponentTokenFileLoadError';
+        this.file = file;
+        this.reason = reason;
+    }
+}
+exports.ComponentTokenFileLoadError = ComponentTokenFileLoadError;
+/** Load one component-token module; a throw during load is rethrown as {@link ComponentTokenFileLoadError} naming the file. */
+function loadTokenModule(loadModule, fullPath) {
+    try {
+        return loadModule(fullPath, __filename);
+    }
+    catch (err) {
+        throw new ComponentTokenFileLoadError(fullPath, err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * True for a filename matching the `tokens.ts` / `*.tokens.ts` naming convention the
+ * harvest-zero lint (C11, Req 8) targets — the convention 124's authoring-convention seed
+ * names as worn by two mechanisms (value-registration files and plain semantic-reference
+ * maps).
+ */
+function isTokenFileName(name) {
+    return name === 'tokens.ts' || name.endsWith('.tokens.ts');
+}
+/**
+ * The harvest-zero lint's warning message (Spec 123 C11, Req 8).
+ *
+ * NOTE: design.md's C11 entry is "Unchanged" and carries no exact-string catalog row for
+ * this warning (unlike most 123 catalog strings elsewhere in the spec). This wording
+ * follows design-outline.md § 4.5's proposed phrasing as closely as an implementation
+ * string can: *"this scanned file harvested zero component tokens; if you meant to
+ * register values, call `defineComponentTokens`"* (Lina, R1). Flagged for a Thurgood
+ * erratum to add the row to design.md's catalog rather than leaving this the sole source
+ * of truth for the string.
+ */
+function harvestZeroWarning(file) {
+    return `⚠️  ${file}: this scanned file harvested zero component tokens; if you meant to register values, call \`defineComponentTokens\`.`;
+}
 /**
  * Harvest branded `defineComponentTokens` results from a single loaded module's exports.
  *
@@ -119,7 +193,7 @@ function loadComponentTokens(config, loadModule = scopedTsRequire_1.scopedTsRequ
  * module), and a token `name` already harvested from any module is skipped (first-seen
  * wins) so a re-export alias never moves or duplicates an entry.
  */
-function harvestModule(mod, harvested, seenNames) {
+function harvestModule(mod, harvested, seenNames, file, brandedCountByFile) {
     if (mod == null || typeof mod !== 'object')
         return;
     const seenObjects = new Set();
@@ -133,6 +207,10 @@ function harvestModule(mod, harvested, seenNames) {
         if (!tokens)
             continue;
         seenObjects.add(exported);
+        // Harvest-zero lint instrumentation (Req 8.2): recorded here, per distinct branded
+        // object, BEFORE the cross-module name dedupe below — so this file's branded status
+        // never depends on whether another module already harvested the same token names.
+        brandedCountByFile.set(file, (brandedCountByFile.get(file) ?? 0) + 1);
         for (const token of tokens) {
             // First-seen-wins across modules (a genuine duplicate name is caught by the
             // registry's conflict throw at write time).
@@ -147,16 +225,17 @@ function harvestModule(mod, harvested, seenNames) {
  * Recursively scan a directory for *.tokens.ts / tokens.ts files, load each through the
  * injected runtime-TS resolution seam, and harvest branded results in scan order.
  */
-function scanForTokenFiles(dir, loadModule, harvested, seenNames) {
+function scanForTokenFiles(dir, loadModule, harvested, seenNames, scannedTokenFiles, brandedCountByFile) {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory() && entry.name !== '__tests__' && entry.name !== 'node_modules') {
-            scanForTokenFiles(fullPath, loadModule, harvested, seenNames);
+            scanForTokenFiles(fullPath, loadModule, harvested, seenNames, scannedTokenFiles, brandedCountByFile);
         }
         else if (entry.isFile() && (entry.name.endsWith('.tokens.ts') || entry.name === 'tokens.ts') && !entry.name.endsWith('.test.ts')) {
-            const mod = loadModule(fullPath, __filename);
-            harvestModule(mod, harvested, seenNames);
+            scannedTokenFiles.add(fullPath);
+            const mod = loadTokenModule(loadModule, fullPath);
+            harvestModule(mod, harvested, seenNames, fullPath, brandedCountByFile);
         }
     }
 }

package/dist/cli/shared/bornRepo.d.ts

@@ -0,0 +1,50 @@
+/** The four birth states a directory walk can resolve to. */
+export type BirthState = 'born' | 'package-mode' | 'partial' | 'unborn';
+/** Named sub-cases of `partial` (C2). */
+export type PartialCase = 'config-no-tier' | 'unused-local-tier' | 'tier-no-config' | 'manifest-only';
+/** The result of walking up from a start directory looking for a DesignerPunk root. */
+export interface DesignSystemRoot {
+    state: BirthState;
+    /** The anchoring directory; `null` iff unborn. */
+    root: string | null;
+    /** The LIVE tier, resolved exactly as ConfigLoader resolves it (Ada D2-B1); `null` iff no tier is live. */
+    tierDir: string | null;
+    partialCase?: PartialCase;
+    /**
+     * `config-no-tier` ONLY: the resolved absolute path the config's `tokenSource` names,
+     * where no DesignerPunk tier was found — the `<tokenSource>` slot in that partial
+     * case's catalog string (Task 1.6). `undefined` when `tokenSource` was present but
+     * non-literal (Peter, 2026-09-26) — we cannot resolve a path we never read.
+     */
+    attemptedTokenSource?: string;
+    signals: {
+        config: boolean;
+        tier: boolean;
+        manifest: boolean;
+        legacyManifest: boolean;
+    };
+}
+/**
+ * True iff `dir` is a DesignerPunk-shaped tier: `index.ts` textually exports
+ * `getAllPrimitiveTokens`, AND `semantic/index.ts` textually exports
+ * `getAllSemanticTokens` (C2). Read without loading — see this module's header.
+ */
+export declare function isDesignerPunkTier(dir: string): boolean;
+/**
+ * Walk up from `startDir` looking for a DesignerPunk root (C2/C3).
+ *
+ * Every caller passes `process.cwd()` of the invoking process — never `__dirname`,
+ * never a package root. Spawned MCP servers inherit it: `spawnServer` passes no
+ * `cwd` option (see `designerpunk.ts`), so `process.cwd()` there is whatever the
+ * launching harness set, and that absence is load-bearing.
+ *
+ * At EACH level: signals are tested FIRST, then the walk checks for a stop. This
+ * means the repo root, where `.git` and the config live together, IS tested before
+ * the walk would otherwise stop. Any directory with a `node_modules` path segment
+ * is skipped as a candidate (never classified), which is what keeps
+ * `node_modules/@3fn/core/` — itself born-shaped — from ever being the root.
+ *
+ * @param startDir - The directory to start the walk from (see note above).
+ */
+export declare function findDesignSystemRoot(startDir: string): DesignSystemRoot;
+//# sourceMappingURL=bornRepo.d.ts.map

package/dist/cli/shared/bornRepo.js

@@ -0,0 +1,199 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bornRepo_exports = {};
+__export(bornRepo_exports, {
+  findDesignSystemRoot: () => findDesignSystemRoot,
+  isDesignerPunkTier: () => isDesignerPunkTier
+});
+module.exports = __toCommonJS(bornRepo_exports);
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var import_resolvePackageRoot = require("./resolvePackageRoot");
+const CONFIG_FILE = "designerpunk.config.ts";
+const MANIFEST_FILE = "designerpunk.manifest.json";
+const LEGACY_MANIFEST_RELPATH = path.join(".kiro", "sync-manifest.json");
+const TOKEN_SOURCE_RELPATH = path.join("src", "tokens");
+const GIT_MARKER = ".git";
+function hasNodeModulesSegment(dir) {
+  return dir.split(path.sep).includes("node_modules");
+}
+function isGitBoundary(dir) {
+  return fs.existsSync(path.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 = fs.readFileSync(filePath, "utf8");
+    return typeof text === "string" ? text : null;
+  } catch {
+    return null;
+  }
+}
+function isDesignerPunkTier(dir) {
+  const indexText = readFileTextSafe(path.join(dir, "index.ts"));
+  if (indexText === null || !exportsTextually(indexText, "getAllPrimitiveTokens")) return false;
+  const semanticIndexText = readFileTextSafe(path.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 = path.join(dir, CONFIG_FILE);
+  const hasConfig = fs.existsSync(configPath);
+  const tokenSourceRead = hasConfig ? readConfigTokenSource(configPath) : { present: false };
+  const hasTokenSource = tokenSourceRead.present;
+  const localTierDir = path.join(dir, TOKEN_SOURCE_RELPATH);
+  const localBarrelIsTier = isDesignerPunkTier(localTierDir);
+  const tokenSourceRoot = tokenSourceRead.present && tokenSourceRead.literal ? path.resolve(dir, tokenSourceRead.value) : null;
+  const tierPresentAtTokenSource = tokenSourceRoot !== null && isDesignerPunkTier(tokenSourceRoot);
+  const packageOwnedTierDir = path.resolve(packageRoot, TOKEN_SOURCE_RELPATH);
+  const manifestPath = path.join(dir, MANIFEST_FILE);
+  const manifestExists = fs.existsSync(manifestPath);
+  const manifestPosture = manifestExists ? readManifestPosture(manifestPath) : null;
+  const manifestSignal = manifestExists && manifestPosture !== "consume";
+  const legacyManifestSignal = fs.existsSync(path.join(dir, LEGACY_MANIFEST_RELPATH));
+  const isSteward = path.resolve(dir) === path.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 (fs.existsSync(path.join(dir, "package.json"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return (0, import_resolvePackageRoot.resolvePackageRoot)(path.dirname(__dirname));
+    dir = parent;
+  }
+}
+const 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 = path.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 = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return UNBORN_RESULT;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findDesignSystemRoot,
+  isDesignerPunkTier
+});
+//# sourceMappingURL=bornRepo.js.map

package/dist/cli/shared/errorCatalog.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The loud-failure catalog — exact strings (Spec 123, design.md § "Error Handling —
+ * the loud-failure catalog (exact strings)"). ONE source for every birth-detection-
+ * related refusal/status message, consumed by `generate`'s refusals (Task 1.5) and
+ * the MCP servers' unavailable/refusal logging (Task 1.6) — a single copy so the
+ * two call sites can never drift (the project's named recurring failure mode).
+ *
+ * Every function here returns EXACTLY the design's catalog string with its `<…>`
+ * slots filled — no paraphrasing, no added punctuation. The Task 1.6 conformance
+ * test asserts string equality against these rows.
+ */
+import type { PartialCase } from './bornRepo';
+/** design.md catalog row: `partial: config-no-tier`. */
+export declare function partialConfigNoTierMessage(root: string, tokenSource: string | undefined): string;
+/** design.md catalog row: `partial: unused-local-tier`. */
+export declare function partialUnusedLocalTierMessage(root: string): string;
+/** design.md catalog row: `partial: tier-no-config`. */
+export declare function partialTierNoConfigMessage(root: string): string;
+/** design.md catalog row: `partial: manifest-only`. */
+export declare function partialManifestOnlyMessage(root: string): string;
+/** Dispatch to the right partial-case message (all four sub-cases). */
+export declare function partialCaseMessage(root: string, partialCase: PartialCase, attemptedTokenSource: string | undefined): string;
+/** design.md catalog row: `package-mode posture (D2-B1; no longer partial), index absent or empty`. */
+export declare function packageModeIndexAbsentMessage(): string;
+/** design.md catalog row: `born, token index absent or empty`. */
+export declare function bornIndexAbsentMessage(root: string): string;
+/** design.md catalog row: `explicit TOKEN_INDEX_DIR missing`. */
+export declare function explicitTokenIndexMissingMessage(explicitPath: string): string;
+/** design.md catalog row: `init` in a born repo (A7). */
+export declare function initBornRepoMessage(root: string): string;
+/**
+ * design.md catalog row: **restart line — sequenced** (erratum, Le-T1 + Le-T5).
+ * `init` and born-repo `attach` output; printed LAST, as the final next step.
+ */
+export declare function restartLineSequencedMessage(): string;
+/** design.md catalog row: **clone hatch** (erratum, Le-T1; `init` output). */
+export declare function cloneHatchMessage(): string;
+/** design.md catalog row: **personal-note naming** (erratum, Le-T1; `init` output). */
+export declare function personalNoteNamingMessage(): string;
+/**
+ * design.md § C27 (A13): the truthful `jest.config.js` collision string — states
+ * the CONSEQUENCE of the skip, not just the skip (Req 19.3).
+ */
+export declare function jestConfigCollisionMessage(): string;
+/**
+ * Req 13 — the consumer profile's DECLARED DEGRADATION (Spec 123 Task 16.1; design C20:
+ * "Degradation in the consumer profile = warn and exit 0"). Printed once per unresolvable
+ * member when the consumer emission lane (`dist/generator/consumer-entry.js`) finds a member
+ * missing from the installed package — a diet defect or a partial install. The charter is
+ * emitted without that member and the command exits 0.
+ *
+ * AUTHORED AT 16.1, not copied: design § Error Handling carries this row as
+ * `consumer degradation | (unchanged; warning, exit 0)` with no text, so there is no catalog
+ * string to be equal to. `consumer-entry.degradation.test.ts` asserts THIS function's output.
+ *
+ * - `member`: what is missing, e.g. `governance doc 'contract-system-reference'`.
+ * - `where`: where the lane looked, relative to the package root.
+ * - `consequence`: what was emitted without it.
+ *
+ * THE REMEDY CLAUSE (corrected 2026-10-02): a correctly built package emits no warning (the
+ * parity test asserts `warnings` is empty over the built `dist/consumer-canonical`), so every
+ * warning is either a damaged install or a package that shipped without the member (a diet
+ * defect, a tool the shipped manifest does not declare, a missing prepack dispositions file).
+ * A reinstall repairs only the first, so the text says what a failed reinstall means instead of
+ * promising a repair. It asks for a CLEAN reinstall because `npm install` over an existing
+ * `node_modules` does not re-extract a package already present, so a damaged copy survives it;
+ * and it names no cause, because a linked or `file:` install fails the same way. The design
+ * catalog row for this text is owed under
+ * `.kiro/issues/2026-10-01-design-erratum-req-13-degradation-warning-text.md`.
+ */
+export declare function consumerDegradationMessage(member: string, where: string, consequence: string): string;
+/**
+ * design.md catalog row: **managed region — markers missing** (Task 16.4, C7 region
+ * grain). `RegionGrain.spliceRegion` returns this string — never throws, never
+ * writes — when a managed region's begin/end marker pair is absent or unmatched
+ * in `<file>` (e.g. `CLAUDE.md`, `.gitignore`).
+ */
+export declare function managedRegionMarkersMissingMessage(file: string): string;
+/**
+ * design.md catalog row: **managed region — edited inside** (Task 16.5, C7 region
+ * grain). `sync` reports it for a recorded region whose contents differ from both
+ * the package's and the recorded baseline; the region is replaced only with
+ * `--apply` (or `--overwrite <file>#managed`), never on the terminal's batch
+ * confirmation alone.
+ */
+export declare function managedRegionEditedInsideMessage(file: string): string;
+/** design.md catalog row: `attach` in an unborn repo (A8). */
+export declare function attachUnbornRepoMessage(): string;
+/**
+ * design.md catalog row: **restart line — now** (erratum, Le-T5).
+ * `attach --reference` output only, where the restart IS the next step.
+ */
+export declare function restartLineNowMessage(): string;
+/**
+ * An MCP config already carries one of DesignerPunk's server keys, so `init`/`attach`
+ * leaves it unchanged. The remedy names `attach` — the verb that rewrites MCP wiring
+ * in a born or migrated repo; `init` is the once-ever birth event.
+ * Source: `.kiro/issues/2026-10-02-sync-steering-dir-suggestion-writes-broken-path.md`.
+ */
+export declare function existingMcpEntryMessage(configFile: string, key: string, target: 'cc' | 'kiro'): string;
+/**
+ * `generate` stopped because a component-token file in the consumer's tree failed
+ * `defineComponentTokens`'s family-mismatch guard (#127) while it loaded. Names the FILE
+ * (the guard names only the component), carries the guard's own message verbatim, and
+ * names ONLY remedies that work for that file (the 15.0.0 upgrade rehearsal, run 2):
+ *
+ * - **always**: split the file's `defineComponentTokens()` into one call per family;
+ * - **a copied `src/tokens/**` file**: the package ships that file's source, but with the
+ *   package-internal import `'../../build/tokens'` that `init` rewrites on copy — so the
+ *   re-copy must take the same rewrite to `'@3fn/core/build'` (a verbatim copy fails to
+ *   load: `Cannot find module '../../build/tokens'`);
+ * - **an unedited `src/components/core/**` copy**: delete it. The package ships no source
+ *   for those token files (only `dist/`), so there is nothing to re-copy; deleting also
+ *   removes that component's tokens from the consumer's generated `ComponentTokens.*`.
+ *
+ * `file` is repo-relative with `/` separators. Pre-123 `init` copied two such files in the
+ * pre-fix single-family form (`src/tokens/component/progress.ts`,
+ * `src/components/core/Button-Icon/buttonIcon.tokens.ts`).
+ * Source: `.kiro/issues/2026-10-02-generate-stack-trace-on-component-token-family-mismatch.md`.
+ */
+export declare function componentTokenFamilyMismatchMessage(file: string, guardMessage: string): string;
+/**
+ * `generate` stopped because a component-token file in the consumer's tree threw while it
+ * loaded, for any reason other than the family guard. Names the file and the FIRST line of
+ * the reason — Node's module-not-found message carries a multi-line `Require stack:` list of
+ * absolute paths that is noise here.
+ * Source: as {@link componentTokenFamilyMismatchMessage}.
+ */
+export declare function componentTokenFileLoadFailedMessage(file: string, reason: string): string;
+//# sourceMappingURL=errorCatalog.d.ts.map