@3fn/core 14.1.0 → 15.0.0

package/src/__tests__/console-fail-setup.ts

@@ -1,169 +0,0 @@
-/**
- * Console-fail hook (125-B, Requirement 11 / Design C8).
- *
- * Captures console.error/console.warn per test and FAILS the test when
- * unallowlisted output is produced. Checked against the checked-in
- * allowlist (`src/__tests__/console-allowlist.json`, a (suite × message-pattern)
- * grain — see that file for entries + reasons, and
- * governance/classification-map.md § "console-fail-root-lanes" for the rule
- * this hook enforces).
- *
- * SCOPE — root functional lanes ONLY (wired via the root jest.config.js's
- * `setupFilesAfterEnv`). Sub-package suites (mcp-server, application-mcp-server
- * — own jest 29 configs outside this repo's root `roots`) are NOT covered by
- * this hook; see governance/classification-map.md
- * § "console-fail-subpackage-deferred" for the recorded deferral.
- * `product-mcp-server/src/**` IS covered — it lives inside root `roots`.
- *
- * VERSION-AGNOSTIC BY DESIGN (125-B C8 constraint, recorded for any future
- * sub-package replication): plain `jest.spyOn` / method-swap capture only —
- * no jest-30-only API. Stable on jest 29 and jest 30.
- *
- * Known limitation (recorded, not solved here): suites that install their
- * OWN console.error/warn spy on top of this hook's (26 files predate this
- * hook — "house style", nested `describe`-level `beforeEach`, which runs
- * AFTER this hook's root-level `beforeEach`) shadow this hook for the
- * duration of their own mock. Output fully swallowed by a local mock's
- * `mockImplementation(() => {})` never reaches this hook (nothing to check
- * — correct no-op). Output a local mock passes through (e.g. Chip's
- * "anything else passes through" pattern) DOES reach this hook via the
- * bound reference the local suite captured. Because this hook is a plain
- * property swap rather than a `jest.spyOn` mock (see below), a local
- * suite's own `jest.restoreAllMocks()` restores only ITS OWN jest-tracked
- * spy — never this hook's swap, which isn't in Jest's mock registry at all.
- * The residual edge case is narrower than a spyOn-based hook would have:
- * async/deferred output (e.g. an rAF-queued warn) that fires after this
- * test's `afterEach` has already restored `console.error`/`console.warn`
- * back to whatever was there before this test's `beforeEach` — a normal,
- * expected end-of-test boundary, not a cross-hook interaction — can land on
- * the real console unrecorded and unchecked. It does not produce false
- * failures.
- *
- * Chain-through, not shadow (fixed during 4.4's own gate-bite run): the
- * "before" console.error/warn reference is captured FRESH inside
- * `beforeEach`, immediately before this hook installs itself — not once at
- * module load. A handful of CLI suites (figma-extract.test.ts,
- * figma-push.test.ts) install a PERSISTENT module-top-level console mock of
- * their own (no per-test beforeEach/afterEach — restored once in `afterAll`,
- * if at all) and assert against its `.mock.calls`. Capturing "before" once
- * at this module's own load time would have bound to the pristine native
- * console — permanently bypassing those suites' own mocks for every test
- * and silently breaking their `consoleOutput()`-style assertions.
- *
- * PLAIN PROPERTY SWAP, NOT `jest.spyOn` (also fixed during 4.4's gate-bite
- * run — the reason this hook does NOT use jest.spyOn even though the header
- * above still calls the general technique "spyOn/method swap"): `jest.spyOn`
- * has a documented reuse rule — spying on a property that is ALREADY a Jest
- * mock function returns and mutates THAT SAME mock object rather than
- * wrapping a new one. Against the figma-extract/figma-push suites'
- * persistent console.error mock, that reuse rule made `jest.spyOn(console,
- * 'error').mockImplementation(fn)` overwrite THEIR mock's implementation
- * with `fn` — and this hook's own "before" reference, bound to that same
- * mutable mock object, then called back into `fn` on every invocation:
- * infinite recursion, observed as a stack overflow on the very first
- * `console.error` call in a chained suite. A plain property assignment
- * (`console.error = wrapper; ...; console.error = original;`) sidesteps
- * Jest's mock-identity bookkeeping entirely — the same technique the header
- * above documents as version-agnostic ("plain jest.spyOn / method swap"),
- * using the method-swap half specifically because it composes safely with
- * another suite's pre-existing mock, which spyOn's reuse rule does not.
- */
-
-import allowlistData from './console-allowlist.json';
-import * as path from 'path';
-
-interface AllowlistEntry {
-  suite: string;
-  pattern: string;
-  reason: string;
-}
-
-const allowlist = allowlistData as AllowlistEntry[];
-
-function isAllowed(suite: string, message: string): boolean {
-  return allowlist.some((entry) => {
-    if (entry.suite !== suite) return false;
-    try {
-      return new RegExp(entry.pattern).test(message);
-    } catch {
-      // A malformed pattern never silently passes output through.
-      return false;
-    }
-  });
-}
-
-function stringifyArg(value: unknown): string {
-  if (value instanceof Error) return value.stack || value.message;
-  if (typeof value === 'string') return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-function formatArgs(args: unknown[]): string {
-  return args.map(stringifyArg).join(' ');
-}
-
-function currentSuitePath(): string {
-  // expect.getState().testPath is the absolute path to the currently
-  // running test file. Repo root is resolved relative to THIS file
-  // (src/__tests__/), so it's correct regardless of process cwd.
-  const testPath = expect.getState().testPath;
-  if (!testPath) return '';
-  const repoRoot = path.resolve(__dirname, '..', '..');
-  return path.relative(repoRoot, testPath).split(path.sep).join('/');
-}
-
-interface CapturedOutput {
-  method: 'error' | 'warn';
-  message: string;
-}
-
-let captured: CapturedOutput[] = [];
-let originalError: typeof console.error | undefined;
-let originalWarn: typeof console.warn | undefined;
-
-beforeEach(() => {
-  captured = [];
-
-  // Capture whatever is CURRENTLY installed (native console, or another
-  // suite's own persistent mock) immediately before swapping — see the
-  // "Chain-through, not shadow" / "Plain property swap" header notes.
-  originalError = console.error;
-  originalWarn = console.warn;
-
-  console.error = (...args: unknown[]) => {
-    captured.push({ method: 'error', message: formatArgs(args) });
-    originalError!.apply(console, args);
-  };
-
-  console.warn = (...args: unknown[]) => {
-    captured.push({ method: 'warn', message: formatArgs(args) });
-    originalWarn!.apply(console, args);
-  };
-});
-
-afterEach(() => {
-  const suite = currentSuitePath();
-
-  // Targeted restore only — put back exactly what was there before this
-  // test's beforeEach ran (native console, or another suite's own mock).
-  if (originalError) console.error = originalError;
-  if (originalWarn) console.warn = originalWarn;
-
-  const unallowed = captured.filter((entry) => !isAllowed(suite, entry.message));
-  captured = [];
-
-  if (unallowed.length > 0) {
-    const details = unallowed
-      .map((entry) => `  [console.${entry.method}] ${entry.message}`)
-      .join('\n');
-    throw new Error(
-      `console-fail: unallowlisted console output in ${suite}:\n${details}\n\n` +
-        'Legitimate expected noise: add a { suite, pattern, reason } entry to ' +
-        'src/__tests__/console-allowlist.json. Genuine defect: fix the source.'
-    );
-  }
-});

package/src/__tests__/examples/improved-test-example.test.ts

@@ -1,120 +0,0 @@
-/**
- * @category evergreen
- * @purpose Verify improved-test-example functionality works correctly
- */
-/**
- * Example of improved test using fixtures
- * 
- * This demonstrates how tests should be written to avoid hard-coded values
- * and maintain flexibility when design system constants change.
- */
-
-import { ThreeTierValidator, type ThreeTierValidationContext } from '../../validators/ThreeTierValidator';
-import { TokenBuilder, TEST_CONSTANTS, isBaselineGridAligned } from '../fixtures/tokenFixtures';
-
-describe('ThreeTierValidator (Improved)', () => {
-  let validator: ThreeTierValidator;
-
-  beforeEach(() => {
-    validator = new ThreeTierValidator();
-  });
-
-  describe('Pass-level validation', () => {
-    it('should validate primitive token with correct mathematical foundation', () => {
-      // Use fixture instead of hard-coded values
-      const token = TokenBuilder.createBaseSpacingToken();
-
-      const context: ThreeTierValidationContext = {
-        token,
-        options: {
-          enabledLevels: ['Pass', 'Warning', 'Error']
-        }
-      };
-
-      const result = validator.validate(context);
-
-      expect(result.primaryResult.level).toBe('Pass');
-      expect(result.primaryResult.token).toBe('space100');
-      expect(result.summary.level).toBe('Pass');
-    });
-
-    it('should validate strategic flexibility token as Pass', () => {
-      // Fixture automatically uses correct SF value
-      const token = TokenBuilder.createStrategicFlexibilityToken();
-
-      const context: ThreeTierValidationContext = {
-        token
-      };
-
-      const result = validator.validate(context);
-
-      expect(result.primaryResult.level).toBe('Pass');
-      expect(result.primaryResult.message).toContain('Strategic flexibility');
-    });
-  });
-
-  describe('Error-level validation', () => {
-    it('should error on baseline grid violation', () => {
-      // Fixture creates invalid token based on current grid unit
-      // Uses a value that is NOT strategic flexibility and NOT grid-aligned
-      const token = TokenBuilder.createInvalidSpacingToken();
-
-      // Verify our test assumptions
-      expect(isBaselineGridAligned(token.baseValue)).toBe(false);
-      expect(token.isStrategicFlexibility).toBe(false);
-
-      const context: ThreeTierValidationContext = {
-        token,
-        mathematicalContext: {
-          baselineGridRequirement: {
-            required: true,
-            gridUnit: TEST_CONSTANTS.BASELINE_GRID,
-            expectedAlignment: true,
-            actualAlignment: false
-          }
-        }
-      };
-
-      const result = validator.validate(context);
-
-      // Test still works regardless of what the actual grid unit is
-      // The ErrorValidator checks:
-      // 1. Token category requires baseline grid alignment (spacing/radius)
-      // 2. Token is NOT strategic flexibility (flag AND value check)
-      // 3. baseValue % gridUnit !== 0
-      expect(result.primaryResult.level).toBe('Error');
-      expect(result.primaryResult.message).toContain('Baseline grid');
-    });
-
-    it('should validate tokens with different multipliers', () => {
-      // Easy to create variations
-      const doubleToken = TokenBuilder.createDoubleSpacingToken();
-      const quarterToken = TokenBuilder.createQuarterSpacingToken();
-
-      expect(doubleToken.baseValue).toBe(TEST_CONSTANTS.SPACING_DOUBLE);
-      expect(quarterToken.baseValue).toBe(TEST_CONSTANTS.SPACING_QUARTER);
-      
-      // Double is 8-unit grid-aligned
-      expect(isBaselineGridAligned(doubleToken.baseValue)).toBe(true);
-      
-      // Quarter (2) is strategic flexibility, not grid-aligned
-      expect(isBaselineGridAligned(quarterToken.baseValue)).toBe(false);
-      expect(quarterToken.isStrategicFlexibility).toBe(true);
-    });
-  });
-
-  describe('Custom token variations', () => {
-    it('should allow overriding specific properties', () => {
-      // Can still customize when needed
-      const customToken = TokenBuilder.createBaseSpacingToken({
-        name: 'space100-custom',
-        description: 'Custom description'
-      });
-
-      expect(customToken.name).toBe('space100-custom');
-      expect(customToken.description).toBe('Custom description');
-      // But still uses system base value
-      expect(customToken.baseValue).toBe(TEST_CONSTANTS.SPACING_BASE);
-    });
-  });
-});

package/src/__tests__/expected-exports.json

@@ -1,66 +0,0 @@
-{
-  ".": {
-    "type": "module",
-    "description": "Main browser entry — Web Components"
-  },
-  "./components": {
-    "type": "module",
-    "description": "Component re-export (same as main)"
-  },
-  "./tokens.css": {
-    "type": "css",
-    "description": "Design token CSS custom properties"
-  },
-  "./component-tokens.css": {
-    "type": "css",
-    "description": "Component token CSS custom properties"
-  },
-  "./config": {
-    "type": "module",
-    "expectedExports": ["defineConfig"]
-  },
-  "./types": {
-    "type": "typescript-source",
-    "expectedExports": ["TokenCategory", "SemanticCategory"]
-  },
-  "./build": {
-    "type": "typescript-source",
-    "expectedExports": ["defineComponentTokens"]
-  },
-  "./blend": {
-    "type": "typescript-source",
-    "expectedExports": ["BlendCalculator", "calculateBlend", "rgbToHsl", "hslToRgb", "useBlendUtilities"]
-  },
-  "./jest-preset": {
-    "type": "commonjs",
-    "description": "Jest configuration preset for component testing"
-  },
-  "./testing": {
-    "type": "module",
-    "expectedExports": ["createComponentFixture", "registerComponent", "cleanupDOM"]
-  },
-  "./grid.css": {
-    "type": "css",
-    "description": "Responsive grid CSS"
-  },
-  "./fonts/inter.css": {
-    "type": "css",
-    "description": "Inter font face declarations"
-  },
-  "./fonts/rajdhani.css": {
-    "type": "css",
-    "description": "Rajdhani font face declarations"
-  },
-  "./fonts/figtree.css": {
-    "type": "css",
-    "description": "Figtree font face declarations"
-  },
-  "./fonts/commit-mono.css": {
-    "type": "css",
-    "description": "Commit Mono font face declarations"
-  },
-  "./package.json": {
-    "type": "json",
-    "description": "Package manifest"
-  }
-}

package/src/__tests__/export-contracts.test.ts

@@ -1,83 +0,0 @@
-/**
- * @category evergreen
- * @purpose Verify all package.json exports resolve and export expected symbols (Spec 106 R7)
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-const PKG_ROOT = path.resolve(__dirname, '../..');
-const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf-8'));
-const expectedExports = JSON.parse(
-  fs.readFileSync(path.join(__dirname, 'expected-exports.json'), 'utf-8')
-);
-
-describe('Package export contracts (Spec 106 R7)', () => {
-  const exportEntries = Object.entries(pkg.exports) as [string, any][];
-
-  describe('all exports declared in package.json have a manifest entry', () => {
-    for (const [subpath] of exportEntries) {
-      it(`${subpath} is in expected-exports.json`, () => {
-        expect(expectedExports[subpath]).toBeDefined();
-      });
-    }
-  });
-
-  describe('all export paths resolve to existing files', () => {
-    for (const [subpath, config] of exportEntries) {
-      const paths: string[] = [];
-      if (typeof config === 'string') {
-        paths.push(config);
-      } else {
-        if (config.import) paths.push(config.import);
-        if (config.require) paths.push(config.require);
-        if (config.types) paths.push(config.types);
-      }
-
-      for (const p of paths) {
-        it(`${subpath} → ${p} exists`, () => {
-          const resolved = path.resolve(PKG_ROOT, p);
-          expect(fs.existsSync(resolved)).toBe(true);
-        });
-      }
-    }
-  });
-
-  describe('module exports contain expected symbols', () => {
-    for (const [subpath, manifest] of Object.entries(expectedExports) as [string, any][]) {
-      if (!manifest.expectedExports || manifest.expectedExports.length === 0) continue;
-
-      const config = pkg.exports[subpath];
-      if (!config) continue;
-
-      const modulePath = typeof config === 'string' ? config : config.require || config.import;
-      if (!modulePath) continue;
-
-      // Skip CSS and JSON
-      if (modulePath.endsWith('.css') || modulePath.endsWith('.json')) continue;
-
-      describe(subpath, () => {
-        let mod: any;
-
-        beforeAll(() => {
-          const resolved = path.resolve(PKG_ROOT, modulePath);
-          mod = require(resolved);
-        });
-
-        for (const symbol of manifest.expectedExports) {
-          it(`exports "${symbol}"`, () => {
-            expect(mod[symbol]).toBeDefined();
-          });
-        }
-      });
-    }
-  });
-
-  describe('no exports were removed (manifest completeness)', () => {
-    for (const subpath of Object.keys(expectedExports)) {
-      it(`${subpath} still in package.json exports`, () => {
-        expect(pkg.exports[subpath]).toBeDefined();
-      });
-    }
-  });
-});

package/src/__tests__/fixtures/acknowledged-differences.json

@@ -1,127 +0,0 @@
-{
-  "$schema": "./acknowledged-differences.schema.json",
-  "version": "1.1.0",
-  "lastUpdated": "2025-12-28",
-  "description": "Registry of acknowledged platform-specific differences that are intentional and authorized. These differences are expected due to platform-native requirements and design guidelines.",
-  "platformSpecificTokens": {
-    "description": "Tokens that exist only on specific platforms due to platform-native requirements",
-    "tokens": [
-      {
-        "token": "elevation.none",
-        "platform": "android",
-        "reason": "Android Material Design requires an explicit 0dp elevation baseline. Web/iOS z-index systems don't need a 'zero' token as elements without z-index naturally stack in document order.",
-        "authorizedBy": "Peter Michaels Allen",
-        "date": "2025-12-28"
-      }
-    ]
-  },
-  "acknowledgedDifferences": [
-    {
-      "token": "typography.fontSize.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses REM units (relative to 16px base), iOS uses pt (points), Android uses sp (scale-independent pixels)",
-      "rationale": "Platform-native typography units ensure proper scaling with user accessibility settings. REM on web respects browser font size preferences, pt on iOS respects Dynamic Type, sp on Android respects system font scale.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "spacing.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses px, iOS uses pt, Android uses dp",
-      "rationale": "Platform-native spacing units ensure consistent physical dimensions across device densities. All three units are designed to represent approximately the same physical size (1/160 inch at standard density).",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "elevation.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses z-index (arbitrary integers), iOS uses zIndex (small integers), Android uses elevation dp (Material Design scale: 4dp, 8dp, 16dp, 24dp)",
-      "rationale": "Elevation/layering systems are fundamentally different across platforms. Web z-index is purely stacking order, iOS zIndex is similar, but Android elevation combines stacking with visual shadow depth following Material Design guidelines.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "shadow.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web/iOS use shadow primitives (offset, blur, spread, color), Android uses elevation dp values",
-      "rationale": "Android Material Design uses elevation-based shadows that are automatically calculated by the system, while web and iOS require explicit shadow composition. This is a fundamental platform architecture difference.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "motion.duration.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses milliseconds (ms), iOS uses TimeInterval (seconds), Android uses milliseconds (ms)",
-      "rationale": "Platform-native animation APIs use different time units. iOS TimeInterval is in seconds for consistency with Foundation framework, while web CSS and Android use milliseconds.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "motion.easing.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses cubic-bezier() CSS function, iOS uses Animation.timingCurve(), Android uses PathInterpolator or cubic-bezier equivalent",
-      "rationale": "Platform-native animation APIs have different syntax for defining easing curves, but all use the same underlying cubic-bezier mathematical model with identical control points.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "accessibility.tapArea.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "iOS minimum tap area is 44pt (Apple HIG), Android minimum is 48dp (Material Design), Web follows WCAG 2.5.5 (44x44 CSS pixels)",
-      "rationale": "Platform accessibility guidelines specify different minimum touch target sizes. These are intentional platform-specific affordances to meet each platform's accessibility requirements.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "fontFamily.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "System font stacks differ: Web uses system-ui fallback chain, iOS uses SF Pro (system default), Android uses Roboto (system default)",
-      "rationale": "Platform system fonts are intentionally different to provide native look and feel. Custom fonts (Inter) are consistent across platforms, but system font fallbacks are platform-specific.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "naming.convention",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses kebab-case (--space-100), iOS uses camelCase (space100), Android uses snake_case (space_100)",
-      "rationale": "Platform naming conventions follow established language and framework standards: CSS custom properties use kebab-case, Swift uses camelCase, Kotlin uses snake_case for constants.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "color.format",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses hex (#RRGGBB) or rgba(), iOS uses Color struct with RGB components, Android uses Color.argb() or hex integers",
-      "rationale": "Platform color APIs have different representations. The underlying RGB values are mathematically identical, only the syntax differs.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "borderRadius.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "Web uses px, iOS uses CGFloat (pt), Android uses dp",
-      "rationale": "Platform-native units for corner radius ensure consistent visual appearance across device densities.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    },
-    {
-      "token": "lineHeight.*",
-      "platforms": ["web", "ios", "android"],
-      "difference": "All platforms use unitless multipliers, but iOS may use absolute pt values in some contexts",
-      "rationale": "Unitless line-height multipliers are preferred for scalability, but iOS UIKit sometimes requires absolute values. SwiftUI supports unitless multipliers.",
-      "authorizedBy": "Peter Michaels Allen",
-      "date": "2025-12-27"
-    }
-  ],
-  "validationRules": {
-    "allowedDifferenceTypes": [
-      "unit",
-      "syntax",
-      "naming",
-      "scale",
-      "format"
-    ],
-    "requireRationale": true,
-    "requireAuthorization": true
-  }
-}

package/src/__tests__/fixtures/acknowledged-differences.schema.json

@@ -1,113 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "acknowledged-differences.schema.json",
-  "title": "Acknowledged Differences Registry",
-  "description": "Schema for documenting intentional platform-specific differences in the design token system",
-  "type": "object",
-  "required": ["version", "lastUpdated", "acknowledgedDifferences"],
-  "properties": {
-    "$schema": {
-      "type": "string",
-      "description": "Reference to this schema file"
-    },
-    "version": {
-      "type": "string",
-      "pattern": "^\\d+\\.\\d+\\.\\d+$",
-      "description": "Semantic version of the registry format"
-    },
-    "lastUpdated": {
-      "type": "string",
-      "format": "date",
-      "description": "ISO 8601 date when the registry was last updated"
-    },
-    "description": {
-      "type": "string",
-      "description": "Human-readable description of the registry purpose"
-    },
-    "acknowledgedDifferences": {
-      "type": "array",
-      "description": "List of acknowledged platform-specific differences",
-      "items": {
-        "$ref": "#/definitions/AcknowledgedDifference"
-      }
-    },
-    "validationRules": {
-      "type": "object",
-      "description": "Rules for validating new difference entries",
-      "properties": {
-        "allowedDifferenceTypes": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "enum": ["unit", "syntax", "naming", "scale", "format", "value", "behavior"]
-          }
-        },
-        "requireRationale": {
-          "type": "boolean",
-          "default": true
-        },
-        "requireAuthorization": {
-          "type": "boolean",
-          "default": true
-        }
-      }
-    }
-  },
-  "definitions": {
-    "AcknowledgedDifference": {
-      "type": "object",
-      "required": ["token", "platforms", "difference", "rationale", "authorizedBy", "date"],
-      "properties": {
-        "token": {
-          "type": "string",
-          "description": "Token path pattern (e.g., 'spacing.inset.100' or 'typography.fontSize.*' for wildcards)",
-          "minLength": 1
-        },
-        "platforms": {
-          "type": "array",
-          "description": "Platforms affected by this difference",
-          "items": {
-            "$ref": "#/definitions/Platform"
-          },
-          "minItems": 2,
-          "uniqueItems": true
-        },
-        "difference": {
-          "type": "string",
-          "description": "Clear description of what differs between platforms",
-          "minLength": 10
-        },
-        "rationale": {
-          "type": "string",
-          "description": "Explanation of why this difference is intentional and acceptable",
-          "minLength": 20
-        },
-        "authorizedBy": {
-          "type": "string",
-          "description": "Name of the person who authorized this difference",
-          "minLength": 1
-        },
-        "date": {
-          "type": "string",
-          "format": "date",
-          "description": "ISO 8601 date when this difference was authorized"
-        },
-        "category": {
-          "type": "string",
-          "description": "Optional category for grouping related differences",
-          "enum": ["unit", "syntax", "naming", "scale", "format", "value", "behavior"]
-        },
-        "notes": {
-          "type": "string",
-          "description": "Optional additional notes or context"
-        }
-      },
-      "additionalProperties": false
-    },
-    "Platform": {
-      "type": "string",
-      "enum": ["web", "ios", "android"],
-      "description": "Supported platform identifiers"
-    }
-  }
-}