@3fn/core 14.0.0 → 15.0.0

package/application-mcp-server/src/indexer/__tests__/ThemeRootFollowsIndex.test.ts

@@ -0,0 +1,216 @@
+/**
+ * @category evergreen
+ * @purpose Verify the theme root FOLLOWS the served index's recorded `tierDir`
+ * (Spec 123 Task 1.5 — design.md DD24 "the theme root travels with the index"),
+ * rather than being hardcoded to `<projectRoot>/src/tokens`.
+ *
+ * REGRESSION THIS CLOSES (flagged by Lina at Task 1.4 handoff): once the application
+ * server's bootstrap anchors `projectRoot` on the CONSUMER root (Task 1.4), a
+ * package-mode consumer's `<consumerRoot>/src/tokens/themes/…` doesn't exist — the
+ * live tier is the PACKAGE's `src/tokens`. `ModeClassifier` and `TokenIndexer` must
+ * read `token-index/meta.json`'s `tierDir` (written by `generate`) instead.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ComponentIndexer } from '../ComponentIndexer';
+import { ModeClassifier } from '../ModeClassifier';
+import { resolveThemeTierRoot } from '../resolveThemeTierRoot';
+
+function mkTmpDir(prefix: string): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function writeDarkOverrides(tierDir: string): void {
+  fs.mkdirSync(path.join(tierDir, 'themes', 'dark'), { recursive: true });
+  fs.writeFileSync(
+    path.join(tierDir, 'themes', 'dark', 'SemanticOverrides.ts'),
+    "import type { SemanticOverrideMap } from '../types';\n" +
+      "export const darkOverrides: SemanticOverrideMap = {\n" +
+      "  'color.structure.canvas': { primitiveReferences: { value: 'gray400' } },\n" +
+      '};\n'
+  );
+}
+
+function writeMeta(tokenIndexDir: string, tierDir: string): void {
+  fs.mkdirSync(tokenIndexDir, { recursive: true });
+  fs.writeFileSync(path.join(tokenIndexDir, 'meta.json'), JSON.stringify({ tierDir }));
+}
+
+describe('resolveThemeTierRoot — precedence (meta.json → explicit → legacy)', () => {
+  let scratch: string;
+
+  beforeEach(() => {
+    scratch = mkTmpDir('dp-themeroot-');
+  });
+
+  afterEach(() => {
+    fs.rmSync(scratch, { recursive: true, force: true });
+  });
+
+  test('meta.json tierDir wins over both the explicit tier and the legacy default', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index');
+    const metaTier = path.join(scratch, 'from-meta');
+    fs.mkdirSync(metaTier, { recursive: true }); // rule 1 wins only for a tier that exists on disk
+    writeMeta(tokenIndexDir, metaTier);
+
+    const result = resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy-project-root');
+    expect(result).toBe(metaTier);
+  });
+
+  test('explicit tier wins when meta.json is absent', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index'); // no meta.json written
+    fs.mkdirSync(tokenIndexDir, { recursive: true });
+
+    const result = resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy-project-root');
+    expect(result).toBe('/from-explicit');
+  });
+
+  test('legacy <projectRoot>/src/tokens is the last resort', () => {
+    const result = resolveThemeTierRoot(undefined, undefined, '/from-legacy-project-root');
+    expect(result).toBe(path.join('/from-legacy-project-root', 'src', 'tokens'));
+  });
+
+  // The 15.0.0 upgrade rehearsal, F2 (.kiro/issues/2026-10-02-token-index-meta-ships-absolute-path.md):
+  // a packed index carried the BUILD machine's absolute tierDir. On any other machine
+  // that path does not exist, and it must not win.
+  test('a meta.json carrying a nonexistent absolute path does not win — the explicit tier follows', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index');
+    writeMeta(tokenIndexDir, path.join(scratch, 'build-machine', 'clone', 'src', 'tokens')); // never created
+    expect(resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy-project-root')).toBe('/from-explicit');
+  });
+
+  test('...and with no explicit tier, the legacy default follows', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index');
+    writeMeta(tokenIndexDir, path.join(scratch, 'build-machine', 'clone', 'src', 'tokens'));
+    expect(resolveThemeTierRoot(tokenIndexDir, undefined, '/from-legacy-project-root')).toBe(
+      path.join('/from-legacy-project-root', 'src', 'tokens'),
+    );
+  });
+
+  test('a RELATIVE tierDir resolves against the index directory (the packed form: ../src/tokens)', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index');
+    const tier = path.join(scratch, 'src', 'tokens');
+    fs.mkdirSync(tier, { recursive: true });
+    writeMeta(tokenIndexDir, '../src/tokens');
+    expect(resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy-project-root')).toBe(tier);
+  });
+
+  test('a relative tierDir that does not exist falls through like an absolute one', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index');
+    writeMeta(tokenIndexDir, '../src/tokens'); // not created
+    expect(resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy-project-root')).toBe('/from-explicit');
+  });
+
+  test('BITE target: a malformed meta.json falls through, never throws', () => {
+    const tokenIndexDir = path.join(scratch, 'token-index');
+    fs.mkdirSync(tokenIndexDir, { recursive: true });
+    fs.writeFileSync(path.join(tokenIndexDir, 'meta.json'), '{ not valid json');
+
+    expect(() => resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy')).not.toThrow();
+    expect(resolveThemeTierRoot(tokenIndexDir, '/from-explicit', '/from-legacy')).toBe('/from-explicit');
+  });
+});
+
+describe('the package-mode regression: ModeClassifier follows meta.json, not <projectRoot>/src/tokens', () => {
+  let consumerRoot: string;
+  let packageTier: string;
+  let tokenIndexDir: string;
+
+  beforeEach(() => {
+    consumerRoot = mkTmpDir('dp-consumer-'); // package-mode: NO src/tokens here at all
+    packageTier = mkTmpDir('dp-package-tier-');
+    writeDarkOverrides(packageTier);
+    tokenIndexDir = path.join(mkTmpDir('dp-index-'), 'token-index');
+    writeMeta(tokenIndexDir, packageTier);
+  });
+
+  afterEach(() => {
+    fs.rmSync(consumerRoot, { recursive: true, force: true });
+    fs.rmSync(packageTier, { recursive: true, force: true });
+    fs.rmSync(path.dirname(tokenIndexDir), { recursive: true, force: true });
+  });
+
+  test('load() resolves the theme from meta.json\'s tierDir, not <consumerRoot>/src/tokens', () => {
+    const classifier = new ModeClassifier();
+    // projectRoot is the CONSUMER root (package-mode's dsRoot.root) — it has no
+    // src/tokens at all. Without following meta.json this would warn "not found".
+    classifier.load(consumerRoot, tokenIndexDir);
+
+    expect(classifier.getWarnings()).toEqual([]);
+    expect(classifier.classify('color.structure.canvas')).toBe('level-2');
+  });
+
+  test('a relative tierDir in a relocated index still finds the package tier (the installed-package layout)', () => {
+    // The packed layout: <pkg>/token-index/meta.json → "../src/tokens" → <pkg>/src/tokens.
+    const pkgRoot = mkTmpDir('dp-installed-pkg-');
+    try {
+      // A key ONLY this fixture carries: a "../src/tokens" mis-resolved against the test's
+      // cwd would land on the repo's own tier, which has color.structure.canvas too.
+      const tier = path.join(pkgRoot, 'src', 'tokens');
+      fs.mkdirSync(path.join(tier, 'themes', 'dark'), { recursive: true });
+      fs.writeFileSync(
+        path.join(tier, 'themes', 'dark', 'SemanticOverrides.ts'),
+        "import type { SemanticOverrideMap } from '../types';\n" +
+          "export const darkOverrides: SemanticOverrideMap = {\n" +
+          "  'color.fixture.installedOnly': { primitiveReferences: { value: 'gray400' } },\n" +
+          '};\n'
+      );
+      const installedIndex = path.join(pkgRoot, 'token-index');
+      writeMeta(installedIndex, '../src/tokens');
+
+      const classifier = new ModeClassifier();
+      classifier.load(consumerRoot, installedIndex);
+
+      expect(classifier.getWarnings()).toEqual([]);
+      expect(classifier.classify('color.fixture.installedOnly')).toBe('level-2');
+    } finally {
+      fs.rmSync(pkgRoot, { recursive: true, force: true });
+    }
+  });
+
+  test('BITE (recorded red in the Task 1.5 completion doc): hardcoding <projectRoot>/src/tokens loses the override', () => {
+    // Reproduce the PRE-1.5 hardcoded read directly, to prove it would have missed
+    // the override that lives at the PACKAGE tier, not the consumer root.
+    const legacyOverridesPath = path.join(consumerRoot, 'src/tokens/themes/dark/SemanticOverrides.ts');
+    expect(fs.existsSync(legacyOverridesPath)).toBe(false);
+  });
+});
+
+describe('ComponentIndexer wiring: options.tierDir threads through to the theme readers', () => {
+  let consumerRoot: string;
+  let componentsRoot: string;
+  let packageTier: string;
+  let tokenIndexDir: string;
+
+  beforeEach(() => {
+    consumerRoot = mkTmpDir('dp-consumer2-');
+    componentsRoot = path.join(consumerRoot, 'src', 'components');
+    fs.mkdirSync(componentsRoot, { recursive: true });
+    packageTier = mkTmpDir('dp-package-tier2-');
+    writeDarkOverrides(packageTier);
+    tokenIndexDir = path.join(consumerRoot, 'token-index');
+    fs.mkdirSync(tokenIndexDir, { recursive: true });
+    fs.writeFileSync(path.join(tokenIndexDir, 'primitives.yaml'), 'tokens: {}\n');
+    fs.writeFileSync(path.join(tokenIndexDir, 'semantics.yaml'), 'tokens: {}\n');
+    fs.writeFileSync(path.join(tokenIndexDir, 'components.yaml'), 'tokens: {}\n');
+  });
+
+  afterEach(() => {
+    fs.rmSync(consumerRoot, { recursive: true, force: true });
+    fs.rmSync(packageTier, { recursive: true, force: true });
+  });
+
+  test('explicit options.tierDir (no meta.json yet) reaches ModeClassifier via a full index', async () => {
+    const indexer = new ComponentIndexer();
+    await indexer.indexComponents(componentsRoot, undefined, undefined, undefined, tokenIndexDir, {
+      projectRoot: consumerRoot,
+      tierDir: packageTier,
+    });
+
+    // getTokenIndexer's warnings would include "Dark theme overrides not found" if the
+    // hardcoded <projectRoot>/src/tokens path had been used instead of options.tierDir.
+    const warnings = indexer.getTokenIndexer().getWarnings();
+    expect(warnings.some(w => w.includes('Dark theme overrides not found'))).toBe(false);
+  });
+});

package/application-mcp-server/src/indexer/__tests__/fixtures/consumerFixture.ts

@@ -0,0 +1,84 @@
+/**
+ * Shared consumer-install fixture for the Spec 123 Task 1.4 multi-root tests
+ * (`MultiRootIndexing.test.ts`, `src/__tests__/consumerRootLiveReindex.test.ts`).
+ * Not a test file (no `.test.ts` suffix, so jest does not collect it).
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export interface FixtureComponent {
+  dir: string;
+  name: string;
+  inherits?: string;
+  contracts: string[];
+  tokens?: string[];
+  description?: string;
+  composesInternal?: string[];
+}
+
+export function writeComponent(root: string, c: FixtureComponent): string {
+  const dirPath = path.join(root, c.dir);
+  fs.mkdirSync(dirPath, { recursive: true });
+  const schema = [
+    `name: ${c.name}`,
+    `type: type-primitive`,
+    `family: Fixture`,
+    `version: "1.0.0"`,
+    `description: "${c.description ?? c.name}"`,
+    `platforms: [web]`,
+    `tokens: [${(c.tokens ?? []).join(', ')}]`,
+  ];
+  if (c.composesInternal?.length) {
+    schema.push('composition:', '  internal:');
+    for (const child of c.composesInternal) schema.push(`    - component: ${child}`, `      relationship: contains`);
+  }
+  fs.writeFileSync(path.join(dirPath, `${c.name}.schema.yaml`), schema.join('\n') + '\n');
+  const contracts = [`version: "1.0.0"`, `component: ${c.name}`, `family: Fixture`];
+  if (c.inherits) contracts.push(`inherits: ${c.inherits}`);
+  contracts.push('contracts:');
+  for (const k of c.contracts) {
+    contracts.push(`  ${k}:`, `    category: ${k.split('_')[0]}`, `    description: "${k}"`, `    behavior: "${k}"`);
+  }
+  fs.writeFileSync(path.join(dirPath, 'contracts.yaml'), contracts.join('\n') + '\n');
+  return dirPath;
+}
+
+export interface ConsumerFixture {
+  base: string;
+  consumerRoot: string;
+  packageRoot: string;
+}
+
+/**
+ * Package: Widget-Base, Widget-Primary (inherits Widget-Base), Panel-Base (composes Widget-Primary).
+ * Consumer: a FORK of Widget-Primary in a directory whose name differs from its declared name
+ * (`widget-primary-fork/`), inheriting the PACKAGE parent Widget-Base; Card-Consumer (composes
+ * the package's Widget-Base).
+ */
+export function buildConsumerFixture(prefix: string): ConsumerFixture {
+  const base = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), prefix));
+  const consumerRoot = path.join(base, 'src', 'components');
+  const packageRoot = path.join(base, 'node_modules', '@3fn', 'core', 'src', 'components', 'core');
+  fs.mkdirSync(consumerRoot, { recursive: true });
+  fs.mkdirSync(packageRoot, { recursive: true });
+
+  writeComponent(packageRoot, { dir: 'Widget-Base', name: 'Widget-Base', contracts: ['interaction_pressable'], tokens: ['space100'] });
+  writeComponent(packageRoot, {
+    dir: 'Widget-Primary', name: 'Widget-Primary', inherits: 'Widget-Base',
+    contracts: ['visual_package_marker'], tokens: ['color.package'], description: 'PACKAGE',
+  });
+  writeComponent(packageRoot, {
+    dir: 'Panel-Base', name: 'Panel-Base', contracts: ['visual_panel'], composesInternal: ['Widget-Primary'],
+  });
+
+  writeComponent(consumerRoot, {
+    dir: 'widget-primary-fork', name: 'Widget-Primary', inherits: 'Widget-Base',
+    contracts: ['visual_fork_marker'], tokens: ['color.fork'], description: 'FORK',
+  });
+  writeComponent(consumerRoot, {
+    dir: 'Card-Consumer', name: 'Card-Consumer', contracts: ['visual_card'], composesInternal: ['Widget-Base'],
+  });
+
+  return { base, consumerRoot, packageRoot };
+}

