@hegemonart/get-design-done 1.33.5 → 1.34.1

package/scripts/lib/authority-watcher/index.cjs

@@ -170,6 +170,147 @@ function buildKfmCandidate(article, options) {
   };
 }
 
+// -------------------------------------------------------------------
+// Plan 33.6-03 (SC#8) — OpenRouter catalog drift
+// -------------------------------------------------------------------
+
+/**
+ * Index a catalog `models[]` by id, keeping only well-formed rows
+ * (objects with a non-empty string `id`). Last write wins on dup ids.
+ *
+ * @param {unknown} models
+ * @returns {Map<string, object>}
+ */
+function indexById(models) {
+  const map = new Map();
+  if (!Array.isArray(models)) return map;
+  for (const m of models) {
+    if (m && typeof m === 'object' && typeof m.id === 'string' && m.id.length > 0) {
+      map.set(m.id, m);
+    }
+  }
+  return map;
+}
+
+/**
+ * Best-effort "is this model flagged deprecated?" signal. Tolerant of the
+ * several shapes an upstream catalog might use: a boolean `deprecated`,
+ * or a `status`/`lifecycle`/`availability` string containing "deprecat".
+ *
+ * @param {object} model
+ * @returns {boolean}
+ */
+function isDeprecatedFlag(model) {
+  if (!model || typeof model !== 'object') return false;
+  if (model.deprecated === true) return true;
+  for (const key of ['status', 'lifecycle', 'availability', 'state']) {
+    const v = model[key];
+    if (typeof v === 'string' && /deprecat/i.test(v)) return true;
+  }
+  return false;
+}
+
+/**
+ * Stable string-compare of a single pricing field. A pricing field is the
+ * catalog's `pricing.prompt` / `pricing.completion` (strings like "0.000003").
+ * Compares as strings (the catalog stores them as strings) after a defensive
+ * String() coercion; missing → ''.
+ */
+function priceStr(model, field) {
+  if (!model || typeof model !== 'object' || !model.pricing || typeof model.pricing !== 'object') {
+    return '';
+  }
+  const v = model.pricing[field];
+  return v === undefined || v === null ? '' : String(v);
+}
+
+function pricingChanged(prevModel, currModel) {
+  return (
+    priceStr(prevModel, 'prompt') !== priceStr(currModel, 'prompt') ||
+    priceStr(prevModel, 'completion') !== priceStr(currModel, 'completion')
+  );
+}
+
+/**
+ * Diff a prior vs current OpenRouter catalog (`models[]` arrays) and classify
+ * each delta. Plan 33.6-03 / SC#8.
+ *
+ * Classification per id:
+ *   - `new-model`      — id in curr, not in prev.
+ *   - `withdrawn`      — id in prev, not in curr.
+ *   - `deprecated`     — id in BOTH, and the curr row carries a deprecated/status
+ *                        flag (best-effort `isDeprecatedFlag`). Takes precedence
+ *                        over a coincident pricing change.
+ *   - `pricing-change` — id in BOTH, not deprecated, with a changed
+ *                        pricing.prompt or pricing.completion.
+ *   - (unchanged ids produce NO entry.)
+ *
+ * Surfacing (the actionable "a model you pinned is going away" signal):
+ *   `surfaced === true` ONLY when `change ∈ {deprecated, withdrawn}` AND the id
+ *   is in `options.overrides` (the configured `openrouter_tier_overrides`
+ *   values). `new-model` / `pricing-change` are classified but `surfaced:false`
+ *   (noise control per CONTEXT). A deprecated/withdrawn id NOT in overrides is
+ *   also `surfaced:false`.
+ *
+ * Pure, zero deps, NEVER throws — garbage inputs degrade to `[]`.
+ *
+ * @param {Array<object>} prevModels prior catalog `models[]`
+ * @param {Array<object>} currModels current catalog `models[]`
+ * @param {object} [options]
+ * @param {Array<string>} [options.overrides] configured openrouter_tier_overrides id values
+ * @returns {Array<{id:string, change:('new-model'|'pricing-change'|'deprecated'|'withdrawn'), surfaced:boolean}>}
+ */
+function diffOpenRouterCatalog(prevModels, currModels, options) {
+  try {
+    const prev = indexById(prevModels);
+    const curr = indexById(currModels);
+
+    const opts = options && typeof options === 'object' ? options : {};
+    const overrideList = Array.isArray(opts.overrides) ? opts.overrides : [];
+    const overrides = new Set(overrideList.filter(x => typeof x === 'string' && x.length > 0));
+
+    /** @type {Array<{id:string, change:string, surfaced:boolean}>} */
+    const out = [];
+
+    // Deterministic id order: union of all ids, sorted ascending. Keeps the
+    // output stable for a fixed input pair (no Date, no randomness).
+    const allIds = new Set([...prev.keys(), ...curr.keys()]);
+    const sortedIds = [...allIds].sort();
+
+    for (const id of sortedIds) {
+      const inPrev = prev.has(id);
+      const inCurr = curr.has(id);
+      let change = null;
+
+      if (inCurr && !inPrev) {
+        change = 'new-model';
+      } else if (inPrev && !inCurr) {
+        change = 'withdrawn';
+      } else {
+        // id in both.
+        const currModel = curr.get(id);
+        if (isDeprecatedFlag(currModel)) {
+          change = 'deprecated';
+        } else if (pricingChanged(prev.get(id), currModel)) {
+          change = 'pricing-change';
+        } else {
+          continue; // unchanged → no delta
+        }
+      }
+
+      const actionable = change === 'deprecated' || change === 'withdrawn';
+      const surfaced = actionable && overrides.has(id);
+      out.push({ id, change, surfaced });
+    }
+
+    return out;
+  } catch {
+    // Absolute backstop — diffOpenRouterCatalog NEVER throws (parity with the
+    // never-throws discipline of the 33.6 adapter/fetcher).
+    return [];
+  }
+}
+
 /**
  * Classify a list of fetched articles into events. Emits one kfm-candidate
  * per whitelist-matched article. Other articles produce no events here
@@ -192,10 +333,16 @@ module.exports = {
   classifyArticles,
   matchesKfmWhitelist,
   buildKfmCandidate,
+  // Plan 33.6-03 (SC#8) — OpenRouter catalog weekly-diff classifier. Added as a
+  // sibling pure function; the existing API above is unchanged.
+  diffOpenRouterCatalog,
   // Exposed for tests / advanced consumers.
   KFM_WHITELIST_PATTERNS,
   MAX_RAW_EXCERPT,
   _deriveSymptom: deriveSymptom,
   _derivePatternHint: derivePatternHint,
   _truncateExcerpt: truncateExcerpt,
+  _indexById: indexById,
+  _isDeprecatedFlag: isDeprecatedFlag,
+  _pricingChanged: pricingChanged,
 };

package/scripts/lib/budget-enforcer.cjs

@@ -407,6 +407,15 @@ function computeCost(args, opts) {
  *   Phase 27. The peer-CLI ID when `runtime_role === "peer"` (e.g.
  *   `"gemini"`, `"codex"`). Omitted from output when absent or when
  *   `runtime_role === "host"`.
+ * @param {string} [args.provider]
+ *   Phase 33.6 / Plan 33.6-03 (SC#6). The resolution provider — set to
+ *   `"openrouter"` by the caller when the model was resolved via the
+ *   OpenRouter tier-resolver adapter
+ *   (`scripts/lib/tier-resolver-openrouter.cjs`). Additive/back-compat:
+ *   when absent (the native-resolution default + every pre-33.6 caller)
+ *   the key is OMITTED — exactly how `peer_id` is omitted for host rows —
+ *   so the legacy on-disk cost-row shape stays byte-stable. Only a
+ *   non-empty string is threaded; anything else is dropped.
  * @returns {object}
  */
 function buildCostEventPayload(args) {
@@ -433,6 +442,13 @@ function buildCostEventPayload(args) {
       : null;
     out.peer_id = pid;
   }
+  // Phase 33.6 SC#6 — additive provider tag. Threaded ONLY when the caller
+  // passes a non-empty string (e.g. "openrouter" when the OpenRouter adapter
+  // resolved the model). Omitted otherwise, mirroring peer_id, so the legacy
+  // cost-row shape stays stable for native-resolution + pre-33.6 callers.
+  if (args && typeof args.provider === 'string' && args.provider.length > 0) {
+    out.provider = args.provider;
+  }
   return out;
 }
 

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 };