@sparknest/theme-contract-vue 0.0.0-stage → 1.1.0

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@sparknest/theme-contract-vue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.1.0",
+  "description": "Shared Cedar and Maple theme token contract",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.mjs",
+    "./checker": "./src/checker.mjs",
+    "./contract": "./contracts/theme-contract.json",
+    "./legacy-denylist": "./contracts/legacy-denylist.json"
+  },
+  "bin": {
+    "ui-theme-contract": "./bin/theme-contract.mjs"
+  },
+  "files": [
+    "bin",
+    "contracts",
+    "schema",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "check": "node bin/theme-contract.mjs check",
+    "sync": "node bin/theme-contract.mjs sync"
+  }
 }

package/schema/theme-contract.schema.json

@@ -0,0 +1,105 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "UI Foundation theme contract",
+  "type": "object",
+  "required": ["version", "prefixes", "rules", "systemTokenValues", "componentTokenValues", "components", "tokens", "platformExtensions"],
+  "properties": {
+    "version": { "type": "integer", "minimum": 1 },
+    "prefixes": {
+      "type": "object",
+      "required": ["cedar", "maple"],
+      "properties": {
+        "cedar": { "const": "c" },
+        "maple": { "const": "mp" }
+      },
+      "additionalProperties": false
+    },
+    "rules": { "type": "object" },
+    "systemTokenValues": {
+      "type": "object",
+      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
+      "additionalProperties": { "type": "string", "minLength": 1 }
+    },
+    "componentTokenValues": {
+      "type": "object",
+      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
+      "additionalProperties": {
+        "type": "object",
+        "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
+        "additionalProperties": { "type": "string", "minLength": 1 }
+      }
+    },
+    "platformSystemTokenValues": {
+      "type": "object",
+      "properties": {
+        "cedar": { "$ref": "#/$defs/tokenValues" },
+        "maple": { "$ref": "#/$defs/tokenValues" }
+      },
+      "additionalProperties": false
+    },
+    "components": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" },
+      "uniqueItems": true
+    },
+    "platformComponentTokenValues": {
+      "type": "object",
+      "properties": {
+        "cedar": { "$ref": "#/$defs/componentValues" },
+        "maple": { "$ref": "#/$defs/componentValues" }
+      },
+      "additionalProperties": false
+    },
+    "tokens": {
+      "type": "object",
+      "required": ["system", "components"],
+      "properties": {
+        "system": {
+          "type": "array",
+          "items": { "type": "string" },
+          "uniqueItems": true
+        },
+        "components": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "platformExtensions": {
+      "type": "object",
+      "required": ["cedar", "maple"],
+      "properties": {
+        "cedar": { "$ref": "#/$defs/componentNames" },
+        "maple": { "$ref": "#/$defs/componentNames" }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "tokenValues": {
+      "type": "object",
+      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
+      "additionalProperties": { "type": "string", "minLength": 1 }
+    },
+    "componentValues": {
+      "type": "object",
+      "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
+      "additionalProperties": {
+        "type": "object",
+        "propertyNames": { "pattern": "^[a-z][a-z0-9-]*$" },
+        "additionalProperties": { "type": "string", "minLength": 1 }
+      }
+    },
+    "componentNames": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" },
+      "uniqueItems": true
+    }
+  }
+}

package/src/checker.mjs

@@ -0,0 +1,257 @@
+import assert from 'node:assert/strict'
+import { readFileSync, readdirSync } from 'node:fs'
+import { extname, resolve } from 'node:path'
+import contract from '../contracts/theme-contract.json' with { type: 'json' }
+import legacyDenylist from '../contracts/legacy-denylist.json' with { type: 'json' }
+import { normalizeTokenValue } from './normalize-value.mjs'
+
+const sourceExtensions = new Set(['.less', '.css', '.scss', '.vue', '.ts', '.tsx', '.md'])
+const ignoredDirectories = new Set(['node_modules', 'dist', 'coverage'])
+
+function walk(directory) {
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = resolve(directory, entry.name)
+    if (entry.isDirectory()) return ignoredDirectories.has(entry.name) ? [] : walk(path)
+    return sourceExtensions.has(extname(entry.name)) ? [path] : []
+  })
+}
+
+function definitions(source, prefix) {
+  const pattern = new RegExp(`(--${prefix}-[a-z0-9-]+)\\s*:`, 'g')
+  return new Set([...source.matchAll(pattern)].map((match) => match[1]))
+}
+
+function customPropertyValues(source, prefix) {
+  const pattern = new RegExp(`(--${prefix}-[a-z0-9-]+)\\s*:\\s*([^;]+);`, 'g')
+  return new Map([...source.matchAll(pattern)].map((match) => [match[1], match[2].replace(/\\s+/g, ' ').trim()]))
+}
+
+function systemReferences(source, prefix) {
+  const pattern = new RegExp(`var\\(\\s*(--${prefix}-sys-[a-z0-9-]+)`, 'g')
+  return new Set([...source.matchAll(pattern)].map((match) => match[1]))
+}
+
+function allDefinitions(source, prefix) {
+  const names = new Set()
+  for (const file of walk(source)) {
+    for (const name of definitions(readFileSync(file, 'utf8'), prefix)) names.add(name)
+  }
+  return names
+}
+
+function checkThemeOverrides(name, source, prefix) {
+  const defined = allDefinitions(source, prefix)
+  const violations = []
+  const themesRoot = resolve(source, 'themes')
+  for (const file of walk(themesRoot)) {
+    if (/\/(?:__tests__|__demos__|example|docs)\//.test(file)) continue
+    const text = readFileSync(file, 'utf8')
+    const keys = [...text.matchAll(new RegExp(`['\"](--${prefix}-[a-z0-9-]+)['\"]\\s*:`, 'g'))].map(
+      (match) => match[1],
+    )
+    for (const key of keys) {
+      if (key.startsWith(`--${prefix}-internal-`)) violations.push(`${key}: internal token in ${file}`)
+      else if (!defined.has(key)) violations.push(`${key}: undefined theme override in ${file}`)
+    }
+  }
+  assert.deepEqual(violations, [], `${name}: invalid theme overrides`)
+}
+
+function checkLegacyTokens(name, source, prefix, denied) {
+  const violations = []
+  const ignored = /\/(?:docs|example|__demos__|__tests__)\//
+  for (const file of walk(source)) {
+    if (ignored.test(file)) continue
+    const text = readFileSync(file, 'utf8')
+    for (const token of denied) {
+      const fullName = `--${prefix}-${token}`
+      const pattern = new RegExp(`${fullName}(?![a-z0-9-])`)
+      if (pattern.test(text)) violations.push(`${fullName} in ${file}`)
+    }
+  }
+  assert.deepEqual(violations, [], `${name}: legacy tokens are forbidden`)
+}
+
+function checkComponentDocs(name, source, prefix) {
+  const violations = []
+  const platform = prefix === contract.prefixes.cedar ? 'cedar' : 'maple'
+  for (const component of contract.components) {
+    const namespace = component === 'field-decorator' ? 'field' : component
+    const allowed = new Set(contract.tokens.components[component])
+    if (contract.platformExtensions[platform]?.includes(component)) {
+      for (const token of logicalComponentTokens({ prefix, source }, component)) allowed.add(token)
+    }
+    const docsRoot = resolve(source, component, 'docs')
+    let files = []
+    try {
+      files = walk(docsRoot)
+    } catch {
+      continue
+    }
+    for (const file of files.filter((path) => path.endsWith('.md'))) {
+      const text = readFileSync(file, 'utf8')
+      const pattern = new RegExp(
+        `--(?:${prefix}-)?${namespace}-([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)(?![a-z0-9-])`,
+        'g',
+      )
+      for (const match of text.matchAll(pattern)) {
+        if (!allowed.has(match[1])) violations.push(`${match[0]} in ${file}`)
+      }
+    }
+  }
+  assert.deepEqual(violations, [], `${name}: component docs contain tokens outside the contract`)
+}
+
+function logicalSystemTokens(library) {
+  const source = readFileSync(resolve(library.source, 'style/theme/system.less'), 'utf8')
+  return [...definitions(source, library.prefix)]
+    .filter((name) => name.startsWith(`--${library.prefix}-sys-`))
+    .map((name) => name.slice(`--${library.prefix}-sys-`.length))
+    .sort()
+}
+
+function logicalSystemTokenValues(library, expected = contract.systemTokenValues) {
+  const source = readFileSync(resolve(library.source, 'style/theme/system.less'), 'utf8')
+  const values = customPropertyValues(source, library.prefix)
+  return Object.fromEntries(
+    Object.keys(expected).map((token) => {
+      const name = `--${library.prefix}-sys-${token}`
+      assert.ok(values.has(name), `${library.name}: ${name} has no value`)
+      return [token, normalizeTokenValue(values.get(name), library.prefix)]
+    }),
+  )
+}
+
+function logicalComponentTokenValues(library, component, expected = contract.componentTokenValues[component]) {
+  const namespace = component === 'field-decorator' ? 'field' : component
+  // Govern the public :root defaults, not theme-specific overrides later in token.less.
+  const source = readFileSync(resolve(library.source, component, 'style/token.less'), 'utf8')
+  // Naming examples in comments may contain braces (e.g. {variant}); they are not CSS blocks.
+  // Preserve quoted strings so URLs and string-valued defaults are not treated as comments.
+  const uncommented = source.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g,
+    (match) => match.startsWith('//') || match.startsWith('/*') ? '' : match)
+  const defaults = [...uncommented.matchAll(/(?:^|\n)\s*:root\s*\{([^}]*)\}/g)].map((match) => match[1]).join('\n')
+  const values = customPropertyValues(defaults, library.prefix)
+  return Object.fromEntries(
+    Object.keys(expected).map((token) => {
+      const name = `--${library.prefix}-${namespace}-${token}`
+      assert.ok(values.has(name), `${library.name}: ${name} has no value`)
+      return [token, normalizeTokenValue(values.get(name), library.prefix)]
+    }),
+  )
+}
+
+function logicalComponentTokens(library, component) {
+  const namespace = component === 'field-decorator' ? 'field' : component
+  const tokenPrefix = `--${library.prefix}-${namespace}-`
+  const names = new Set()
+  for (const file of walk(resolve(library.source, component))) {
+    if (/\/(?:docs|example|__demos__|__tests__)\//.test(file)) continue
+    for (const name of definitions(readFileSync(file, 'utf8'), library.prefix)) {
+      if (name.startsWith(tokenPrefix)) names.add(name.slice(tokenPrefix.length))
+    }
+  }
+  return [...names].sort()
+}
+
+export function collectThemeContract({ cedarSource, mapleSource }) {
+  const libraries = [
+    { name: 'Cedar', prefix: contract.prefixes.cedar, source: cedarSource },
+    { name: 'Maple', prefix: contract.prefixes.maple, source: mapleSource },
+  ]
+  const [cedar, maple] = libraries
+  const cedarSystem = logicalSystemTokens(cedar)
+  const mapleSystem = logicalSystemTokens(maple)
+  assert.deepEqual(cedarSystem, mapleSystem, 'Cedar and Maple system token names differ')
+
+  const components = {}
+  for (const component of contract.components) {
+    const cedarTokens = logicalComponentTokens(cedar, component)
+    const mapleTokens = logicalComponentTokens(maple, component)
+    const sharedTokens = cedarTokens.filter((token) => mapleTokens.includes(token))
+    components[component] = sharedTokens
+  }
+  return { system: cedarSystem, components }
+}
+
+export function checkThemeContract(options) {
+  const actual = collectThemeContract(options)
+  assert.deepEqual(actual.system, contract.tokens.system, 'System tokens differ from @sparknest/theme-contract-vue')
+  assert.deepEqual(actual.components, contract.tokens.components, 'Component tokens differ from @sparknest/theme-contract-vue')
+
+  for (const library of [
+    { name: 'Cedar', key: 'cedar', prefix: contract.prefixes.cedar, source: options.cedarSource },
+    { name: 'Maple', key: 'maple', prefix: contract.prefixes.maple, source: options.mapleSource },
+  ]) {
+    assert.deepEqual(
+      logicalSystemTokenValues(library),
+      contract.systemTokenValues,
+      `${library.name}: system token values differ from @sparknest/theme-contract-vue`,
+    )
+    const platformSystem = contract.platformSystemTokenValues?.[library.key] ?? {}
+    for (const token of Object.keys(platformSystem)) assert.ok(!(token in contract.systemTokenValues), `${library.name}: duplicate system default ${token}`)
+    assert.deepEqual(logicalSystemTokenValues(library, platformSystem), platformSystem, `${library.name}: platform system defaults differ`)
+    assert.deepEqual([...Object.keys(contract.systemTokenValues), ...Object.keys(platformSystem)].sort(), actual.system, `${library.name}: every system default must be governed`)
+    for (const [component, expected] of Object.entries(contract.componentTokenValues)) {
+      assert.deepEqual(
+        logicalComponentTokenValues(library, component),
+        expected,
+        `${library.name} ${component}: component token values differ from @sparknest/theme-contract-vue`,
+      )
+    }
+    for (const [component, expected] of Object.entries(contract.platformComponentTokenValues?.[library.key] ?? {})) {
+      for (const token of Object.keys(expected)) {
+        assert.ok(!(token in (contract.componentTokenValues[component] ?? {})), `${library.name} ${component}/${token}: duplicate shared and platform default`)
+      }
+      assert.deepEqual(
+        logicalComponentTokenValues(library, component, expected),
+        expected,
+        `${library.name} ${component}: registered platform defaults differ`,
+      )
+    }
+    for (const component of contract.components) {
+      const common = contract.tokens.components[component] ?? []
+      const current = logicalComponentTokens(library, component)
+      const missing = common.filter((token) => !current.includes(token))
+      assert.deepEqual(missing, [], `${library.name} ${component} misses common component tokens`)
+      if (!contract.platformExtensions[library.key]?.includes(component)) {
+        assert.deepEqual(current, common, `${library.name} ${component} has undeclared platform token extensions`)
+      }
+    }
+  }
+
+  for (const [name, prefix, source] of [
+    ['Cedar', contract.prefixes.cedar, options.cedarSource],
+    ['Maple', contract.prefixes.maple, options.mapleSource],
+  ]) {
+    const system = new Set(actual.system.map((token) => `--${prefix}-sys-${token}`))
+    const unresolved = []
+    for (const file of walk(source)) {
+      for (const reference of systemReferences(readFileSync(file, 'utf8'), prefix)) {
+        if (!system.has(reference)) unresolved.push(`${reference} in ${file}`)
+      }
+    }
+    assert.deepEqual(unresolved, [], `${name}: unresolved system token references`)
+  }
+
+  checkThemeOverrides('Cedar', options.cedarSource, contract.prefixes.cedar)
+  checkThemeOverrides('Maple', options.mapleSource, contract.prefixes.maple)
+  checkLegacyTokens('Cedar', options.cedarSource, contract.prefixes.cedar, legacyDenylist.cedar)
+  checkLegacyTokens('Maple', options.mapleSource, contract.prefixes.maple, legacyDenylist.maple)
+  checkComponentDocs('Cedar', options.cedarSource, contract.prefixes.cedar)
+  checkComponentDocs('Maple', options.mapleSource, contract.prefixes.maple)
+
+  return {
+    systemCount: actual.system.length,
+    systemValueCount: Object.keys(contract.systemTokenValues).length,
+    platformSystemValueCount: Object.values(contract.platformSystemTokenValues ?? {}).reduce((count, values) => count + Object.keys(values).length, 0),
+    componentValueCount: Object.values(contract.componentTokenValues).reduce(
+      (count, values) => count + Object.keys(values).length,
+      0,
+    ),
+    componentCount: contract.components.length,
+    platformComponentValueCount: Object.values(contract.platformComponentTokenValues ?? {}).reduce(
+      (count, components) => count + Object.values(components).reduce((sum, values) => sum + Object.keys(values).length, 0), 0,
+    ),
+  }
+}

package/src/index.mjs

@@ -0,0 +1,25 @@
+import contract from '../contracts/theme-contract.json' with { type: 'json' }
+
+export const themeContract = Object.freeze(contract)
+export const parityComponents = Object.freeze([...contract.components])
+export const contractRules = Object.freeze({ ...contract.rules })
+export const systemTokens = Object.freeze([...contract.tokens.system])
+export const systemTokenValues = Object.freeze({ ...contract.systemTokenValues })
+export const platformSystemTokenValues = Object.freeze(
+  Object.fromEntries(Object.entries(contract.platformSystemTokenValues ?? {}).map(([name, values]) => [name, Object.freeze({ ...values })])),
+)
+export const componentTokenValues = Object.freeze(
+  Object.fromEntries(
+    Object.entries(contract.componentTokenValues).map(([name, values]) => [name, Object.freeze({ ...values })]),
+  ),
+)
+export const componentTokens = Object.freeze(
+  Object.fromEntries(Object.entries(contract.tokens.components).map(([name, tokens]) => [name, Object.freeze([...tokens])])),
+)
+export const platformExtensions = Object.freeze(contract.platformExtensions)
+export const platformComponentTokenValues = Object.freeze(
+  Object.fromEntries(Object.entries(contract.platformComponentTokenValues ?? {}).map(([platform, components]) => [
+    platform,
+    Object.freeze(Object.fromEntries(Object.entries(components).map(([name, values]) => [name, Object.freeze({ ...values })]))),
+  ])),
+)

package/src/normalize-value.mjs

@@ -0,0 +1,14 @@
+// Normalize syntax only. Preserve semantic var() dependencies and units.
+export function normalizeTokenValue(value, prefix) {
+  // Only unwrap a complete Less escaped value. Ordinary quoted CSS strings and
+  // partial/mismatched expressions must retain their string semantics.
+  const literal = value.trim().replace(/^~(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)')$/, (_, double, single) => double ?? single)
+  const names = literal.replaceAll(`--${prefix}-`, '--PREFIX-')
+    .replace(/var\(~(['"])(--PREFIX-[a-z0-9-]+)\1\)/g, 'var($2)')
+  return names.split(/("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')/g).map((part, index) => index % 2 ? part : part
+    .replace(/\s+/g, ' ').replace(/\(\s+/g, '(').replace(/\s+\)/g, ')')
+    .replace(/(^|[\s,(])(-?)\.(\d+)/g, '$1$20.$3')
+    .replace(/rgb\(\s*(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)\s*\/\s*([\d.]+)(%)?\s*\)/g,
+      (_, red, green, blue, alpha, percent) => `rgba(${red}, ${green}, ${blue}, ${Number(alpha) / (percent ? 100 : 1)})`)
+  ).join('')
+}

package/src/normalize-value.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeTokenValue } from './normalize-value.mjs';
+
+test('normalizes literal modern alpha colors without erasing token relationships', () => {
+  assert.equal(normalizeTokenValue('0 4px 10px rgb(0 0 0 / 10%)', 'c'), '0 4px 10px rgba(0, 0, 0, 0.1)');
+  assert.equal(normalizeTokenValue('rgb(1 2 3 / .5)', 'mp'), 'rgba(1, 2, 3, 0.5)');
+  assert.equal(normalizeTokenValue("var(~'--c-sys-radius-md')", 'c'), 'var(--PREFIX-sys-radius-md)');
+  assert.equal(normalizeTokenValue('rgba(var(--mp-gray-6), 0.2)', 'mp'), 'rgba(var(--PREFIX-gray-6), 0.2)');
+  assert.equal(normalizeTokenValue('calc(var(--c-x) * 2)', 'c'), 'calc(var(--PREFIX-x) * 2)');
+  assert.equal(normalizeTokenValue('.5', 'c'), '0.5');
+  assert.equal(normalizeTokenValue('-.5s .2s', 'c'), '-0.5s 0.2s');
+  assert.equal(normalizeTokenValue('calc(\n  (var(--c-a) / 2) -\n (var(--c-b) / 2)\n)', 'c'), 'calc((var(--PREFIX-a) / 2) - (var(--PREFIX-b) / 2))');
+  assert.equal(normalizeTokenValue('"Font  Name .5"', 'c'), '"Font  Name .5"');
+});
+
+test('unwraps only complete Less escaped literals before syntax normalization', () => {
+  assert.equal(normalizeTokenValue("~'rgb(255 255 255 / 35%)'", 'c'), 'rgba(255, 255, 255, 0.35)');
+  assert.equal(normalizeTokenValue('  ~"rgb(0 0 0 / 55%)"  ', 'mp'), 'rgba(0, 0, 0, 0.55)');
+  assert.equal(normalizeTokenValue("~'var(--c-sys-content-brand)'", 'c'), 'var(--PREFIX-sys-content-brand)');
+  assert.equal(normalizeTokenValue("'rgb(0 0 0 / 35%)'", 'c'), "'rgb(0 0 0 / 35%)'");
+  assert.equal(normalizeTokenValue("~'rgb(0 0 0 / 35%)' suffix", 'c'), "~'rgb(0 0 0 / 35%)' suffix");
+  assert.equal(normalizeTokenValue("~'red\"", 'c'), "~'red\"");
+});

package/src/platform-values.test.mjs

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import contract from '../contracts/theme-contract.json' with { type: 'json' };
+import { platformComponentTokenValues, platformSystemTokenValues } from './index.mjs';
+import { normalizeTokenValue } from './normalize-value.mjs';
+
+test('every system value is registered exactly once per platform', () => {
+  for (const platform of ['cedar', 'maple']) {
+    const names = [...Object.keys(contract.systemTokenValues), ...Object.keys(contract.platformSystemTokenValues[platform])];
+    assert.equal(new Set(names).size, names.length);
+    assert.deepEqual(names.sort(), contract.tokens.system);
+    assert.ok(Object.isFrozen(platformSystemTokenValues[platform]));
+  }
+});
+
+test('platform component defaults never contradict shared defaults', () => {
+  for (const platform of ['cedar', 'maple']) {
+    for (const [component, values] of Object.entries(contract.platformComponentTokenValues[platform])) {
+      assert.ok(Object.isFrozen(platformComponentTokenValues[platform][component]));
+      for (const [token, value] of Object.entries(values)) {
+        assert.equal(contract.componentTokenValues[component]?.[token], undefined);
+        assert.equal(typeof value, 'string');
+        assert.ok(value.length);
+      }
+    }
+  }
+});
+
+test('Checkbox mark-color is shared by name and preserves both existing platform defaults', () => {
+  assert.ok(contract.tokens.components.checkbox.includes('mark-color'));
+  assert.equal(contract.componentTokenValues.checkbox['mark-color'], undefined);
+  for (const [platform, repository, prefix, role] of [
+    ['cedar', 'cedar-design-web', 'c', 'surface-default'],
+    ['maple', 'maple-design-mobile', 'mp', 'content-on-bright'],
+  ]) {
+    const expected = `var(--PREFIX-sys-color-${role})`;
+    const source = readFileSync(new URL(`../../../../${repository}/packages/ui/src/checkbox/style/token.less`, import.meta.url), 'utf8');
+    const value = source.match(new RegExp(`--${prefix}-checkbox-mark-color:\\s*([^;]+);`))?.[1];
+    assert.ok(value, `${platform}: Checkbox mark-color must be declared`);
+    assert.equal(normalizeTokenValue(value, prefix), expected);
+    assert.equal(platformComponentTokenValues[platform].checkbox['mark-color'], expected);
+  }
+});
+
+test('Switch checked text has a public contract without changing platform foreground defaults', () => {
+  assert.ok(contract.tokens.components.switch.includes('checked-text-color'));
+  assert.equal(contract.componentTokenValues.switch['checked-text-color'], undefined);
+  for (const [platform, repository, prefix, expected] of [
+    ['cedar', 'cedar-design-web', 'c', 'var(--PREFIX-switch-text-color)'],
+    ['maple', 'maple-design-mobile', 'mp', 'var(--PREFIX-switch-text-color)'],
+  ]) {
+    const root = new URL(`../../../../${repository}/packages/ui/src/`, import.meta.url);
+    const tokens = readFileSync(new URL('switch/style/token.less', root), 'utf8');
+    const value = tokens.match(new RegExp(`--${prefix}-switch-checked-text-color:\\s*([^;]+);`))?.[1];
+    assert.ok(value);
+    assert.equal(normalizeTokenValue(value, prefix), expected);
+    assert.equal(platformComponentTokenValues[platform].switch['checked-text-color'], expected);
+    const style = readFileSync(new URL(`switch/style/${platform === 'maple' ? 'switch' : 'index'}.less`, root), 'utf8');
+    assert.match(style, new RegExp(`&--checked &__text\\s*\\{[^}]*color: var\\(--${prefix}-switch-checked-text-color\\)`));
+  }
+});