package/application-mcp-server/src/indexer/resolveThemeTierRoot.ts

@@ -0,0 +1,61 @@
+/**
+ * Resolve the theme TIER ROOT — where `ModeClassifier` and `TokenIndexer` read
+ * `themes/dark/SemanticOverrides.ts` from (Spec 123 Task 1.5, design.md DD24 —
+ * "the theme root travels with the index").
+ *
+ * BACKGROUND: `modeClassifier.load()` and `tokenIndexer.indexTokens()` used to read
+ * `<projectRoot>/src/tokens/themes/dark/SemanticOverrides.ts`, hardcoding the
+ * assumption that the live token tier is always at `<projectRoot>/src/tokens`. Under
+ * Model B that's only true for a BORN consumer whose `tokenSource` happens to be the
+ * conventional path. It's wrong for `package-mode` (the live tier is the PACKAGE's
+ * `src/tokens`, not the consumer's own tree) and for any born consumer whose
+ * `tokenSource` points somewhere else — the C2/C3 monorepo escape (`TOKEN_INDEX_DIR`)
+ * exists precisely so an index can be chosen independently of the working directory,
+ * and "any way of choosing the index... brings its own themes with it" (C3).
+ *
+ * PRECEDENCE (design.md § C3 "THE THEME ROOT IS PAIRED WITH THE INDEX"):
+ *   1. `<tokenIndexDir>/meta.json`'s `tierDir` field — written by `generate` (Task 1.5)
+ *      alongside the index it describes. This is the authoritative, self-describing
+ *      answer: whichever index got served, its own metadata says where its themes live.
+ *   2. The caller's explicit tier (`DesignSystemRoot.tierDir`, from
+ *      `findDesignSystemRoot`) — used only when the index predates this metadata (a
+ *      pre-1.5 `generate` run) or `tokenIndexDir` isn't known at the call site.
+ *   3. Legacy default: `<projectRoot>/src/tokens` — the ONLY shape supported before
+ *      this change. Kept so callers that pass neither metadata nor an explicit tier
+ *      (single-root tests, the live pre-regeneration corpus) see IDENTICAL behavior.
+ *
+ * RULE 1 IS PORTABLE AND VERIFIED (the 15.0.0 upgrade rehearsal, F2 —
+ * `.kiro/issues/2026-10-02-token-index-meta-ships-absolute-path.md`): the writer
+ * records `tierDir` RELATIVE to the token-index directory (`/` separators), so a
+ * packed index's `../src/tokens` resolves inside whichever install serves it. A
+ * relative value resolves against `tokenIndexDir`; an absolute one is taken as is
+ * (indexes written before the fix). Either way the value wins only if it EXISTS on
+ * disk — an index built on another machine records a path that does not exist here,
+ * and that value falls through to rule 2 rather than pointing the theme readers at
+ * nothing. The check is an existence check only; a directory without a dark
+ * `SemanticOverrides.ts` still wins (the readers report that themselves).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+export function resolveThemeTierRoot(
+  tokenIndexDir: string | undefined,
+  explicitTierDir: string | undefined,
+  projectRoot: string,
+): string {
+  if (tokenIndexDir) {
+    try {
+      const raw = fs.readFileSync(path.join(tokenIndexDir, 'meta.json'), 'utf8');
+      const meta = JSON.parse(raw) as { tierDir?: unknown };
+      if (typeof meta.tierDir === 'string' && meta.tierDir.length > 0) {
+        const recorded = path.isAbsolute(meta.tierDir) ? meta.tierDir : path.resolve(tokenIndexDir, meta.tierDir);
+        if (fs.existsSync(recorded)) return recorded;
+        // Recorded, but not on this machine — fall through to the next source.
+      }
+    } catch {
+      // meta.json absent, unreadable, or malformed — fall through to the next source.
+    }
+  }
+  if (explicitTierDir) return explicitTierDir;
+  return path.join(projectRoot, 'src', 'tokens');
+}

package/application-mcp-server/src/watcher/FileWatcher.ts

@@ -6,6 +6,9 @@
  *
  * Data sources:
  * - components: schema.yaml, contracts.yaml, component-meta.yaml → reindexComponent
+ *   (one watcher per MUTABLE component root — Spec 123 C3: the consumer root is watched; the
+ *   package root is exempt as immutable. The caller passes the mutable set, see
+ *   `mutableComponentRoots` in ComponentIndexer.ts.)
  * - patterns: *.yaml → reindexPatterns
  * - templates: *.yaml → reindexTemplates
  * - guidance: *.yaml → reindexGuidance
@@ -28,23 +31,32 @@ interface WatchConfig {
 export class FileWatcher {
   private watchers: fs.FSWatcher[] = [];
   private debounceTimers = new Map<string, NodeJS.Timeout>();
+  private componentsDirs: string[];
 
   constructor(
     private indexer: ComponentIndexer,
-    private componentsDir: string,
+    componentsDir: string | string[],
     private patternsDir?: string,
     private templatesDir?: string,
     private guidanceDir?: string,
     private tokenIndexDir?: string,
     private debounceMs: number = 100,
-  ) {}
+  ) {
+    this.componentsDirs = (Array.isArray(componentsDir) ? componentsDir : [componentsDir]).filter(Boolean);
+  }
+
+  /** The component roots this watcher watches (the mutable set it was given). */
+  getWatchedComponentRoots(): string[] {
+    return [...this.componentsDirs];
+  }
 
   start(): void {
     this.stop();
 
-    const configs: WatchConfig[] = [
-      { dir: this.componentsDir, handler: (f) => this.handleComponentChange(f) },
-    ];
+    const configs: WatchConfig[] = this.componentsDirs.map(root => ({
+      dir: root,
+      handler: (f: string) => this.handleComponentChange(root, f),
+    }));
 
     if (this.patternsDir) configs.push({ dir: this.patternsDir, handler: () => this.debounceReindex('patterns', () => this.indexer.reindexPatterns(this.patternsDir!)) });
     if (this.templatesDir) configs.push({ dir: this.templatesDir, handler: () => this.debounceReindex('templates', () => this.indexer.reindexTemplates(this.templatesDir!)) });
@@ -77,11 +89,12 @@ export class FileWatcher {
     return this.watchers.length > 0;
   }
 
-  private handleComponentChange(filename: string): void {
+  private handleComponentChange(root: string, filename: string): void {
     const base = path.basename(filename);
     if (!base.endsWith('.schema.yaml') && !COMPONENT_FILES.has(base)) return;
 
-    const componentDir = path.join(this.componentsDir, path.dirname(filename));
+    // `filename` is root-relative; under a legacy `core/` level it is `core/<Name>/<file>`.
+    const componentDir = path.join(root, path.dirname(filename));
     this.debounceReindex(componentDir, () => this.indexer.reindexComponent(componentDir));
   }
 

package/dist/ComponentTokens.android.kt

@@ -1,6 +1,6 @@
 /**
  * DesignerPunk Design System - Component Tokens
- * Generated: 2026-08-12T03:23:17.012Z
+ * Generated: 2026-10-03T02:14:57.175Z
  * Version: 1.0.0
  * Platform: Android (Kotlin Constants)
  *
@@ -45,11 +45,11 @@ object ButtonIconTokens {
     // Small button variant uses 8px padding (1× base) for minimal footprint in dense UI layouts while meeting minimum touch target requirements
     val insetSmall = SpacingTokens.space100
     // Large button size (48px = 6× base) provides generous touch target exceeding tapAreaRecommended, calculated as icon (24px) + padding (12px × 2)
-    val sizeLarge = SpacingTokens.size600
+    val sizeLarge = SizingTokens.size600
     // Medium button size (40px = 5× base) provides standard touch target, calculated as icon (18px) + padding (10px × 2) rounded to grid
-    val sizeMedium = SpacingTokens.size500
+    val sizeMedium = SizingTokens.size500
     // Small button size (32px = 4× base) provides compact visual footprint, calculated as icon (13px) + padding (8px × 2) rounded to grid
-    val sizeSmall = SpacingTokens.size400
+    val sizeSmall = SizingTokens.size400
 }
 
 /** InputCheckbox Component Tokens */
@@ -74,26 +74,26 @@ object InputRadioTokens {
 
 /** Progress Component Tokens */
 object ProgressTokens {
+    // Connector line thickness (1px). References borderDefault primitive for consistent border treatment across the design system.
+    val connectorThickness = BorderWidthTokens.borderWidth100
     // Small node base size (12px). Inactive dots in compact mobile contexts.
-    val nodeSizeSm = SpacingTokens.size150
+    val nodeSizeSm = SizingTokens.size150
     // Medium node base size (16px). Default inactive dot size.
-    val nodeSizeMd = SpacingTokens.size200
+    val nodeSizeMd = SizingTokens.size200
     // Large node base size (20px). Inactive dots in desktop contexts.
-    val nodeSizeLg = SpacingTokens.size250
+    val nodeSizeLg = SizingTokens.size250
     // Current node emphasis for sm (16px). +4px over base 12px for non-color visual differentiation.
-    val nodeSizeSmCurrent = SpacingTokens.size200
+    val nodeSizeSmCurrent = SizingTokens.size200
     // Current node emphasis for md (20px). +4px over base 16px for non-color visual differentiation.
-    val nodeSizeMdCurrent = SpacingTokens.size250
+    val nodeSizeMdCurrent = SizingTokens.size250
     // Current node emphasis for lg (24px). +4px over base 20px for non-color visual differentiation.
-    val nodeSizeLgCurrent = SpacingTokens.size300
+    val nodeSizeLgCurrent = SizingTokens.size300
     // Small gap between nodes (6px = 0.75× base). Tight spacing for compact pagination dots in mobile contexts.
     val nodeGapSm = SpacingTokens.space075
     // Medium gap between nodes (8px = 1× base). Default spacing for stepper nodes, providing clear separation without excessive whitespace.
     val nodeGapMd = SpacingTokens.space100
     // Large gap between nodes (12px = 1.5× base). Generous spacing for detailed steppers with labels in desktop contexts.
     val nodeGapLg = SpacingTokens.space150
-    // Connector line thickness (1px). References borderDefault primitive for consistent border treatment across the design system.
-    val connectorThickness = SpacingTokens.borderWidth100
 }
 
 /** VerticalListItem Component Tokens */

package/dist/ComponentTokens.ios.swift

@@ -1,6 +1,6 @@
 ///
 /// DesignerPunk Design System - Component Tokens
-/// Generated: 2026-08-12T03:23:17.012Z
+/// Generated: 2026-10-03T02:14:57.175Z
 /// Version: 1.0.0
 /// Platform: iOS (Swift Constants)
 ///
@@ -45,11 +45,11 @@ public enum ButtonIconTokens {
     /// Small button variant uses 8px padding (1× base) for minimal footprint in dense UI layouts while meeting minimum touch target requirements
     public static let insetSmall: CGFloat = SpacingTokens.space100
     /// Large button size (48px = 6× base) provides generous touch target exceeding tapAreaRecommended, calculated as icon (24px) + padding (12px × 2)
-    public static let sizeLarge: CGFloat = SpacingTokens.size600
+    public static let sizeLarge: CGFloat = SizingTokens.size600
     /// Medium button size (40px = 5× base) provides standard touch target, calculated as icon (18px) + padding (10px × 2) rounded to grid
-    public static let sizeMedium: CGFloat = SpacingTokens.size500
+    public static let sizeMedium: CGFloat = SizingTokens.size500
     /// Small button size (32px = 4× base) provides compact visual footprint, calculated as icon (13px) + padding (8px × 2) rounded to grid
-    public static let sizeSmall: CGFloat = SpacingTokens.size400
+    public static let sizeSmall: CGFloat = SizingTokens.size400
 }
 
 /// InputCheckbox Component Tokens
@@ -74,26 +74,26 @@ public enum InputRadioTokens {
 
 /// Progress Component Tokens
 public enum ProgressTokens {
+    /// Connector line thickness (1px). References borderDefault primitive for consistent border treatment across the design system.
+    public static let connectorThickness: CGFloat = BorderWidthTokens.borderWidth100
     /// Small node base size (12px). Inactive dots in compact mobile contexts.
-    public static let nodeSizeSm: CGFloat = SpacingTokens.size150
+    public static let nodeSizeSm: CGFloat = SizingTokens.size150
     /// Medium node base size (16px). Default inactive dot size.
-    public static let nodeSizeMd: CGFloat = SpacingTokens.size200
+    public static let nodeSizeMd: CGFloat = SizingTokens.size200
     /// Large node base size (20px). Inactive dots in desktop contexts.
-    public static let nodeSizeLg: CGFloat = SpacingTokens.size250
+    public static let nodeSizeLg: CGFloat = SizingTokens.size250
     /// Current node emphasis for sm (16px). +4px over base 12px for non-color visual differentiation.
-    public static let nodeSizeSmCurrent: CGFloat = SpacingTokens.size200
+    public static let nodeSizeSmCurrent: CGFloat = SizingTokens.size200
     /// Current node emphasis for md (20px). +4px over base 16px for non-color visual differentiation.
-    public static let nodeSizeMdCurrent: CGFloat = SpacingTokens.size250
+    public static let nodeSizeMdCurrent: CGFloat = SizingTokens.size250
     /// Current node emphasis for lg (24px). +4px over base 20px for non-color visual differentiation.
-    public static let nodeSizeLgCurrent: CGFloat = SpacingTokens.size300
+    public static let nodeSizeLgCurrent: CGFloat = SizingTokens.size300
     /// Small gap between nodes (6px = 0.75× base). Tight spacing for compact pagination dots in mobile contexts.
     public static let nodeGapSm: CGFloat = SpacingTokens.space075
     /// Medium gap between nodes (8px = 1× base). Default spacing for stepper nodes, providing clear separation without excessive whitespace.
     public static let nodeGapMd: CGFloat = SpacingTokens.space100
     /// Large gap between nodes (12px = 1.5× base). Generous spacing for detailed steppers with labels in desktop contexts.
     public static let nodeGapLg: CGFloat = SpacingTokens.space150
-    /// Connector line thickness (1px). References borderDefault primitive for consistent border treatment across the design system.
-    public static let connectorThickness: CGFloat = SpacingTokens.borderWidth100
 }
 
 /// VerticalListItem Component Tokens

package/dist/ComponentTokens.web.css

@@ -1,6 +1,6 @@
 /**
  * DesignerPunk Design System - Component Tokens
- * Generated: 2026-08-12T03:23:17.012Z
+ * Generated: 2026-10-03T02:14:57.175Z
  * Version: 1.0.0
  * Platform: Web (CSS Custom Properties)
  *
@@ -63,6 +63,8 @@
   --inputradio-box-lg: var(--size-500);
 
   /* Progress Component Tokens */
+  /* Connector line thickness (1px). References borderDefault primitive for consistent border treatment across the design system. */
+  --progress-connector-thickness: var(--border-width-100);
   /* Small node base size (12px). Inactive dots in compact mobile contexts. */
   --progress-node-size-sm: var(--size-150);
   /* Medium node base size (16px). Default inactive dot size. */
@@ -81,8 +83,6 @@
   --progress-node-gap-md: var(--space-100);
   /* Large gap between nodes (12px = 1.5× base). Generous spacing for detailed steppers with labels in desktop contexts. */
   --progress-node-gap-lg: var(--space-150);
-  /* Connector line thickness (1px). References borderDefault primitive for consistent border treatment across the design system. */
-  --progress-connector-thickness: var(--border-width-100);
 
   /* VerticalListItem Component Tokens */
   /* Block padding at rest state (1px border). 11px padding + 1px border = 12px per side, achieving 48px total with 24px content. Uses TokenWithValue pattern as no primitive token exists for 11px. */

package/dist/DesignTokens.android.kt

@@ -1,6 +1,6 @@
 /**
  * DesignerPunk Design System - Android Tokens
- * Generated: 2026-08-12T03:23:16.999Z
+ * Generated: 2026-10-03T02:14:57.161Z
  * Version: 1.0.0
  * Platform: Android (Kotlin Constants)
  */
@@ -406,7 +406,6 @@ object DesignTokens {
     Use these for UI development
     // ============================================
 
-    val color_feedback_success_text = Oklch(0.66f, 0.18f, 154f).toComposeColor()
     val color_feedback_success_background = Oklch(0.97f, 0.029f, 154f).toComposeColor()
     val color_feedback_success_border = Oklch(0.66f, 0.18f, 154f).toComposeColor()
     val color_feedback_error_text = Oklch(0.55f, 0.203f, 10f).toComposeColor()
@@ -430,9 +429,6 @@ object DesignTokens {
     val color_highlight = Oklch(0.8f, 0.2f, 107f).toComposeColor()
     val color_tech = Oklch(0.51f, 0.241f, 310f).toComposeColor()
     val color_data = Oklch(0.6f, 0.286f, 310f).toComposeColor()
-    val color_text_default = Oklch(0.52f, 0.02f, 260f).toComposeColor()
-    val color_text_muted = Oklch(0.62f, 0.02f, 260f).toComposeColor()
-    val color_text_subtle = Oklch(0.72f, 0.018f, 260f).toComposeColor()
     val color_contrast_on_light = Oklch(0f, 0f, 260f).toComposeColor()
     val color_contrast_on_dark = Oklch(1f, 0f, 260f).toComposeColor()
     val color_structure_surface = Oklch(0.95f, 0.006f, 260f).toComposeColor()