@hegemonart/get-design-done 1.33.6 → 1.34.2

package/scripts/lib/design-tokens/_native-shared.cjs

@@ -0,0 +1,206 @@
+/**
+ * design-tokens/_native-shared.cjs — shared precision-contract helpers for the
+ * native emitters (swift.cjs / compose.cjs / flutter.cjs), Phase 34.1 Plan 01.
+ *
+ * The single implementation of the PRECISION CONTRACT documented in
+ * reference/native-platforms.md, so all three emitters convert color /
+ * dimension / typography / non-mappable values identically:
+ *   COLOR      hex #RGB/#RGBA/#RRGGBB/#RRGGBBAA -> 8-bit channels EXACT;
+ *              #RGB/#RGBA expand by nibble duplication; alpha tracked.
+ *   DIMENSION  Npx | unit-less -> integer (round-half-up) + logical-px double.
+ *   TYPOGRAPHY strings -> pass-through.
+ *   NON-MAPPABLE var()/calc()/gradient/rem/em -> verbatim, excluded.
+ *
+ * Pure: no fs, no network, no Date, no process.env, no child_process (D-10).
+ */
+
+'use strict';
+
+// Markers embedded in every emitted line so the symmetric re-extractors can
+// recover the EXACT canonical token key (native identifiers are mangled, e.g.
+// `color-primary` -> `colorPrimary`, so the key must travel alongside).
+const TOKEN_MARKER = '// token: ';
+const NONMAPPABLE_MARKER = '// non-mappable: ';
+
+const HEX_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const PX_RE = /^-?\d+(?:\.\d+)?px$/;
+const UNITLESS_RE = /^-?\d+(?:\.\d+)?$/;
+const NONMAPPABLE_RE = /(^var\(|^calc\(|gradient\(|\b(rem|em)$|\d(rem|em)$)/i;
+
+/**
+ * Read `.tokens` from a Phase-23 TokenSet or a bare {tokens} map.
+ * @param {*} tokenSet
+ * @returns {Record<string,string>}
+ */
+function readTokens(tokenSet) {
+  if (
+    !tokenSet ||
+    typeof tokenSet !== 'object' ||
+    !tokenSet.tokens ||
+    typeof tokenSet.tokens !== 'object'
+  ) {
+    throw new TypeError(
+      'native emitter: expected { tokens: Record<string,string> } (or a Phase-23 TokenSet)',
+    );
+  }
+  return tokenSet.tokens;
+}
+
+/**
+ * Stable, sorted [key, value] entries so emit(x) === emit(x) byte-for-byte.
+ * @param {Record<string,string>} tokens
+ * @returns {[string,string][]}
+ */
+function sortedEntries(tokens) {
+  return Object.keys(tokens)
+    .sort()
+    .map((k) => [k, String(tokens[k])]);
+}
+
+/**
+ * Classify a token value per the precision contract. The value is the
+ * authority; the key prefix is only a hint (see native-platforms.md §2).
+ * @param {string} _key
+ * @param {string} value
+ * @returns {'non-mappable'|'color'|'dimension'|'typography'}
+ */
+function classify(_key, value) {
+  const v = String(value).trim();
+  if (NONMAPPABLE_RE.test(v)) return 'non-mappable';
+  if (HEX_RE.test(v)) return 'color';
+  if (PX_RE.test(v) || UNITLESS_RE.test(v)) return 'dimension';
+  return 'typography';
+}
+
+/**
+ * Expand #RGB/#RGBA shorthand to #RRGGBB/#RRGGBBAA and split into 8-bit
+ * channels. Alpha defaults to opaque (255) when absent; `hadAlpha` records
+ * whether the source carried an alpha channel so the re-extractor can emit a
+ * 6- or 8-digit hex faithfully.
+ * @param {string} hex
+ * @returns {{r:number,g:number,b:number,a:number,hadAlpha:boolean}}
+ */
+function parseHexChannels(hex) {
+  let h = String(hex).trim().replace(/^#/, '');
+  let hadAlpha = false;
+  if (h.length === 3) {
+    h = h.split('').map((c) => c + c).join('');
+  } else if (h.length === 4) {
+    h = h.split('').map((c) => c + c).join('');
+    hadAlpha = true;
+  } else if (h.length === 8) {
+    hadAlpha = true;
+  }
+  const r = parseInt(h.slice(0, 2), 16);
+  const g = parseInt(h.slice(2, 4), 16);
+  const b = parseInt(h.slice(4, 6), 16);
+  const a = hadAlpha ? parseInt(h.slice(6, 8), 16) : 255;
+  return { r, g, b, a, hadAlpha };
+}
+
+/**
+ * Recover the canonical hex from 8-bit channels. Emits 6-digit #RRGGBB when
+ * the original had no alpha, 8-digit #RRGGBBAA when it did (contract: implied
+ * opaque alpha is dropped on the way back so #3B82F6 round-trips exactly).
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @param {number} a
+ * @param {boolean} hadAlpha
+ * @returns {string}
+ */
+function channelsToHex(r, g, b, a, hadAlpha) {
+  const h2 = (n) => (n & 0xff).toString(16).padStart(2, '0');
+  const base = `#${h2(r)}${h2(g)}${h2(b)}`;
+  return hadAlpha ? `${base}${h2(a)}` : base;
+}
+
+/**
+ * Pack channels into a Compose/Flutter 0xAARRGGBB literal (uppercase digits).
+ * @param {{r:number,g:number,b:number,a:number}} ch
+ * @returns {string} e.g. "0xFF3B82F6"
+ */
+function channelsToArgbLiteral({ r, g, b, a }) {
+  const h2 = (n) => (n & 0xff).toString(16).toUpperCase().padStart(2, '0');
+  return `0x${h2(a)}${h2(r)}${h2(g)}${h2(b)}`;
+}
+
+/**
+ * Strip a 0xAARRGGBB literal back into channels.
+ * @param {string} literal e.g. "0xFF3B82F6"
+ * @returns {{r:number,g:number,b:number,a:number}}
+ */
+function argbLiteralToChannels(literal) {
+  const h = String(literal).replace(/^0x/i, '').padStart(8, '0');
+  return {
+    a: parseInt(h.slice(0, 2), 16),
+    r: parseInt(h.slice(2, 4), 16),
+    g: parseInt(h.slice(4, 6), 16),
+    b: parseInt(h.slice(6, 8), 16),
+  };
+}
+
+/**
+ * px (or unit-less) -> nearest integer, round-half-up (for pt/dp).
+ * @param {string} value
+ * @returns {number}
+ */
+function pxToInt(value) {
+  const n = parseFloat(String(value));
+  return Math.floor(n + 0.5);
+}
+
+/**
+ * px (or unit-less) -> logical-px double form string for Dart (`16` -> `16.0`).
+ * @param {string} value
+ * @returns {string}
+ */
+function pxToDouble(value) {
+  const n = parseFloat(String(value));
+  return Number.isInteger(n) ? `${n}.0` : String(n);
+}
+
+/**
+ * Recover the canonical `Npx` string from an emitted numeric form.
+ * @param {string|number} num
+ * @returns {string}
+ */
+function numToPx(num) {
+  const n = parseFloat(String(num));
+  return Number.isInteger(n) ? `${n}px` : `${n}px`;
+}
+
+/**
+ * dash-case token -> camelCase Swift/Kotlin/Dart identifier.
+ * `color-primary` -> `colorPrimary`; leading digit gets a `t` prefix.
+ * @param {string} key
+ * @returns {string}
+ */
+function swiftIdent(key) {
+  let id = String(key).replace(/[^A-Za-z0-9]+(.)?/g, (_, c) =>
+    c ? c.toUpperCase() : '',
+  );
+  if (!id) id = 'token';
+  if (/^[0-9]/.test(id)) id = 't' + id;
+  return id;
+}
+
+module.exports = {
+  TOKEN_MARKER,
+  NONMAPPABLE_MARKER,
+  HEX_RE,
+  PX_RE,
+  UNITLESS_RE,
+  NONMAPPABLE_RE,
+  readTokens,
+  sortedEntries,
+  classify,
+  parseHexChannels,
+  channelsToHex,
+  channelsToArgbLiteral,
+  argbLiteralToChannels,
+  pxToInt,
+  pxToDouble,
+  numToPx,
+  swiftIdent,
+};

package/scripts/lib/design-tokens/compose.cjs

@@ -0,0 +1,150 @@
+/**
+ * design-tokens/compose.cjs — Jetpack Compose (Kotlin) theme emitter +
+ * re-extractor (Phase 34.1 Plan 01).
+ *
+ * Consumes the canonical Phase-23 token map ({ tokens: Record<string,string> })
+ * and emits a deterministic Kotlin theme source string: `Color` vals, a
+ * `Shapes` block (radius tokens), a `Typography` block (font/text tokens), and
+ * a `MaterialTheme` wiring object — per the PRECISION CONTRACT in
+ * reference/native-platforms.md.
+ *
+ * Precision contract:
+ *   COLOR      hex -> Color(0xAARRGGBB) long. 8-bit channels EXACT; #RGB
+ *              expands; alpha 0xFF when absent.
+ *   DIMENSION  Npx -> N.dp (integer dp, round-half-up).
+ *   TYPOGRAPHY strings -> Kotlin string literal, pass-through.
+ *   NON-MAPPABLE var()/calc()/gradient/rem/em -> verbatim comment, EXCLUDED.
+ *
+ * Each emitted token line carries a `// token: <original-key>` marker so the
+ * symmetric `reextractCompose(source)` recovers the exact canonical key+value.
+ * Pure: no fs, no network, no Date, no process.env, no child_process (D-10).
+ */
+
+'use strict';
+
+const {
+  TOKEN_MARKER,
+  NONMAPPABLE_MARKER,
+  readTokens,
+  sortedEntries,
+  classify,
+  parseHexChannels,
+  channelsToArgbLiteral,
+  argbLiteralToChannels,
+  channelsToHex,
+  pxToInt,
+  swiftIdent,
+} = require('./_native-shared.cjs');
+
+const RADIUS_RE = /(^|[^a-z])radius/i;
+
+/**
+ * Emit a Jetpack Compose / Kotlin theme source string from a token set.
+ *
+ * @param {{tokens: Record<string,string>}|Record<string,string>} tokenSet
+ * @returns {string}
+ */
+function emitCompose(tokenSet) {
+  const tokens = readTokens(tokenSet);
+  const entries = sortedEntries(tokens);
+  const lines = [];
+  lines.push('// Generated by get-design-done — Jetpack Compose theme tokens.');
+  lines.push('// See reference/native-platforms.md (token-bridge precision contract).');
+  lines.push('import androidx.compose.ui.graphics.Color');
+  lines.push('import androidx.compose.ui.unit.dp');
+  lines.push('import androidx.compose.material3.Shapes');
+  lines.push('import androidx.compose.material3.Typography');
+  lines.push('import androidx.compose.foundation.shape.RoundedCornerShape');
+  lines.push('');
+  lines.push('object GDDTheme {');
+
+  // Colors
+  for (const [key, value] of entries) {
+    if (classify(key, value) !== 'color') continue;
+    const { r, g, b, a, hadAlpha } = parseHexChannels(value);
+    lines.push(
+      `    val ${swiftIdent(key)} = Color(${channelsToArgbLiteral({ r, g, b, a })}) ${TOKEN_MARKER}${key} hadAlpha=${hadAlpha ? 1 : 0}`,
+    );
+  }
+
+  // Dimensions (dp)
+  for (const [key, value] of entries) {
+    if (classify(key, value) !== 'dimension') continue;
+    lines.push(
+      `    val ${swiftIdent(key)} = ${pxToInt(value)}.dp ${TOKEN_MARKER}${key}`,
+    );
+  }
+
+  // Typography (strings)
+  for (const [key, value] of entries) {
+    if (classify(key, value) !== 'typography') continue;
+    lines.push(
+      `    val ${swiftIdent(key)} = ${JSON.stringify(value)} ${TOKEN_MARKER}${key}`,
+    );
+  }
+
+  // Non-mappable — verbatim, excluded from identity set
+  for (const [key, value] of entries) {
+    if (classify(key, value) !== 'non-mappable') continue;
+    lines.push(`    ${NONMAPPABLE_MARKER}${key} = ${value}`);
+  }
+
+  // Shapes block (from radius dimension tokens) — wires dp into RoundedCornerShape
+  lines.push('');
+  lines.push('    val Shapes = Shapes(');
+  for (const [key, value] of entries) {
+    if (classify(key, value) !== 'dimension') continue;
+    if (!RADIUS_RE.test(key)) continue;
+    lines.push(`        // ${key}: RoundedCornerShape(${pxToInt(value)}.dp)`);
+  }
+  lines.push('    )');
+
+  // Typography block (MaterialTheme wiring) — references the font tokens above
+  lines.push('    val Typography = Typography()');
+  lines.push('}');
+  lines.push('');
+  return lines.join('\n');
+}
+
+const COMPOSE_COLOR_RE = new RegExp(
+  String.raw`val \w+ = Color\((0x[0-9a-fA-F]{8})\)\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)\s+hadAlpha=([01])`,
+);
+const COMPOSE_DIM_RE = new RegExp(
+  String.raw`val \w+ = (\d+)\.dp\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)`,
+);
+const COMPOSE_STR_RE = new RegExp(
+  String.raw`val \w+ = ("(?:[^"\\]|\\.)*")\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)`,
+);
+
+/**
+ * Recover the canonical token map from an emitted Compose source string.
+ * Non-mappable lines and the Shapes-comment lines are NOT recovered.
+ *
+ * @param {string} source
+ * @returns {{tokens: Record<string,string>}}
+ */
+function reextractCompose(source) {
+  /** @type {Record<string,string>} */
+  const tokens = {};
+  for (const line of String(source).split(/\r?\n/)) {
+    if (line.includes(NONMAPPABLE_MARKER)) continue;
+    let m;
+    if ((m = COMPOSE_COLOR_RE.exec(line))) {
+      const ch = argbLiteralToChannels(m[1]);
+      tokens[m[2]] = channelsToHex(ch.r, ch.g, ch.b, ch.a, m[3] === '1');
+    } else if ((m = COMPOSE_DIM_RE.exec(line))) {
+      tokens[m[2]] = `${m[1]}px`;
+    } else if ((m = COMPOSE_STR_RE.exec(line))) {
+      tokens[m[2]] = JSON.parse(m[1]);
+    }
+  }
+  return { tokens };
+}
+
+module.exports = { emitCompose, reextractCompose };

package/scripts/lib/design-tokens/flutter.cjs

@@ -0,0 +1,128 @@
+/**
+ * design-tokens/flutter.cjs — Flutter (Dart) theme emitter + re-extractor
+ * (Phase 34.1 Plan 01).
+ *
+ * Consumes the canonical Phase-23 token map ({ tokens: Record<string,string> })
+ * and emits a deterministic Dart theme source string: a `GDDTheme` constants
+ * class plus a `themeData()` builder wiring `ColorScheme` + `TextTheme` into a
+ * `ThemeData` — per the PRECISION CONTRACT in reference/native-platforms.md.
+ *
+ * Precision contract:
+ *   COLOR      hex -> Color(0xAARRGGBB). 8-bit channels EXACT; #RGB expands;
+ *              alpha 0xFF when absent.
+ *   DIMENSION  Npx -> logical-px double (`16` -> `16.0`); NOT rounded.
+ *   TYPOGRAPHY strings -> Dart string literal, pass-through.
+ *   NON-MAPPABLE var()/calc()/gradient/rem/em -> verbatim comment, EXCLUDED.
+ *
+ * Each emitted token line carries a `// token: <original-key>` marker so the
+ * symmetric `reextractFlutter(source)` recovers the exact canonical key+value.
+ * Pure: no fs, no network, no Date, no process.env, no child_process (D-10).
+ */
+
+'use strict';
+
+const {
+  TOKEN_MARKER,
+  NONMAPPABLE_MARKER,
+  readTokens,
+  sortedEntries,
+  classify,
+  parseHexChannels,
+  channelsToArgbLiteral,
+  argbLiteralToChannels,
+  channelsToHex,
+  pxToDouble,
+  swiftIdent,
+} = require('./_native-shared.cjs');
+
+/**
+ * Emit a Flutter / Dart theme source string from a token set.
+ *
+ * @param {{tokens: Record<string,string>}|Record<string,string>} tokenSet
+ * @returns {string}
+ */
+function emitFlutter(tokenSet) {
+  const tokens = readTokens(tokenSet);
+  const entries = sortedEntries(tokens);
+  const lines = [];
+  lines.push('// Generated by get-design-done — Flutter theme tokens.');
+  lines.push('// See reference/native-platforms.md (token-bridge precision contract).');
+  lines.push("import 'package:flutter/material.dart';");
+  lines.push('');
+  lines.push('class GDDTheme {');
+
+  for (const [key, value] of entries) {
+    const kind = classify(key, value);
+    const ident = swiftIdent(key);
+    if (kind === 'color') {
+      const { r, g, b, a, hadAlpha } = parseHexChannels(value);
+      lines.push(
+        `  static const ${ident} = Color(${channelsToArgbLiteral({ r, g, b, a })}); ${TOKEN_MARKER}${key} hadAlpha=${hadAlpha ? 1 : 0}`,
+      );
+    } else if (kind === 'dimension') {
+      lines.push(
+        `  static const ${ident} = ${pxToDouble(value)}; ${TOKEN_MARKER}${key}`,
+      );
+    } else if (kind === 'typography') {
+      lines.push(
+        `  static const ${ident} = ${JSON.stringify(value)}; ${TOKEN_MARKER}${key}`,
+      );
+    } else {
+      lines.push(`  ${NONMAPPABLE_MARKER}${key} = ${value}`);
+    }
+  }
+
+  // ThemeData builder wiring ColorScheme + TextTheme (MaterialTheme analog).
+  lines.push('');
+  lines.push('  static ThemeData themeData() => ThemeData(');
+  lines.push('        colorScheme: ColorScheme.fromSeed(seedColor: GDDTheme.colorPrimary),');
+  lines.push('        textTheme: const TextTheme(),');
+  lines.push('      );');
+  lines.push('}');
+  lines.push('');
+  return lines.join('\n');
+}
+
+const FLUTTER_COLOR_RE = new RegExp(
+  String.raw`static const \w+ = Color\((0x[0-9a-fA-F]{8})\);\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)\s+hadAlpha=([01])`,
+);
+const FLUTTER_DIM_RE = new RegExp(
+  String.raw`static const \w+ = (\d+(?:\.\d+)?);\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)`,
+);
+const FLUTTER_STR_RE = new RegExp(
+  String.raw`static const \w+ = ("(?:[^"\\]|\\.)*");\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)`,
+);
+
+/**
+ * Recover the canonical token map from an emitted Flutter source string.
+ * Non-mappable lines + the ThemeData builder lines are NOT recovered.
+ *
+ * @param {string} source
+ * @returns {{tokens: Record<string,string>}}
+ */
+function reextractFlutter(source) {
+  /** @type {Record<string,string>} */
+  const tokens = {};
+  for (const line of String(source).split(/\r?\n/)) {
+    if (line.includes(NONMAPPABLE_MARKER)) continue;
+    let m;
+    if ((m = FLUTTER_COLOR_RE.exec(line))) {
+      const ch = argbLiteralToChannels(m[1]);
+      tokens[m[2]] = channelsToHex(ch.r, ch.g, ch.b, ch.a, m[3] === '1');
+    } else if ((m = FLUTTER_DIM_RE.exec(line))) {
+      // Recover canonical Npx: a logical-px double `16.0` -> `16px`.
+      tokens[m[2]] = `${parseFloat(m[1])}px`;
+    } else if ((m = FLUTTER_STR_RE.exec(line))) {
+      tokens[m[2]] = JSON.parse(m[1]);
+    }
+  }
+  return { tokens };
+}
+
+module.exports = { emitFlutter, reextractFlutter };

package/scripts/lib/design-tokens/index.cjs

@@ -17,6 +17,12 @@ const { readJsConst } = require('./js-const.cjs');
 const { readTailwind } = require('./tailwind.cjs');
 const { readFigma } = require('./figma.cjs');
 
+// Phase 34.1 — native theme emitters (token-bridge, D-02: extend the engine,
+// do not fork a native IR). See reference/native-platforms.md.
+const { emitSwift, reextractSwift } = require('./swift.cjs');
+const { emitCompose, reextractCompose } = require('./compose.cjs');
+const { emitFlutter, reextractFlutter } = require('./flutter.cjs');
+
 /**
  * @typedef {Object} TokenSet
  * @property {Object<string, string>} tokens
@@ -97,4 +103,11 @@ module.exports = {
   readJsConst,
   readTailwind,
   readFigma,
+  // Phase 34.1 native token-bridge emitters + symmetric re-extractors.
+  emitSwift,
+  emitCompose,
+  emitFlutter,
+  reextractSwift,
+  reextractCompose,
+  reextractFlutter,
 };

package/scripts/lib/design-tokens/swift.cjs

@@ -0,0 +1,122 @@
+/**
+ * design-tokens/swift.cjs — SwiftUI theme emitter + re-extractor
+ * (Phase 34.1 Plan 01).
+ *
+ * Consumes the canonical Phase-23 token map ({ tokens: Record<string,string> })
+ * and emits a deterministic SwiftUI theme source string: an `enum GDDTheme`
+ * exposing static `Color` / `CGFloat` (pt) / `String` constants per the
+ * PRECISION CONTRACT in reference/native-platforms.md.
+ *
+ * Precision contract (the round-trip's definition of "identity preserved"):
+ *   COLOR      hex #RGB/#RRGGBB/#RRGGBBAA -> Color(red:G/255 ...). 8-bit
+ *              channels EXACT (numerator-over-255 form avoids float drift);
+ *              #RGB expands to #RRGGBB; alpha opaque (255) when absent.
+ *   DIMENSION  Npx -> CGFloat integer points (round-half-up).
+ *   TYPOGRAPHY font-family / strings -> String literal, pass-through.
+ *   NON-MAPPABLE var()/calc()/gradient/rem/em -> verbatim trailing comment,
+ *              EXCLUDED from the round-trip identity set.
+ *
+ * Each emitted token line carries a `// token: <original-key>` marker so the
+ * symmetric `reextractSwift(source)` recovers the exact canonical key + value.
+ * Pure: no fs, no network, no Date, no process.env, no child_process (D-10).
+ */
+
+'use strict';
+
+const {
+  TOKEN_MARKER,
+  NONMAPPABLE_MARKER,
+  readTokens,
+  sortedEntries,
+  classify,
+  parseHexChannels,
+  channelsToHex,
+  pxToInt,
+  swiftIdent,
+} = require('./_native-shared.cjs');
+
+/**
+ * Emit a SwiftUI theme source string from a token set.
+ *
+ * @param {{tokens: Record<string,string>}|Record<string,string>} tokenSet
+ * @returns {string}
+ */
+function emitSwift(tokenSet) {
+  const tokens = readTokens(tokenSet);
+  const lines = [];
+  lines.push('// Generated by get-design-done — SwiftUI theme tokens.');
+  lines.push('// See reference/native-platforms.md (token-bridge precision contract).');
+  lines.push('import SwiftUI');
+  lines.push('');
+  lines.push('enum GDDTheme {');
+  for (const [key, value] of sortedEntries(tokens)) {
+    const ident = swiftIdent(key);
+    const kind = classify(key, value);
+    if (kind === 'color') {
+      const { r, g, b, a, hadAlpha } = parseHexChannels(value);
+      const alphaSlot = hadAlpha
+        ? `, opacity: ${a}.0/255.0`
+        : `, opacity: 255.0/255.0`;
+      lines.push(
+        `    static let ${ident} = Color(red: ${r}.0/255.0, green: ${g}.0/255.0, blue: ${b}.0/255.0${alphaSlot}) ${TOKEN_MARKER}${key} hadAlpha=${hadAlpha ? 1 : 0}`,
+      );
+    } else if (kind === 'dimension') {
+      lines.push(
+        `    static let ${ident}: CGFloat = ${pxToInt(value)} ${TOKEN_MARKER}${key}`,
+      );
+    } else if (kind === 'typography') {
+      lines.push(
+        `    static let ${ident} = ${JSON.stringify(value)} ${TOKEN_MARKER}${key}`,
+      );
+    } else {
+      // non-mappable — verbatim, excluded from identity set
+      lines.push(`    ${NONMAPPABLE_MARKER}${key} = ${value}`);
+    }
+  }
+  lines.push('}');
+  lines.push('');
+  return lines.join('\n');
+}
+
+const SWIFT_COLOR_RE = new RegExp(
+  String.raw`Color\(red:\s*(\d+)\.0/255\.0,\s*green:\s*(\d+)\.0/255\.0,\s*blue:\s*(\d+)\.0/255\.0,\s*opacity:\s*(\d+)\.0/255\.0\)\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)\s+hadAlpha=([01])`,
+);
+const SWIFT_DIM_RE = new RegExp(
+  String.raw`:\s*CGFloat\s*=\s*(\d+)\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)`,
+);
+const SWIFT_STR_RE = new RegExp(
+  String.raw`static let \w+ = ("(?:[^"\\]|\\.)*")\s*` +
+    TOKEN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
+    String.raw`(\S+)`,
+);
+
+/**
+ * Recover the canonical token map from an emitted SwiftUI source string.
+ * Non-mappable lines (NONMAPPABLE_MARKER) are intentionally NOT recovered.
+ *
+ * @param {string} source
+ * @returns {{tokens: Record<string,string>}}
+ */
+function reextractSwift(source) {
+  /** @type {Record<string,string>} */
+  const tokens = {};
+  for (const line of String(source).split(/\r?\n/)) {
+    if (line.includes(NONMAPPABLE_MARKER)) continue;
+    let m;
+    if ((m = SWIFT_COLOR_RE.exec(line))) {
+      const [, r, g, b, a, key, hadAlpha] = m;
+      tokens[key] = channelsToHex(+r, +g, +b, +a, hadAlpha === '1');
+    } else if ((m = SWIFT_DIM_RE.exec(line))) {
+      tokens[m[2]] = `${m[1]}px`;
+    } else if ((m = SWIFT_STR_RE.exec(line))) {
+      tokens[m[2]] = JSON.parse(m[1]);
+    }
+  }
+  return { tokens };
+}
+
+module.exports = { emitSwift, reextractSwift };