okchroma 0.6.1 → 0.8.0

package/dist-lib/index.mjs

@@ -725,29 +725,14 @@ function perceptualDarkC(L, H2, nativeC, keep = KEEP_DARK, gamut = MASTER_GAMUT)
 var SHARED_NAMES = {
   1: "paper-1",
   2: "paper-3",
-  // stop 3 renamed wash-3 → paper-3 (owner 2026-07-24, elevation round): it is a
-  // PLANE in both themes (light sink / dark pop), so it belongs to the surface band.
-  // NAME ONLY — generation is index-keyed and unchanged; the chalk-collision machinery
-  // (collision.ts CHALK_STOPS) deliberately still spans stops 3–7. (The requirement
-  // spec's `group` label followed the band to 'paper' on 2026-08-31 — labels only,
-  // the spans never moved; see spec.ts groupOf.)
-  // Stage B (owner 2026-08-07, names only): relabeled to the ROOT_L-derived digit,
-  // paper-5 — same band, same index.
   3: "paper-5",
   4: "chalk-8",
   5: "chalk-11",
   6: "chalk-15",
   7: "chalk-20",
   8: "highlighter-26",
-  // THE PEN BAND (C49, owner 2026-08-05): the first text stop + emphasis fill (the
-  // 2026-07-29 highlight collapse — the old highlight-9 and on-highlight are
-  // deleted; this stop carries both jobs, its on-color a paper token), the between
-  // text stop (a value the retired text-cta hover state used to generate bespokely,
-  // promoted to a normal stop), and the strong text stop. The three read as states
-  // ARE the text-style cta (owner 2026-08-12). C49 restored the top
-  // two pre-collapse stop INDICES (11, and the off-scale anchor's 12 — emitted as a
-  // literal in cssRender, not through this table) with the between stop taking the
-  // vacated index 10; the indices (9/10/11) are unchanged since.
+  // the pen band: the first text stop doubles as the emphasis fill, the between stop and
+  // the strong stop follow; the three read as states are the text-style CTA (C49)
   9: "pencil-47",
   10: "pen-58",
   11: "pen-70"
@@ -779,63 +764,22 @@ var STAMP_LEAF = {
   EDGE: STAMP_STATE_LEAVES[STAMP_EDGE],
   ON: STAMP_STATE_LEAVES[STAMP_ON]
 };
-var SYSTEM_LEAF = {
-  ABS_BLACK: "system/abs-black",
-  ABS_WHITE: "system/abs-white",
-  SURFACE: {
-    DIM: "system/surface/dim",
-    LOW: "system/surface/low",
-    MID: "system/surface/mid",
-    HIGH: "system/surface/high"
-  },
-  ALPHA: {
-    TRANSPARENT: "system/alpha/transparent",
-    INK: "system/alpha/ink",
-    // the DIRECTIONAL ladders (owner 2026-08-31, renaming the 2026-08-18 bare rungs
-    // and the 2026-08-29 inverse ladder): away-from-bg is the page-polarity pole
-    // (black in light, white in dark), toward-bg the flipped pole — STATE LAYERS for
-    // INVERTED grounds, whose polarity is opposite the page's. (Never call toward-bg
-    // a "chalk": that word belongs to the tinted band stops.) The reversal lives in
-    // the engine: a consumer on an inverted ground names one token and never picks a
-    // pole. Colored fills never ride these; their states stay engine-solved stops.
-    // Rungs are two-digit percent, harmonizing with shadow-04/08/12.
-    AWAY_FROM_BG_06: "system/alpha/away-from-bg/06",
-    AWAY_FROM_BG_08: "system/alpha/away-from-bg/08",
-    AWAY_FROM_BG_16: "system/alpha/away-from-bg/16",
-    TOWARD_BG_06: "system/alpha/toward-bg/06",
-    TOWARD_BG_08: "system/alpha/toward-bg/08",
-    TOWARD_BG_16: "system/alpha/toward-bg/16",
-    SHADOW_04: "system/alpha/shadow-04",
-    SHADOW_08: "system/alpha/shadow-08",
-    SHADOW_12: "system/alpha/shadow-12"
-  },
-  // the OPACITY LADDER's rows: bare numbers, never colors. `alpha` above is the group
-  // of colors that carry transparency; `opacity` is the numbers they compose with
-  // (values in cssRender OPACITY_RUNGS; the ext plugin zones these under utility/).
-  OPACITY: {
-    "004": "system/opacity/004",
-    "008": "system/opacity/008",
-    "012": "system/opacity/012",
-    "016": "system/opacity/016",
-    "024": "system/opacity/024",
-    "032": "system/opacity/032",
-    "048": "system/opacity/048",
-    "064": "system/opacity/064"
-  }
-};
-var SURFACE_PLANE_LAW = {
-  [SYSTEM_LEAF.SURFACE.DIM]: { light: SHARED_NAMES[3], dark: PAPER_0 },
-  [SYSTEM_LEAF.SURFACE.LOW]: { light: SHARED_NAMES[2], dark: SHARED_NAMES[1] },
-  [SYSTEM_LEAF.SURFACE.MID]: { light: SHARED_NAMES[1], dark: SHARED_NAMES[2] },
-  [SYSTEM_LEAF.SURFACE.HIGH]: { light: PAPER_0, dark: SHARED_NAMES[3] }
-};
+var cssVarName = (path) => `--${path.join("-")}`;
+var figmaPathOf = (path) => path.join("/");
+var familyPath = (family, leaf) => [family, ...(STAMP_STATE_LEAVES[leaf] ?? leaf).split("/")];
+var LINK_GROUP = "link";
+var LINK_POSTURES = ["default", "inverse"];
+var LINK_STATES = ["enabled", "hover", "pressed"];
+var linkPath = (posture, state) => [LINK_GROUP, posture, state];
+var ABSOLUTE_GROUP = "absolute";
+var absolutePath = (family) => [ABSOLUTE_GROUP, family];
+var COLOR_GROUP = "color";
 var TOKEN_ORDER = [
   ...Object.values(SHARED_NAMES),
   STAMP_FILL,
   STAMP_FILL_HOVER,
   STAMP_FILL_PRESSED,
-  STAMP_ON,
-  "identity"
+  STAMP_ON
 ];
 function tokenOrder(name) {
   const i = TOKEN_ORDER.indexOf(name);
@@ -2764,8 +2708,34 @@ var COLOR_WORD = {
   [FAMILY.positive]: " (green)",
   [FAMILY.info]: " (blue)"
 };
-var PAPER = { req: "backgrounds, inverted text", theming: (f) => TINT[f], collides: true };
-var CHALK = { req: "decorative borders, inverted text, illos, signal hierarchy", theming: (f) => TINT[f], collides: true };
+var COLLIDES = "shifts to avoid similar colors";
+var GUARANTEE_SCOPE = {
+  highlighter: { level: AA_LARGE, grounds: ["paper"] },
+  pencil: { level: AA_BODY, grounds: ["paper"] },
+  pen: { level: AA_BODY, grounds: ["paper", "chalk"] }
+};
+var BAND_STOPS = {
+  highlighter: ["highlighter-26"],
+  pencil: ["pencil-47"],
+  pen: ["pen-58", "pen-70"]
+};
+var list = (words) => words.length > 1 ? `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}` : words[0];
+var ofFamilies = (fam) => fam === FAMILY.neutral ? "of every family" : "of this family and of the neutral";
+var fromFamilies = (fam) => fam === FAMILY.neutral ? "from every family" : "from this family and from the neutral";
+var claimOf = (band) => (fam) => `${GUARANTEE_SCOPE[band].level} on every ${GUARANTEE_SCOPE[band].grounds.join(" and ")} ${ofFamilies(fam)}`;
+var groundLine = (ground) => (fam) => {
+  const bands = Object.keys(GUARANTEE_SCOPE).filter((b) => GUARANTEE_SCOPE[b].grounds.includes(ground));
+  const byLevel = /* @__PURE__ */ new Map();
+  for (const b of bands) {
+    const stops = [...BAND_STOPS[b], ...b === "pen" && fam === FAMILY.neutral ? ["pen-100"] : []];
+    byLevel.set(GUARANTEE_SCOPE[b].level, [...byLevel.get(GUARANTEE_SCOPE[b].level) ?? [], ...stops]);
+  }
+  const clears = [...byLevel.entries()].map(([level, stops]) => `${list(stops)} clear${stops.length === 1 ? "s" : ""} it as ${level}`).join("; ");
+  const notHeld = Object.keys(GUARANTEE_SCOPE).filter((b) => !bands.includes(b));
+  return `${clears}, ${fromFamilies(fam)}${notHeld.length ? `; ${list(notHeld.map((b) => `the ${b}`))} ${notHeld.length === 1 ? "is" : "are"} not held against it` : ""}`;
+};
+var PAPER = { req: "backgrounds, inverted text", theming: (f) => TINT[f], collides: true, ground: groundLine("paper") };
+var CHALK = { req: "decorative borders, inverted text, illos, signal hierarchy", theming: (f) => TINT[f], collides: true, ground: groundLine("chalk") };
 var solved = (f) => `${TINT[f]}; re-solved to clear its floor`;
 var OVERLAY = {
   req: "translucent backgrounds that hold their reading on any paper",
@@ -2777,106 +2747,123 @@ var SCALE = {
   "paper-99-overlay": OVERLAY,
   "paper-3": PAPER,
   "paper-97-overlay": OVERLAY,
-  "paper-5": { req: "backgrounds, inverted text", theming: (f) => `${TINT[f]}. Worst background text stops must clear.`, collides: true },
+  "paper-5": { req: "backgrounds, inverted text", theming: (f) => `${TINT[f]}. Worst background text stops must clear.`, collides: true, ground: (f) => `${groundLine("paper")(f)}; the ground the text stops are solved against` },
   "paper-95-overlay": OVERLAY,
   "chalk-8": CHALK,
   "chalk-11": CHALK,
   "chalk-15": CHALK,
   "chalk-20": CHALK,
-  // ("icons" KEPT through the 2026-08-28 on-flood strip (owner): an "icon" query
-  // landing on the highlighter rows is worth its ic-ON-s noise — the one surviving body carrier)
-  "highlighter-26": { req: "focus rings, icons, large text, translucent state layers over any ground", contrast: AA_LARGE, theming: solved, collides: true },
-  "pencil-47": { req: "regular text, inverted backgrounds", contrast: AA_BODY, theming: solved, collides: true },
-  "pen-58": { req: "regular text, inverted backgrounds", contrast: AA_BODY, theming: solved, collides: true },
-  // ("high-emphasis" reworded 2026-08-12: the surface planes took low/high as label
-  // words, and a body carrying either floods that token's picker search — the C50 law;
-  // "strong-emphasis" reworded 2026-08-28: str-ON-g fed the "on" flood)
-  "pen-70": { req: "heavy-emphasis text, inverted backgrounds", contrast: AA_BODY, theming: solved, collides: true },
-  // the stamp family (cta words → solid 2026-08-18, solid → stamp 2026-08-27). "CTA" stays in
-  // these bodies on purpose: it stopped being a token label, so it floods nothing,
-  // and a designer's "cta" query still lands on these rows.
-  "stamp/fill": { req: "CTAs", theming: (f) => `fully re-solved per theme and family${COLOR_WORD[f]}` },
-  "stamp/fill-hover": { req: "CTA pointer-over state", theming: (f) => `follows its rest fill${COLOR_WORD[f]}` },
-  "stamp/fill-pressed": { req: "CTA pressed state", theming: (f) => `follows its rest fill${COLOR_WORD[f]}` },
-  "stamp/edge": { req: "min APCA visibility", theming: (f) => `draws for CTAs that sit close to the page; strength per family tier${COLOR_WORD[f]}` },
-  // ("fill" reworded out 2026-08-18: fill became a label word and is foreign here)
-  "stamp/on": { req: "text over the CTA color", contrast: `${AA_BODY} over its CTA`, theming: (f) => `whichever pole passes; quiet CTAs take the soft pole${COLOR_WORD[f]}` }
+  // ("icons" stays although it carries "on": an "icon" query landing on the highlighter
+  // rows is worth that noise)
+  "highlighter-26": { req: "focus rings, icons, large text, translucent state layers over any ground", contrast: AA_LARGE, claim: claimOf("highlighter"), theming: solved, collides: true },
+  "pencil-47": { req: "regular text, inverted backgrounds", contrast: AA_BODY, claim: claimOf("pencil"), theming: solved, collides: true },
+  "pen-58": { req: "regular text, inverted backgrounds", contrast: AA_BODY, claim: claimOf("pen"), theming: solved, collides: true },
+  // ("heavy-emphasis": "high" and "low" are plane words in the community plugin and
+  // "strong" carries "on")
+  "pen-70": { req: "heavy-emphasis text, inverted backgrounds", contrast: AA_BODY, claim: claimOf("pen"), theming: solved, collides: true },
+  // the stamp family. "CTA" stays in these bodies on purpose: it is not a token label, so
+  // it floods nothing, and a designer's "cta" query lands on these rows.
+  // the usage lines are the owner's guidance, for the document rendering: the fill is
+  // misused as a standalone color in the wild
+  "stamp/fill": {
+    req: "CTAs",
+    theming: (f) => `fully re-solved per theme and family${COLOR_WORD[f]}`,
+    use: "primary button fills; optional for avatars, badges and other elements that carry text. Not a standalone color: it has no contrast guarantee of its own, only its on-text has one. Use it alone or with its hover and pressed states. Always bordered with its edge"
+  },
+  "stamp/fill-hover": { req: "CTA pointer-over state", theming: (f) => `follows its rest fill${COLOR_WORD[f]}`, use: "the pointer-over state of the fill, with the fill; for nothing else. Always bordered with the edge" },
+  "stamp/fill-pressed": { req: "CTA pressed state", theming: (f) => `follows its rest fill${COLOR_WORD[f]}`, use: "the pressed state of the fill, with the fill; for nothing else. Always bordered with the edge" },
+  "stamp/edge": { req: "min APCA visibility", theming: (f) => `draws for CTAs that sit close to the page; strength per family tier${COLOR_WORD[f]}`, use: "the border of the fill and its states, always rendered with them and never without them (it resolves to transparent unless the fill sits close to the page); for nothing else" },
+  // ("fill" is a label word and foreign here)
+  "stamp/on": { req: "text over the CTA color", contrast: `${AA_BODY} over its CTA`, theming: (f) => `whichever pole passes; quiet CTAs take the soft pole${COLOR_WORD[f]}`, use: "the only text color over the fill; never elsewhere" }
+};
+var NEUTRAL_ONLY = {
+  // the pole is measured against the neutral's own stops only; as text, it is the on-color
+  // of every family's emphasis fill (the band audit holds that)
+  "paper-0": { req: "backgrounds, inverted text", theming: (f) => TINT[f], ground: () => `the neutral's highlighter-26 clears it as ${AA_LARGE}; its pencil-47, pen-58, pen-70 and pen-100 clear it as ${AA_BODY}; as text, ${AA_BODY} on every family's pencil-47` },
+  // the literal pole carries no tint, so no theming line
+  "pen-100": { req: "max-emphasis text", contrast: AA_BODY, claim: () => `${AA_BODY} on every paper and chalk of every family` }
 };
-var ABS = { req: "extreme poles for CTAs, aliased global endpoints" };
-var OFFSET = { req: "min APCA visibility", theming: "offsets CTAs in themes where they sit close to the page" };
-var OFFSET_INVERSE = { req: "state layers over inverted backgrounds", theming: "the offset ladder with its pole flipped, so inverted grounds keep the same rungs" };
-var SHADOW = { req: "drop shadows" };
-var OPACITY_RUNG = { req: "translucency weight for any color", theming: "a bare number; a translucent row composes its color with one rung" };
-var OPACITY_STATE = { req: "translucency weight for any color; the state layer weight of the non-text stop over any ground", theming: "a bare number; a translucent row composes its color with one rung" };
-var PLANE = (req) => ({ req, theming: "aliased to the gray ramp" });
 var LINK = (state, contrast) => ({
   req: "links" + state,
   contrast,
-  theming: "rides the theme\u2019s link color; custom seed re-solves; overridable per theme"
+  claim: () => `${contrast} on every paper of the neutral`,
+  theming: "rides the theme\u2019s link color; custom seed re-solves; overridable per theme",
+  use: "hyperlinks; not a text-style CTA, which is the text stops read as states"
 });
 var LINK_INVERSE = (state, contrast) => ({
   req: "links over inverted backgrounds" + state,
   contrast,
-  theming: "same seed as the link, re-solved for inverted backgrounds; overridable per theme"
+  claim: () => `${contrast} on any family's pen-70`,
+  theming: "same seed as the link, re-solved for inverted backgrounds; overridable per theme",
+  use: "hyperlinks on a pen-70 ground; not a text-style CTA"
 });
 var SYSTEM = {
-  "system/abs-black": ABS,
-  "system/abs-white": ABS,
-  // (the community system/pen-100 row RETIRED 2026-08-28 with its STATIC_UTILS entry:
-  // the anchor is engine-resolved and rides the neutral in BOTH plugins now —
-  // NEUTRAL_ONLY above. Old files' static rows orphan unwritten.)
-  "system/abs-primary": { req: "identity seed reference", theming: "the theme\u2019s own input, as given" },
-  // ("companion" reworded 2026-08-28: compani-ON fed the "on" flood)
-  "system/abs-alt": { req: "identity seed reference", theming: "the theme\u2019s paired input, as given" },
-  "system/alpha/transparent": { req: "aliased off-states" },
-  // the OPACITY LADDER: bare numbers a translucent color row composes with (the
-  // scrim is the absolute black at the top rung). No conformance line of its own:
-  // the state-layer claim rides the non-text stop these weights apply to
-  "system/opacity/004": OPACITY_RUNG,
-  "system/opacity/008": OPACITY_STATE,
-  "system/opacity/012": OPACITY_STATE,
-  "system/opacity/016": OPACITY_STATE,
-  "system/opacity/024": OPACITY_STATE,
-  "system/opacity/032": OPACITY_STATE,
-  "system/opacity/048": OPACITY_RUNG,
-  "system/opacity/064": OPACITY_RUNG,
-  // ("fills" reworded 2026-08-18: fill became a label word and is foreign here;
-  // "on-color" reworded 2026-08-28: the bare on fed the "on" flood)
-  "system/alpha/ink": { req: "soft text pole for quiet CTAs" },
-  "system/alpha/away-from-bg/06": OFFSET,
-  "system/alpha/away-from-bg/08": OFFSET,
-  "system/alpha/away-from-bg/16": OFFSET,
-  // the inverse ladder: the offset rungs with the pole flipped per mode, for
-  // chalks and edges over inverted backgrounds ("interaction" avoided in the
-  // bodies: acti-ON would feed the "on" flood)
-  "system/alpha/toward-bg/06": OFFSET_INVERSE,
-  "system/alpha/toward-bg/08": OFFSET_INVERSE,
-  "system/alpha/toward-bg/16": OFFSET_INVERSE,
-  "system/alpha/shadow-04": SHADOW,
-  "system/alpha/shadow-08": SHADOW,
-  "system/alpha/shadow-12": SHADOW,
-  // ("elevation" dropped 2026-08-28: elevati-ON fed the "on" flood; the sibling
-  // planes never carried the word)
-  "system/surface/dim": PLANE("recessed plane"),
-  "system/surface/low": PLANE("resting page plane"),
-  "system/surface/mid": PLANE("raised plane \u2014 cards, menus"),
-  // ("overlays" reworded 2026-08-13: paper-overlay took the word as a label — the C50 law)
-  "system/surface/high": PLANE("topmost plane \u2014 modals, dialogs"),
-  "system/link/default/enabled": LINK("", AA_BODY),
-  "system/link/default/hover": LINK(" pointer-over", AA_BODY),
-  "system/link/default/pressed": LINK(" pressed", AA_BODY),
-  "system/link/inverse/enabled": LINK_INVERSE("", AA_BODY),
-  "system/link/inverse/hover": LINK_INVERSE(" pointer-over", AA_BODY),
-  "system/link/inverse/pressed": LINK_INVERSE(" pressed", AA_BODY)
+  "absolute/brand": { req: "identity seed reference", theming: "the theme\u2019s own input, as given", use: "a reference value (logos, swatches of the input); never a UI color, it carries no contrast guarantee" },
+  "absolute/brand-alt": { req: "identity seed reference", theming: "the theme\u2019s paired input, as given", use: "a reference value (logos, swatches of the input); never a UI color, it carries no contrast guarantee" },
+  "link/default/enabled": LINK("", AA_BODY),
+  "link/default/hover": LINK(" pointer-over", AA_BODY),
+  "link/default/pressed": LINK(" pressed", AA_BODY),
+  "link/inverse/enabled": LINK_INVERSE("", AA_BODY),
+  "link/inverse/hover": LINK_INVERSE(" pointer-over", AA_BODY),
+  "link/inverse/pressed": LINK_INVERSE(" pressed", AA_BODY)
 };
 var PREFIXES = [
-  // community spellings FIRST: the 2026-08-21 family rename made the ext word a
-  // PREFIX of the community shapes ('brand/' would shadow 'brand/primary/' and
-  // 'brand/alt/'), so most-specific must be tried before the family words
+  // community spellings first: the family word is a prefix of the community shapes
+  // ('brand/' would shadow 'brand/primary/' and 'brand/alt/'), so most-specific wins
   ["brand/primary/", FAMILY.brandPrimary],
   ["brand/alt/", FAMILY.brandSecondary],
   ...FAMILIES.map((f) => [f + "/", f])
 ];
+var ZONE_MAP = [
+  // brand-alt before brand: canonicalize is first-match startsWith, and brand is a prefix
+  // of brand-alt
+  ["system/abs-alt", "absolute/brand-alt"],
+  ["system/abs-primary", "absolute/brand"],
+  ["system/link/", "link/"],
+  ["color/", ""],
+  ["base/", ""],
+  ["primitive/", ""]
+];
+function canonicalize(path) {
+  for (const [prefix, home] of ZONE_MAP)
+    if (path.startsWith(prefix)) return home + path.slice(prefix.length);
+  return path;
+}
+function bodyFor(path) {
+  const canonical = canonicalize(path);
+  if (SYSTEM[canonical]) return { body: SYSTEM[canonical], fam: FAMILY.neutral };
+  const hit = PREFIXES.find(([p]) => canonical.startsWith(p));
+  if (!hit) return void 0;
+  const [prefix, fam] = hit;
+  const leaf = canonical.slice(prefix.length);
+  const body = fam === FAMILY.neutral && NEUTRAL_ONLY[leaf] || SCALE[leaf];
+  return body ? { body, fam } : void 0;
+}
+function describeToken(path) {
+  const canonical = canonicalize(path);
+  const title = canonical.replace(/[/-]/g, " ");
+  const hit = bodyFor(canonical);
+  if (!hit) return title;
+  const { body, fam } = hit;
+  const lines = [title, `Req for: ${body.req}`];
+  if (body.contrast) lines.push(body.contrast);
+  if (body.theming) lines.push(`Theming: ${typeof body.theming === "function" ? body.theming(fam) : body.theming}`);
+  if (body.collides && SIGNALS.includes(fam)) lines.push(COLLIDES);
+  return lines.join("\n");
+}
+function describeDocument(path) {
+  const hit = bodyFor(canonicalize(path));
+  if (!hit) return "";
+  const { body, fam } = hit;
+  const lines = [`Req for: ${body.req}`];
+  if (body.claim) lines.push(body.claim(fam));
+  else if (body.contrast) lines.push(body.contrast);
+  if (body.ground) lines.push(`Ground: ${body.ground(fam)}`);
+  if (body.use) lines.push(`Use: ${body.use}`);
+  if (body.theming) lines.push(`Theming: ${typeof body.theming === "function" ? body.theming(fam) : body.theming}`);
+  if (body.collides && SIGNALS.includes(fam)) lines.push(COLLIDES);
+  return lines.join("\n");
+}
 
 // src/engine/signals.ts
 var SIGNALS2 = [
@@ -3195,7 +3182,7 @@ var OUTLINE_PRESSED_ALPHA = 0.18;
 var SOFT_ON_CTA_ALPHA = { light: 0.75, dark: 0.8 };
 function softOnCtaPasses(s, mode) {
   const white = mode === "light" ? s.onFillTextIsWhite : s.onFillTextIsWhiteDark;
-  const pole = white ? 1 : 0;
+  const pole2 = white ? 1 : 0;
   const a = SOFT_ON_CTA_ALPHA[mode];
   const states = mode === "light" ? [s.cta, s.ctaHover, s.ctaPressed] : [s.ctaDark, s.ctaHoverDark, s.ctaPressedDark];
   const lin = (v2) => v2 <= 0.04045 ? v2 / 12.92 : ((v2 + 0.055) / 1.055) ** 2.4;
@@ -3205,7 +3192,7 @@ function softOnCtaPasses(s, mode) {
     const e = srgbEmitChannels(st);
     const fr = q2(e.r), fg = q2(e.g), fb = q2(e.b);
     const fillY = relY(fr, fg, fb);
-    const textY = relY(pole * a + fr * (1 - a), pole * a + fg * (1 - a), pole * a + fb * (1 - a));
+    const textY = relY(pole2 * a + fr * (1 - a), pole2 * a + fg * (1 - a), pole2 * a + fb * (1 - a));
     if (contrastRatio(textY, fillY) < 4.5) return false;
   }
   return true;
@@ -3451,7 +3438,7 @@ var p3Differs = (s) => s.C > clampChromaToGamut(s.L, s.C, s.H, "srgb") + 1e-4;
 var P3_SUPPORTS = "@supports (color: color(display-p3 1 1 1))";
 var P3_MEDIA = "@media (color-gamut: p3)";
 function stopsToVars(stops, prefix) {
-  return [...stops].sort((a, b) => tokenOrder(stopTokenName(a.stop)) - tokenOrder(stopTokenName(b.stop))).map((s) => `  --${prefix}-${stopTokenName(s.stop)}: ${stopHex(s)};`).join("\n");
+  return [...stops].sort((a, b) => tokenOrder(stopTokenName(a.stop)) - tokenOrder(stopTokenName(b.stop))).map((s) => `  ${cssVarName(familyPath(prefix, stopTokenName(s.stop)))}: ${stopHex(s)};`).join("\n");
 }
 var onColor = (white) => white ? "#ffffff" : "#000000";
 var CTA_BORDER_LC_FLOOR = 15;
@@ -3462,34 +3449,7 @@ function pageStopFor(neutral, mode) {
 }
 var OFFSET_ALPHAS = { 6: 0.06, 8: 0.08, 16: 0.16 };
 var ctaBorderRung = (prefix) => prefix === CSS_NEUTRAL ? 8 : prefix === CSS_SECONDARY ? 6 : 16;
-var offsetLeafName = (rung) => String(rung).padStart(2, "0");
-var offsetVarName = (rung) => `--alpha-away-from-bg-${offsetLeafName(rung)}`;
-var OPACITY_RUNGS = { 4: 0.04, 8: 0.08, 12: 0.12, 16: 0.16, 24: 0.24, 32: 0.32, 48: 0.48, 64: 0.64 };
-var INTERACTION_RUNGS = [8, 12, 16, 24, 32];
-var opacityLeafName = (rung) => String(rung).padStart(3, "0");
-var opacityVarName = (rung) => `--opacity-${opacityLeafName(rung)}`;
-var opacityTokenPath = (rung) => SYSTEM_LEAF.OPACITY[opacityLeafName(rung)];
-var SHADOW_ALPHAS = {
-  4: { light: OPACITY_RUNGS[4], dark: OPACITY_RUNGS[32] },
-  8: { light: OPACITY_RUNGS[8], dark: OPACITY_RUNGS[48] },
-  12: { light: OPACITY_RUNGS[12], dark: OPACITY_RUNGS[64] }
-};
-var SCRIM_ALPHA = OPACITY_RUNGS[64];
-var DISABLED_OPACITY = 0.38;
-var TRANSPARENT_VAR = "--alpha-transparent";
 var offsetRgba = (rung, mode) => mode === "light" ? `rgba(0, 0, 0, ${OFFSET_ALPHAS[rung]})` : `rgba(255, 255, 255, ${OFFSET_ALPHAS[rung]})`;
-var alphaRootVars = (mode) => [
-  `  ${TRANSPARENT_VAR}: transparent;`,
-  // the opacity ladder, mode-invariant like transparent; repeated in the dark block to
-  // keep the set together
-  ...Object.keys(OPACITY_RUNGS).map(Number).map((r) => `  ${opacityVarName(r)}: ${OPACITY_RUNGS[r]};`),
-  ...Object.keys(OFFSET_ALPHAS).map(Number).sort((a, b) => a - b).map((r) => `  ${offsetVarName(r)}: ${offsetRgba(r, mode)};`),
-  // the toward-bg ladder (the 2026-08-29 inverse ladder, renamed 2026-08-31): the
-  // same rungs, pole flipped per mode — state layers for INVERTED grounds (never
-  // called a "chalk" — that word is the tinted band's). One spelling with the Figma
-  // row: --alpha-toward-bg-06 ↔ system/alpha/toward-bg/06.
-  ...Object.keys(OFFSET_ALPHAS).map(Number).sort((a, b) => a - b).map((r) => `  --alpha-toward-bg-${offsetLeafName(r)}: ${offsetRgba(r, mode === "light" ? "dark" : "light")};`)
-];
 function ctaPageLc(s, mode, page) {
   const cta = mode === "light" ? s.cta : s.ctaDark;
   return Math.abs(apcaLc(apcaY(cta.r, cta.g, cta.b), apcaY(page.r, page.g, page.b)));
@@ -3504,23 +3464,20 @@ function brandKindBody(prefix, s, mode, page, on = prefix === CSS_NEUTRAL ? "sof
   const onCta = mode === "light" ? s.onFillTextIsWhite : s.onFillTextIsWhiteDark;
   const border = ctaNeedsBorder(s, mode, page);
   const scaleBlock = [
-    ...stops.map((x2) => ({ name: stopTokenName(x2.stop), line: `  --${prefix}-${stopTokenName(x2.stop)}: ${stopHex(x2)};` }))
+    ...stops.map((x2) => ({ name: stopTokenName(x2.stop), line: `  ${cssVarName(familyPath(prefix, stopTokenName(x2.stop)))}: ${stopHex(x2)};` }))
   ].sort((a, b) => tokenOrder(a.name) - tokenOrder(b.name)).map((v2) => v2.line).join("\n");
   return [
     scaleBlock,
-    `  --${prefix}-stamp-fill: ${stopHex(f.cta)};`,
-    `  --${prefix}-stamp-fill-hover: ${stopHex(f.ctaHover)};`,
-    `  --${prefix}-stamp-fill-pressed: ${stopHex(f.ctaPressed)};`,
-    `  --${prefix}-stamp-edge: var(${border ? offsetVarName(ctaBorderRung(prefix)) : TRANSPARENT_VAR});`,
-    // the SOFT on-cta (owner 2026-08-04: "neutral cta on's should also be the alpha"): the
-    // neutral's cta is the scale-fed CHALK-level fill, the system's other quiet cta, so its
-    // button text takes the pole AT ALPHA like the default-model secondary's — composited
-    // over whatever state the fill is in, so hover/pressed carry their own legibility. Same
-    // register both families (SOFT_ON_CTA_ALPHA), so both alias the ONE system/alpha/ink
-    // primitive. The neutral's is unconditional (the parameter default); the secondary's is
-    // the caller's per-mode verdict. Loud fills (brand, signals, the cta escape) keep the
-    // solid pole.
-    on === "soft" ? `  --${prefix}-stamp-on: rgba(${onCta ? "255, 255, 255" : "0, 0, 0"}, ${SOFT_ON_CTA_ALPHA[mode]});` : `  --${prefix}-stamp-on: ${onColor(onCta)};`
+    `  ${cssVarName(familyPath(prefix, STAMP_FILL))}: ${stopHex(f.cta)};`,
+    `  ${cssVarName(familyPath(prefix, STAMP_FILL_HOVER))}: ${stopHex(f.ctaHover)};`,
+    `  ${cssVarName(familyPath(prefix, STAMP_FILL_PRESSED))}: ${stopHex(f.ctaPressed)};`,
+    `  ${cssVarName(familyPath(prefix, STAMP_EDGE))}: ${border ? offsetRgba(ctaBorderRung(prefix), mode) : "transparent"};`,
+    // the soft on-text: a quiet fill's button text is the pole at alpha, composited over
+    // whatever state the fill is in so hover and pressed carry their own legibility (C47).
+    // The neutral's is unconditional (the parameter default); the secondary's is the
+    // caller's per-mode verdict. Loud fills (the brand, the signals, the cta escape) keep
+    // the solid pole.
+    on === "soft" ? `  ${cssVarName(familyPath(prefix, STAMP_ON))}: rgba(${onCta ? "255, 255, 255" : "0, 0, 0"}, ${SOFT_ON_CTA_ALPHA[mode]});` : `  ${cssVarName(familyPath(prefix, STAMP_ON))}: ${onColor(onCta)};`
   ];
 }
 function ctaFamilyOf(s, mode) {
@@ -3530,9 +3487,9 @@ function brandKindP3Body(prefix, s, mode) {
   const stops = mode === "light" ? s.light : s.dark;
   const f = ctaFamilyOf(s, mode);
   const out = [];
-  for (const st of stops) if (p3Differs(st)) out.push(`  --${prefix}-${stopTokenName(st.stop)}: ${p3Value(st)};`);
-  for (const [name, st] of [["stamp-fill", f.cta], ["stamp-fill-hover", f.ctaHover], ["stamp-fill-pressed", f.ctaPressed]])
-    if (p3Differs(st)) out.push(`  --${prefix}-${name}: ${p3Value(st)};`);
+  for (const st of stops) if (p3Differs(st)) out.push(`  ${cssVarName(familyPath(prefix, stopTokenName(st.stop)))}: ${p3Value(st)};`);
+  for (const [name, st] of [[STAMP_FILL, f.cta], [STAMP_FILL_HOVER, f.ctaHover], [STAMP_FILL_PRESSED, f.ctaPressed]])
+    if (p3Differs(st)) out.push(`  ${cssVarName(familyPath(prefix, name))}: ${p3Value(st)};`);
   return out;
 }
 function neutralCss(selector, brandH, level = "default", contrastProfile, ctaBorder = true) {
@@ -3543,16 +3500,14 @@ function neutralCss(selector, brandH, level = "default", contrastProfile, ctaBor
   const p3Dark = brandKindP3Body(CSS_NEUTRAL, s, "dark");
   return [
     `${selector} {`,
-    `  --${PAPER_0}: ${p02(s.paper0, "#ffffff")};`,
-    `  --${PEN_100}: ${p02(s.pen100, "#000000")};`,
-    // the neutral IS the page, so it is judged against its own paper stop
-    // the neutral's overlays never read the visibility bar (the exempt family), so
-    // the brandless chrome context passes 0
+    `  ${cssVarName(familyPath(CSS_NEUTRAL, PAPER_0))}: ${p02(s.paper0, "#ffffff")};`,
+    `  ${cssVarName(familyPath(CSS_NEUTRAL, PEN_100))}: ${p02(s.pen100, "#000000")};`,
+    // the neutral is the page, so it is judged against its own paper stop
     ...brandKindBody(CSS_NEUTRAL, s, "light", nPage("light")),
     `}`,
     `${selector}[data-theme="dark"] {`,
-    `  --${PAPER_0}: ${p02(s.paper0Dark, "#000000")};`,
-    `  --${PEN_100}: ${p02(s.pen100Dark, "#ffffff")};`,
+    `  ${cssVarName(familyPath(CSS_NEUTRAL, PAPER_0))}: ${p02(s.paper0Dark, "#000000")};`,
+    `  ${cssVarName(familyPath(CSS_NEUTRAL, PEN_100))}: ${p02(s.pen100Dark, "#ffffff")};`,
     ...brandKindBody(CSS_NEUTRAL, s, "dark", nPage("dark")),
     `}`,
     ...p3Light.length || p3Dark.length ? [
@@ -3584,16 +3539,9 @@ function signalsCss(contrastProfile) {
   return [
     `/* Signal scales \u2014 engine-generated from canonical hexes, shared across brands */`,
     `:root {`,
-    // the system alpha variables every family's cta-border aliases (owner 2026-07-29) — this is
-    // the engine's one global :root, the CSS counterpart of the Figma side's system/alpha/* rows.
-    // Emitted in BOTH blocks because the offset rungs are scheme-DIVERGENT (black in light,
-    // white in dark); --alpha-transparent and the opacity ladder (mode-invariant) repeat
-    // harmlessly and keep the set together.
-    ...alphaRootVars("light"),
     ...lightBlocks,
     `}`,
     `${SIGNALS_DARK_SELECTOR} {`,
-    ...alphaRootVars("dark"),
     ...darkBlocks,
     `}`,
     ...p3LightBlocks.length || p3DarkBlocks.length ? [
@@ -3627,69 +3575,72 @@ function brandCss(slug, displayName, r, secondary, noteSuffix = "", neutralLevel
   const page = ctaBorder ? { light: pageStopFor(nScale, "light"), dark: pageStopFor(nScale, "dark") } : { light: void 0, dark: void 0 };
   const mirrorBody = (prefix, mode) => {
     const stops = mode === "light" ? scale.light : scale.dark;
-    const alias = (name) => `  --${prefix}-${name}: var(--${CSS_BRAND}-${name});`;
+    const alias = (name) => `  ${cssVarName(familyPath(prefix, name))}: var(${cssVarName(familyPath(CSS_BRAND, name))});`;
     return [
       ...stops.map((x2) => alias(stopTokenName(x2.stop))),
-      alias("stamp-fill"),
-      alias("stamp-fill-hover"),
-      alias("stamp-fill-pressed"),
-      alias("stamp-edge"),
-      alias("stamp-on")
+      alias(STAMP_FILL),
+      alias(STAMP_FILL_HOVER),
+      alias(STAMP_FILL_PRESSED),
+      alias(STAMP_EDGE),
+      alias(STAMP_ON)
     ];
   };
   const secondaryOn = (mode) => secondary && secondaryStyle !== "outline" && softOnCtaPasses(secondary, mode) ? "soft" : "solid";
   const secondaryLight = secondary ? brandKindBody(CSS_SECONDARY, secondary, "light", page.light, secondaryOn("light")) : mirrorBody(CSS_SECONDARY, "light");
   const secondaryDark = secondary ? brandKindBody(CSS_SECONDARY, secondary, "dark", page.dark, secondaryOn("dark")) : mirrorBody(CSS_SECONDARY, "dark");
-  const brandIdentity = `  --${CSS_BRAND}-identity: ${scale.identityHex};`;
-  const secondaryIdentity = secondary ? `  --${CSS_SECONDARY}-identity: ${secondary.identityHex};` : `  --${CSS_SECONDARY}-identity: var(--${CSS_BRAND}-identity);`;
+  const brandIdentity = `  ${cssVarName(absolutePath(CSS_BRAND))}: ${scale.identityHex};`;
+  const secondaryIdentity = secondary ? `  ${cssVarName(absolutePath(CSS_SECONDARY))}: ${secondary.identityHex};` : `  ${cssVarName(absolutePath(CSS_SECONDARY))}: var(${cssVarName(absolutePath(CSS_BRAND))});`;
   const p0hex = (s, fallback) => s ? stopHex(s) : fallback;
-  const lightAnchors = [`  --${PAPER_0}: ${p0hex(nScale.paper0, "#ffffff")};`, `  --${PEN_100}: ${p0hex(nScale.pen100, "#000000")};`];
-  const darkAnchors = [`  --${PAPER_0}: ${p0hex(nScale.paper0Dark, "#000000")};`, `  --${PEN_100}: ${p0hex(nScale.pen100Dark, "#ffffff")};`];
+  const lightAnchors = [`  ${cssVarName(familyPath(CSS_NEUTRAL, PAPER_0))}: ${p0hex(nScale.paper0, "#ffffff")};`, `  ${cssVarName(familyPath(CSS_NEUTRAL, PEN_100))}: ${p0hex(nScale.pen100, "#000000")};`];
+  const darkAnchors = [`  ${cssVarName(familyPath(CSS_NEUTRAL, PAPER_0))}: ${p0hex(nScale.paper0Dark, "#000000")};`, `  ${cssVarName(familyPath(CSS_NEUTRAL, PEN_100))}: ${p0hex(nScale.pen100Dark, "#ffffff")};`];
   const linkTrio = linkHex ? resolveLinkTrio(linkHex, contrastProfile) : null;
-  const link = (mode) => linkTrio ? mode === "light" ? [`  --link: ${stopHex(linkTrio.link)};`, `  --link-hover: ${stopHex(linkTrio.linkHover)};`, `  --link-pressed: ${stopHex(linkTrio.linkPressed)};`] : [`  --link: ${stopHex(linkTrio.linkDark)};`, `  --link-hover: ${stopHex(linkTrio.linkHoverDark)};`, `  --link-pressed: ${stopHex(linkTrio.linkPressedDark)};`] : [
-    `  --link: var(--${CSS_BRAND}-${stopTokenName(9)});`,
-    `  --link-hover: var(--${CSS_BRAND}-${stopTokenName(10)});`,
-    `  --link-pressed: var(--${CSS_BRAND}-${stopTokenName(11)});`
+  const linkVar = (state) => cssVarName(linkPath("default", state));
+  const link = (mode) => linkTrio ? mode === "light" ? [`  ${linkVar("enabled")}: ${stopHex(linkTrio.link)};`, `  ${linkVar("hover")}: ${stopHex(linkTrio.linkHover)};`, `  ${linkVar("pressed")}: ${stopHex(linkTrio.linkPressed)};`] : [`  ${linkVar("enabled")}: ${stopHex(linkTrio.linkDark)};`, `  ${linkVar("hover")}: ${stopHex(linkTrio.linkHoverDark)};`, `  ${linkVar("pressed")}: ${stopHex(linkTrio.linkPressedDark)};`] : [
+    `  ${linkVar("enabled")}: var(${cssVarName(familyPath(CSS_BRAND, stopTokenName(9)))});`,
+    `  ${linkVar("hover")}: var(${cssVarName(familyPath(CSS_BRAND, stopTokenName(10)))});`,
+    `  ${linkVar("pressed")}: var(${cssVarName(familyPath(CSS_BRAND, stopTokenName(11)))});`
   ];
   const linkP3 = (mode) => {
     if (!linkTrio) return [];
-    const trio = mode === "light" ? [["link", linkTrio.link], ["link-hover", linkTrio.linkHover], ["link-pressed", linkTrio.linkPressed]] : [["link", linkTrio.linkDark], ["link-hover", linkTrio.linkHoverDark], ["link-pressed", linkTrio.linkPressedDark]];
-    return trio.filter(([, s]) => p3Differs(s)).map(([n, s]) => `  --${n}: ${p3Value(s)};`);
+    const trio = mode === "light" ? [["enabled", linkTrio.link], ["hover", linkTrio.linkHover], ["pressed", linkTrio.linkPressed]] : [["enabled", linkTrio.linkDark], ["hover", linkTrio.linkHoverDark], ["pressed", linkTrio.linkPressedDark]];
+    return trio.filter(([, s]) => p3Differs(s)).map(([n, s]) => `  ${linkVar(n)}: ${p3Value(s)};`);
   };
   const inverseSeed = linkHex ?? scale.identityHex ?? stopHex(scale.light.find((x2) => x2.stop === 9));
   const linkInverseTrio = resolveLinkInverseTrio(inverseSeed, contrastProfile);
-  const linkInverse = (mode) => mode === "light" ? [`  --link-inverse: ${stopHex(linkInverseTrio.link)};`, `  --link-inverse-hover: ${stopHex(linkInverseTrio.linkHover)};`, `  --link-inverse-pressed: ${stopHex(linkInverseTrio.linkPressed)};`] : [`  --link-inverse: ${stopHex(linkInverseTrio.linkDark)};`, `  --link-inverse-hover: ${stopHex(linkInverseTrio.linkHoverDark)};`, `  --link-inverse-pressed: ${stopHex(linkInverseTrio.linkPressedDark)};`];
+  const inverseVar = (state) => cssVarName(linkPath("inverse", state));
+  const linkInverse = (mode) => mode === "light" ? [`  ${inverseVar("enabled")}: ${stopHex(linkInverseTrio.link)};`, `  ${inverseVar("hover")}: ${stopHex(linkInverseTrio.linkHover)};`, `  ${inverseVar("pressed")}: ${stopHex(linkInverseTrio.linkPressed)};`] : [`  ${inverseVar("enabled")}: ${stopHex(linkInverseTrio.linkDark)};`, `  ${inverseVar("hover")}: ${stopHex(linkInverseTrio.linkHoverDark)};`, `  ${inverseVar("pressed")}: ${stopHex(linkInverseTrio.linkPressedDark)};`];
   const linkInverseP3 = (mode) => {
-    const trio = mode === "light" ? [["link-inverse", linkInverseTrio.link], ["link-inverse-hover", linkInverseTrio.linkHover], ["link-inverse-pressed", linkInverseTrio.linkPressed]] : [["link-inverse", linkInverseTrio.linkDark], ["link-inverse-hover", linkInverseTrio.linkHoverDark], ["link-inverse-pressed", linkInverseTrio.linkPressedDark]];
-    return trio.filter(([, s]) => p3Differs(s)).map(([n, s]) => `  --${n}: ${p3Value(s)};`);
+    const trio = mode === "light" ? [["enabled", linkInverseTrio.link], ["hover", linkInverseTrio.linkHover], ["pressed", linkInverseTrio.linkPressed]] : [["enabled", linkInverseTrio.linkDark], ["hover", linkInverseTrio.linkHoverDark], ["pressed", linkInverseTrio.linkPressedDark]];
+    return trio.filter(([, s]) => p3Differs(s)).map(([n, s]) => `  ${inverseVar(n)}: ${p3Value(s)};`);
   };
   const escape = (mode) => {
     if (!ctaEscape) return [];
     const esc = escapeCtaFamily(nScale, mode, contrastProfile);
     return [
-      `  --${CSS_BRAND}-stamp-fill: ${stopHex(esc.cta)};`,
-      `  --${CSS_BRAND}-stamp-fill-hover: ${stopHex(esc.ctaHover)};`,
-      `  --${CSS_BRAND}-stamp-fill-pressed: ${stopHex(esc.ctaPressed)};`,
-      `  --${CSS_BRAND}-stamp-on: ${onColor(esc.onFillIsWhite)};`
+      `  ${cssVarName(familyPath(CSS_BRAND, STAMP_FILL))}: ${stopHex(esc.cta)};`,
+      `  ${cssVarName(familyPath(CSS_BRAND, STAMP_FILL_HOVER))}: ${stopHex(esc.ctaHover)};`,
+      `  ${cssVarName(familyPath(CSS_BRAND, STAMP_FILL_PRESSED))}: ${stopHex(esc.ctaPressed)};`,
+      `  ${cssVarName(familyPath(CSS_BRAND, STAMP_ON))}: ${onColor(esc.onFillIsWhite)};`
     ];
   };
   const outline = (mode) => {
     if (secondaryStyle !== "outline" || !secondary) return [];
     const s8 = (mode === "light" ? secondary.light : secondary.dark).find((s) => s.stop === 8);
-    const c = (v2) => Math.round(Math.min(1, Math.max(0, v2)) * 255);
+    const c = (v3) => Math.round(Math.min(1, Math.max(0, v3)) * 255);
     const s8e = s8 ? srgbEmitChannels(s8) : null;
+    const v2 = (leaf) => cssVarName(familyPath(CSS_SECONDARY, leaf));
     return [
-      `  --${CSS_SECONDARY}-stamp-fill: transparent;`,
+      `  ${v2(STAMP_FILL)}: transparent;`,
       ...s8e ? [
-        `  --${CSS_SECONDARY}-stamp-fill-hover: rgba(${c(s8e.r)}, ${c(s8e.g)}, ${c(s8e.b)}, ${OUTLINE_HOVER_ALPHA});`,
-        `  --${CSS_SECONDARY}-stamp-fill-pressed: rgba(${c(s8e.r)}, ${c(s8e.g)}, ${c(s8e.b)}, ${OUTLINE_PRESSED_ALPHA});`
+        `  ${v2(STAMP_FILL_HOVER)}: rgba(${c(s8e.r)}, ${c(s8e.g)}, ${c(s8e.b)}, ${OUTLINE_HOVER_ALPHA});`,
+        `  ${v2(STAMP_FILL_PRESSED)}: rgba(${c(s8e.r)}, ${c(s8e.g)}, ${c(s8e.b)}, ${OUTLINE_PRESSED_ALPHA});`
       ] : [],
-      `  --${CSS_SECONDARY}-stamp-edge: var(--${CSS_SECONDARY}-${stopTokenName(8)});`,
-      `  --${CSS_SECONDARY}-stamp-on: var(--${CSS_SECONDARY}-${stopTokenName(9)});`
+      `  ${v2(STAMP_EDGE)}: var(${v2(stopTokenName(8))});`,
+      `  ${v2(STAMP_ON)}: var(${v2(stopTokenName(9))});`
     ];
   };
-  const dropOutlineCta = (lines) => secondaryStyle === "outline" ? lines.filter((l) => !l.startsWith(`  --${CSS_SECONDARY}-stamp-fill:`) && !l.startsWith(`  --${CSS_SECONDARY}-stamp-fill-hover:`) && !l.startsWith(`  --${CSS_SECONDARY}-stamp-fill-pressed:`)) : lines;
-  const dropEscapeCta = (lines) => ctaEscape ? lines.filter((l) => !new RegExp(`^  --${CSS_BRAND}-stamp-fill(-hover|-pressed)?:`).test(l)) : lines;
+  const dropOutlineCta = (lines) => secondaryStyle === "outline" ? lines.filter((l) => ![STAMP_FILL, STAMP_FILL_HOVER, STAMP_FILL_PRESSED].some((leaf) => l.startsWith(`  ${cssVarName(familyPath(CSS_SECONDARY, leaf))}:`))) : lines;
+  const dropEscapeCta = (lines) => ctaEscape ? lines.filter((l) => ![STAMP_FILL, STAMP_FILL_HOVER, STAMP_FILL_PRESSED].some((leaf) => l.startsWith(`  ${cssVarName(familyPath(CSS_BRAND, leaf))}:`))) : lines;
   const p3Light = [
     ...dropEscapeCta(brandKindP3Body(CSS_BRAND, scale, "light")),
     ...secondary ? dropOutlineCta(brandKindP3Body(CSS_SECONDARY, secondary, "light")) : [],
@@ -3797,17 +3748,6 @@ function resolveReferences(own, shared) {
   for (const name of /* @__PURE__ */ new Set([...own.keys(), ...shared.keys()])) out[name] = resolve(lookup(name), 0);
   return out;
 }
-function systemCss() {
-  const planeRef = (stop) => stop === PAPER_0 ? `var(--${PAPER_0})` : `var(--${CSS_FAMILY.neutral}-${stop})`;
-  const pad = (r) => String(r).padStart(2, "0");
-  const lines = (mode) => [
-    ...Object.entries(SURFACE_PLANE_LAW).map(([leaf, stops]) => `  --surface-${leaf.split("/").pop()}: ${planeRef(stops[mode])};`),
-    ...Object.keys(SHADOW_ALPHAS).map(Number).map((r) => `  --shadow-${pad(r)}: rgba(0, 0, 0, ${SHADOW_ALPHAS[r][mode]});`),
-    `  --scrim: rgba(0, 0, 0, ${SCRIM_ALPHA});`,
-    `  --disabled-opacity: ${DISABLED_OPACITY};`
-  ];
-  return [":root {", ...lines("light"), "}", `:root${DARK_MARK}, ${DARK_MARK} {`, ...lines("dark"), "}"].join("\n");
-}
 function tokensFromEmission(slug, css) {
   const { light, dark, order } = readEmission(css);
   const resolvedLight = resolveReferences(light, /* @__PURE__ */ new Map());
@@ -3819,7 +3759,6 @@ function tokensFromEmission(slug, css) {
 function themeTokens(input) {
   const css = [
     signalsCss(input.contrastProfile),
-    systemCss(),
     brandCss(
       input.slug,
       input.displayName ?? input.slug,
@@ -3838,168 +3777,35 @@ function themeTokens(input) {
   return tokensFromEmission(input.slug, css);
 }
 
-// src/engine/interaction.ts
-var INTERACTION_POLE_FAMILY = { strong: "neutral-strong", inverse: "neutral-inverse" };
-var INTERACTION_FAMILIES = [
-  CSS_FAMILY.neutral,
-  CSS_FAMILY.brandPrimary,
-  CSS_FAMILY.brandSecondary,
-  ...SIGNALS2.map((s) => s.emitName),
-  INTERACTION_POLE_FAMILY.strong,
-  INTERACTION_POLE_FAMILY.inverse
-];
-var INTERACTION_STATES = ["enabled", "hover", "pressed", "selected"];
-var INTERACTION_LADDER = {
-  subtle: { enabled: 12, hover: 16, pressed: 24, selected: 32 },
-  hint: { enabled: null, hover: 8, pressed: 12, selected: 16 }
-};
-var INTERACTION_ROWS = [
-  "fg",
-  "fg-strong",
-  "fg-on-hint",
-  "solid-bg-enabled",
-  "solid-bg-hover",
-  "solid-bg-pressed",
-  "solid-border",
-  "solid-fg",
-  "subtle-bg-enabled",
-  "subtle-bg-hover",
-  "subtle-bg-pressed",
-  "subtle-bg-selected",
-  "hint-bg-enabled",
-  "hint-bg-hover",
-  "hint-bg-pressed",
-  "hint-bg-selected"
-];
-var interactionVarName = (family, row) => `--${family}-${row}`;
-var isPole = (family) => family === INTERACTION_POLE_FAMILY.strong || family === INTERACTION_POLE_FAMILY.inverse;
-var hexChannels = (hex) => {
-  const m = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(hex.trim());
-  return m ? [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16)] : null;
-};
-function interactionTintName(family) {
-  if (family === INTERACTION_POLE_FAMILY.strong) return PEN_100;
-  if (family === INTERACTION_POLE_FAMILY.inverse) return PAPER_0;
-  return `${family}-${stopTokenName(8)}`;
-}
-function interactionRows(family, mode, tokens) {
-  const neutral = CSS_FAMILY.neutral;
-  const v2 = (name) => `var(--${name})`;
-  const pen = (stop) => `${family}-${stopTokenName(stop)}`;
-  const tintHex = tokens[mode][interactionTintName(family)];
-  const ch = tintHex ? hexChannels(tintHex) : null;
-  if (!ch) throw new Error(`interactionRows: no sRGB hex for ${interactionTintName(family)} in ${mode}`);
-  const at = (rung) => rung === null ? v2(TRANSPARENT_VAR.slice(2)) : `rgba(${ch[0]}, ${ch[1]}, ${ch[2]}, ${OPACITY_RUNGS[rung]})`;
-  const text = isPole(family) ? [["fg", v2(interactionTintName(family))], ["fg-strong", v2(interactionTintName(family))], ["fg-on-hint", v2(interactionTintName(family))]] : [["fg", v2(pen(10))], ["fg-strong", v2(pen(11))], ["fg-on-hint", v2(pen(9))]];
-  const solid = family === INTERACTION_POLE_FAMILY.strong ? [
-    ["solid-bg-enabled", v2(PEN_100)],
-    ["solid-bg-hover", v2(`${neutral}-${stopTokenName(11)}`)],
-    ["solid-bg-pressed", v2(`${neutral}-${stopTokenName(10)}`)],
-    ["solid-border", v2(TRANSPARENT_VAR.slice(2))],
-    ["solid-fg", v2(PAPER_0)]
-  ] : family === INTERACTION_POLE_FAMILY.inverse ? [
-    ["solid-bg-enabled", v2(PAPER_0)],
-    ["solid-bg-hover", v2(`${neutral}-${stopTokenName(2)}`)],
-    ["solid-bg-pressed", v2(`${neutral}-${stopTokenName(3)}`)],
-    ["solid-border", v2(TRANSPARENT_VAR.slice(2))],
-    ["solid-fg", v2(PEN_100)]
-  ] : [
-    ["solid-bg-enabled", v2(`${family}-${STAMP_FILL}`)],
-    ["solid-bg-hover", v2(`${family}-${STAMP_FILL_HOVER}`)],
-    ["solid-bg-pressed", v2(`${family}-${STAMP_FILL_PRESSED}`)],
-    ["solid-border", v2(`${family}-${STAMP_EDGE}`)],
-    ["solid-fg", v2(`${family}-${STAMP_ON}`)]
-  ];
-  const ladder = (tier) => INTERACTION_STATES.map((state) => [`${tier}-bg-${state}`, at(INTERACTION_LADDER[tier][state])]);
-  return [...text, ...solid, ...ladder("subtle"), ...ladder("hint")];
-}
-var rowVariesByMode = (row) => /^(subtle|hint)-bg-/.test(row) && row !== "hint-bg-enabled";
-function interactionCss(slug, tokens) {
-  const scope = `[data-brand="${slug}"]`;
-  const light = [];
-  const dark = [];
-  for (const family of INTERACTION_FAMILIES) {
-    for (const [row, value] of interactionRows(family, "light", tokens)) light.push(`  ${interactionVarName(family, row)}: ${value};`);
-    for (const [row, value] of interactionRows(family, "dark", tokens)) if (rowVariesByMode(row)) dark.push(`  ${interactionVarName(family, row)}: ${value};`);
-  }
-  const scoped = INTERACTION_FAMILIES.flatMap((family) => [
-    `${scope} [data-family="${family}"], ${scope}[data-family="${family}"] {`,
-    ...INTERACTION_ROWS.map((row) => `  --${row}: var(${interactionVarName(family, row)});`),
-    `}`
-  ]);
-  return [
-    `/* Interaction register: solid, subtle and hint tiers per family, the translucent rows at the engine's opacity rungs */`,
-    `${scope} {`,
-    ...light,
-    `}`,
-    `${scope}[data-theme="dark"] {`,
-    ...dark,
-    `}`,
-    ...scoped
-  ].join("\n");
-}
-function interactionTokens(tokens) {
-  const add = (mode) => {
-    const m = /* @__PURE__ */ new Map();
-    for (const family of INTERACTION_FAMILIES)
-      for (const [row, value] of interactionRows(family, mode, tokens)) m.set(interactionVarName(family, row).slice(2), value);
-    return m;
-  };
-  const rawLight = add("light");
-  const rawDark = add("dark");
-  const baseLight = new Map(Object.entries(tokens.light));
-  const baseDark = new Map(Object.entries(tokens.dark));
-  const light = resolveReferences(rawLight, baseLight);
-  const dark = resolveReferences(rawDark, baseDark);
-  const names = [...tokens.names, ...rawLight.keys()];
-  const invariant = [...tokens.invariant, ...[...rawLight.keys()].filter((n) => rawLight.get(n) === rawDark.get(n))];
-  return {
-    slug: tokens.slug,
-    names,
-    light: { ...tokens.light, ...Object.fromEntries([...rawLight.keys()].map((n) => [n, light[n]])) },
-    dark: { ...tokens.dark, ...Object.fromEntries([...rawDark.keys()].map((n) => [n, dark[n]])) },
-    invariant,
-    raw: {
-      light: { ...tokens.raw.light, ...Object.fromEntries(rawLight) },
-      dark: { ...tokens.raw.dark, ...Object.fromEntries(rawDark) }
-    }
-  };
-}
-
 // src/engine/figmaRender.ts
-var clamp01 = (v2) => Math.min(1, Math.max(0, v2));
-var TRANSPARENT_TOKEN = {
-  $type: "color",
-  $value: { colorSpace: "srgb", components: [0, 0, 0], alpha: 0, hex: "#000000" }
-};
+var channel = (v2) => Math.round(Math.round(Math.min(1, Math.max(0, v2)) * 255) / 255 * 1e4) / 1e4;
+function color(r, g2, b, alpha = 1) {
+  return { $type: "color", $value: { colorSpace: "srgb", components: [channel(r), channel(g2), channel(b)], alpha, hex: toHex2(r, g2, b) } };
+}
+var TRANSPARENT_TOKEN = color(0, 0, 0, 0);
 var OFFSET_TOKEN = (rung, mode) => {
   const c = mode === "light" ? 0 : 1;
-  return {
-    $type: "color",
-    $value: { colorSpace: "srgb", components: [c, c, c], alpha: OFFSET_ALPHAS[rung], hex: mode === "light" ? "#000000" : "#ffffff" }
-  };
+  return color(c, c, c, OFFSET_ALPHAS[rung]);
 };
 function colorFromStop(s) {
   const { r, g: g2, b } = srgbEmitChannels(s);
-  return {
-    $type: "color",
-    $value: { colorSpace: "srgb", components: [clamp01(r), clamp01(g2), clamp01(b)], alpha: 1, hex: toHex2(r, g2, b) }
-  };
-}
-function colorFromHex(white) {
-  const v2 = white ? 1 : 0;
-  return { $type: "color", $value: { colorSpace: "srgb", components: [v2, v2, v2], alpha: 1, hex: white ? "#ffffff" : "#000000" } };
+  return color(r, g2, b);
 }
+var pole = (white, alpha = 1) => white ? color(1, 1, 1, alpha) : color(0, 0, 0, alpha);
 function colorFromHexString(hex) {
   const h = hex.replace("#", "");
-  const r = parseInt(h.slice(0, 2), 16) / 255;
-  const g2 = parseInt(h.slice(2, 4), 16) / 255;
-  const b = parseInt(h.slice(4, 6), 16) / 255;
-  return { $type: "color", $value: { colorSpace: "srgb", components: [r, g2, b], alpha: 1, hex: hex.toLowerCase() } };
+  return color(parseInt(h.slice(0, 2), 16) / 255, parseInt(h.slice(2, 4), 16) / 255, parseInt(h.slice(4, 6), 16) / 255);
 }
 function bandedLeaf(flat) {
   return STAMP_STATE_LEAVES[flat] ?? flat;
 }
+function groupEntries(g2) {
+  const entries = Object.entries(g2);
+  const digitLeading = (k) => /^\d/.test(k);
+  if (entries.length > 1 && entries.every(([k]) => digitLeading(k)))
+    return entries.sort((a, b) => parseInt(b[0], 10) - parseInt(a[0], 10));
+  return entries;
+}
 function putLeaf(g2, flat, tok) {
   const path = bandedLeaf(flat).split("/");
   let cur = g2;
@@ -4017,8 +3823,7 @@ function rampGroup(stops, onFillWhite, extra) {
   if (extra?.ctaHover) putLeaf(g2, STAMP_FILL_HOVER, colorFromStop(extra.ctaHover));
   if (extra?.ctaPressed) putLeaf(g2, STAMP_FILL_PRESSED, colorFromStop(extra.ctaPressed));
   if (extra?.cta) putLeaf(g2, STAMP_EDGE, extra.ctaBorder ?? TRANSPARENT_TOKEN);
-  putLeaf(g2, STAMP_ON, colorFromHex(onFillWhite));
-  if (extra?.identityHex) g2["identity"] = colorFromHexString(extra.identityHex);
+  putLeaf(g2, STAMP_ON, pole(onFillWhite));
   return g2;
 }
 function themeToFigma(r, input) {
@@ -4031,10 +3836,6 @@ function themeToFigma(r, input) {
     ctaBorder: ctaNeedsBorder(s, mode, borderPage(mode)) ? OFFSET_TOKEN(ctaBorderRung(prefix), mode) : TRANSPARENT_TOKEN,
     ...mode === "light" ? { cta: s.cta, ctaHover: s.ctaHover, ctaPressed: s.ctaPressed } : { cta: s.ctaDark, ctaHover: s.ctaHoverDark, ctaPressed: s.ctaPressedDark }
   });
-  const brandExtra = (s, mode, prefix) => ({
-    identityHex: s.identityHex,
-    ...ctaFamily(s, mode, prefix)
-  });
   const nScale = generateNeutralScale(input.neutralH ?? scale.brandH, input.neutralLevel ?? "default", input.contrastProfile);
   const lt = input.linkHex ? resolveLinkTrio(input.linkHex, input.contrastProfile) : null;
   const invSeed = input.linkHex ?? scale.identityHex ?? (() => {
@@ -4043,10 +3844,9 @@ function themeToFigma(r, input) {
     return toHex2(e.r, e.g, e.b);
   })();
   const invLt = resolveLinkInverseTrio(invSeed, input.contrastProfile);
-  const neutralExtra = (mode) => ctaFamily(nScale, mode, CSS_FAMILY.neutral);
   const build = (mode) => {
     const p02 = mode === "light" ? nScale.paper0 : nScale.paper0Dark;
-    const ramp = rampGroup(nScale[mode], mode === "light" ? nScale.onFillTextIsWhite : nScale.onFillTextIsWhiteDark, neutralExtra(mode));
+    const ramp = rampGroup(nScale[mode], mode === "light" ? nScale.onFillTextIsWhite : nScale.onFillTextIsWhiteDark, ctaFamily(nScale, mode, CSS_FAMILY.neutral));
     const i02 = mode === "light" ? nScale.pen100 : nScale.pen100Dark;
     const splicePen100 = (g3) => {
       if (!i02) return g3;
@@ -4058,41 +3858,31 @@ function themeToFigma(r, input) {
       return out;
     };
     const neutralGroup = splicePen100(p02 ? { [PAPER_0]: colorFromStop(p02), ...ramp } : ramp);
-    const secondaryGroup = rampGroup(secondary[mode], mode === "light" ? secondaryOnFillLight : secondaryOnFillDark, brandExtra(secondary, mode, CSS_FAMILY.brandSecondary));
+    const secondaryGroup = rampGroup(secondary[mode], mode === "light" ? secondaryOnFillLight : secondaryOnFillDark, ctaFamily(secondary, mode, CSS_FAMILY.brandSecondary));
     if (input.secondaryStyle === "outline" && input.secondary) {
       const s8 = secondary[mode].find((s) => s.stop === 8);
       const s9 = secondary[mode].find((s) => s.stop === 9);
       putLeaf(secondaryGroup, STAMP_FILL, TRANSPARENT_TOKEN);
       if (s8) {
         const e = srgbEmitChannels(s8);
-        const alphaTint = (alpha) => ({
-          $type: "color",
-          $value: { colorSpace: "srgb", components: [clamp01(e.r), clamp01(e.g), clamp01(e.b)], alpha, hex: toHex2(e.r, e.g, e.b) }
-        });
-        putLeaf(secondaryGroup, STAMP_FILL_HOVER, alphaTint(OUTLINE_HOVER_ALPHA));
-        putLeaf(secondaryGroup, STAMP_FILL_PRESSED, alphaTint(OUTLINE_PRESSED_ALPHA));
+        putLeaf(secondaryGroup, STAMP_FILL_HOVER, color(e.r, e.g, e.b, OUTLINE_HOVER_ALPHA));
+        putLeaf(secondaryGroup, STAMP_FILL_PRESSED, color(e.r, e.g, e.b, OUTLINE_PRESSED_ALPHA));
+        putLeaf(secondaryGroup, STAMP_EDGE, colorFromStop(s8));
       }
-      if (s8) putLeaf(secondaryGroup, STAMP_EDGE, colorFromStop(s8));
       if (s9) putLeaf(secondaryGroup, STAMP_ON, colorFromStop(s9));
     }
-    const softOnCta = (g3, white) => {
-      const p = white ? 1 : 0;
-      putLeaf(g3, STAMP_ON, {
-        $type: "color",
-        $value: { colorSpace: "srgb", components: [p, p, p], alpha: SOFT_ON_CTA_ALPHA[mode], hex: white ? "#ffffff" : "#000000" }
-      });
-    };
+    const softOnCta = (g3, white) => putLeaf(g3, STAMP_ON, pole(white, SOFT_ON_CTA_ALPHA[mode]));
     softOnCta(neutralGroup, mode === "light" ? nScale.onFillTextIsWhite : nScale.onFillTextIsWhiteDark);
     if (input.secondary && input.secondaryStyle !== "outline" && softOnCtaPasses(input.secondary, mode))
       softOnCta(secondaryGroup, mode === "light" ? secondaryOnFillLight : secondaryOnFillDark);
-    const brandGroup = rampGroup(scale[mode], mode === "light" ? scale.onFillTextIsWhite : scale.onFillTextIsWhiteDark, brandExtra(scale, mode, CSS_FAMILY.brandPrimary));
+    const brandGroup = rampGroup(scale[mode], mode === "light" ? scale.onFillTextIsWhite : scale.onFillTextIsWhiteDark, ctaFamily(scale, mode, CSS_FAMILY.brandPrimary));
     const esc = input.ctaEscape ? escapeCtaFamily(nScale, mode, input.contrastProfile) : null;
     if (esc) {
       for (const g3 of input.secondary ? [brandGroup] : [brandGroup, secondaryGroup]) {
         putLeaf(g3, STAMP_FILL, colorFromStop(esc.cta));
         putLeaf(g3, STAMP_FILL_HOVER, colorFromStop(esc.ctaHover));
         putLeaf(g3, STAMP_FILL_PRESSED, colorFromStop(esc.ctaPressed));
-        putLeaf(g3, STAMP_ON, colorFromHex(esc.onFillIsWhite));
+        putLeaf(g3, STAMP_ON, pole(esc.onFillIsWhite));
       }
     }
     const scaleTextAt = (n) => {
@@ -4100,146 +3890,131 @@ function themeToFigma(r, input) {
       if (!s) throw new Error(`themeToFigma link: the brand scale has no pen stop ${n}`);
       return s;
     };
-    const linkGroup = lt ? mode === "light" ? { "link": colorFromStop(lt.link), "link-hover": colorFromStop(lt.linkHover), "link-pressed": colorFromStop(lt.linkPressed) } : { "link": colorFromStop(lt.linkDark), "link-hover": colorFromStop(lt.linkHoverDark), "link-pressed": colorFromStop(lt.linkPressedDark) } : { "link": colorFromStop(scaleTextAt(9)), "link-hover": colorFromStop(scaleTextAt(10)), "link-pressed": colorFromStop(scaleTextAt(11)) };
-    const linkInverseGroup = mode === "light" ? { "link": colorFromStop(invLt.link), "link-hover": colorFromStop(invLt.linkHover), "link-pressed": colorFromStop(invLt.linkPressed) } : { "link": colorFromStop(invLt.linkDark), "link-hover": colorFromStop(invLt.linkHoverDark), "link-pressed": colorFromStop(invLt.linkPressedDark) };
+    const trio = (posture) => {
+      const t = posture === "default" ? lt ? mode === "light" ? [lt.link, lt.linkHover, lt.linkPressed] : [lt.linkDark, lt.linkHoverDark, lt.linkPressedDark] : [scaleTextAt(9), scaleTextAt(10), scaleTextAt(11)] : mode === "light" ? [invLt.link, invLt.linkHover, invLt.linkPressed] : [invLt.linkDark, invLt.linkHoverDark, invLt.linkPressedDark];
+      return Object.fromEntries(LINK_STATES.map((state, i) => [state, colorFromStop(t[i])]));
+    };
     const g2 = {
-      brand: brandGroup,
-      secondary: secondaryGroup,
-      neutral: neutralGroup,
-      link: linkGroup,
-      "link-inverse": linkInverseGroup
+      [CSS_FAMILY.neutral]: neutralGroup,
+      [CSS_FAMILY.brandPrimary]: brandGroup,
+      [CSS_FAMILY.brandSecondary]: secondaryGroup
     };
     for (const sig of input.signals) {
-      g2[sig.name] = rampGroup(
+      const role = SIGNAL_EMIT_NAME[sig.name] ?? sig.name;
+      g2[role] = rampGroup(
         sig.scale[mode],
         mode === "light" ? sig.scale.onFillTextIsWhite : sig.scale.onFillTextIsWhiteDark,
-        // signals rank with the primary (ctaBorderRung: anything not neutral/secondary takes 16).
-        // Unreachable at the Lc 15 gate — no signal gets within 4 Lc of it — but defined, not accidental.
-        ctaFamily(sig.scale, mode, sig.name)
+        ctaFamily(sig.scale, mode, role)
       );
     }
-    const pole = (white, alpha) => {
-      const c = white ? 1 : 0;
-      return {
-        $type: "color",
-        $value: { colorSpace: "srgb", components: [c, c, c], alpha, hex: white ? "#ffffff" : "#000000" }
-      };
+    g2[LINK_GROUP] = { default: trio("default"), inverse: trio("inverse") };
+    g2[ABSOLUTE_GROUP] = {
+      [CSS_FAMILY.brandPrimary]: colorFromHexString(scale.identityHex ?? invSeed),
+      [CSS_FAMILY.brandSecondary]: colorFromHexString((input.secondary ?? scale).identityHex ?? invSeed)
     };
-    putLeaf(g2, SYSTEM_LEAF.ABS_BLACK, colorFromHex(false));
-    putLeaf(g2, SYSTEM_LEAF.ABS_WHITE, colorFromHex(true));
-    for (const [path, law] of Object.entries(SURFACE_PLANE_LAW)) {
-      const tok = neutralGroup[law[mode]];
-      if (tok && "$type" in tok) putLeaf(g2, path, tok);
-    }
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.TRANSPARENT, pole(true, 0));
-    for (const rung of Object.keys(OPACITY_RUNGS).map(Number))
-      putLeaf(g2, opacityTokenPath(rung), { $type: "number", $value: rung });
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.INK, pole(mode === "dark", SOFT_ON_CTA_ALPHA[mode]));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.AWAY_FROM_BG_06, OFFSET_TOKEN(6, mode));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.AWAY_FROM_BG_08, OFFSET_TOKEN(8, mode));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.AWAY_FROM_BG_16, OFFSET_TOKEN(16, mode));
-    const inv = mode === "light" ? "dark" : "light";
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.TOWARD_BG_06, OFFSET_TOKEN(6, inv));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.TOWARD_BG_08, OFFSET_TOKEN(8, inv));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.TOWARD_BG_16, OFFSET_TOKEN(16, inv));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.SHADOW_04, pole(false, SHADOW_ALPHAS[4][mode]));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.SHADOW_08, pole(false, SHADOW_ALPHAS[8][mode]));
-    putLeaf(g2, SYSTEM_LEAF.ALPHA.SHADOW_12, pole(false, SHADOW_ALPHAS[12][mode]));
     return g2;
   };
   return { light: build("light"), dark: build("dark") };
 }
 
-// src/engine/requirements/dtcg.ts
-var EXT_KEY = "org.okchroma.requirement";
-var RESOLVER_ID = "okchroma-reqtoken@2";
-var LEGACY_ROLE_NAMES = {
-  "cta": STAMP_FILL,
-  "cta-hover": STAMP_FILL_HOVER,
-  "cta-pressed": STAMP_FILL_PRESSED
-};
-var hexToValue = (hex) => {
-  const h = hex.replace("#", "");
-  const c = (i) => Math.round(parseInt(h.slice(i, i + 2), 16) / 255 * 1e4) / 1e4;
-  return { colorSpace: "srgb", components: [c(0), c(2), c(4)], alpha: 1, hex: hex.toLowerCase() };
-};
-function emitDtcgRamp(hex, mode, groupName, spec) {
-  spec ?? (spec = MODE_SPECS[mode]);
-  const ramp = resolveRamp(hex, mode, spec);
-  const seedRef = `{${groupName}.seed}`;
-  const group = {
-    seed: { $type: "color", $value: hexToValue(hex) },
-    $extensions: { [EXT_KEY]: { resolver: RESOLVER_ID, ons: spec.ons } }
-  };
-  for (const sp of spec.stops) {
-    const st = ramp.stops.find((s) => s.stop === sp.stop);
-    group[String(sp.stop)] = { $type: "color", $value: hexToValue(st.hex), $extensions: { [EXT_KEY]: { resolver: RESOLVER_ID, seed: seedRef, mode, ...sp } } };
-  }
-  const roleVal = {
-    [STAMP_FILL]: ramp.roles.cta,
-    [STAMP_FILL_HOVER]: ramp.roles.ctaHover,
-    [STAMP_FILL_PRESSED]: ramp.roles.ctaPressed
+// src/engine/dtcgRender.ts
+var STAMP = [STAMP_FILL, STAMP_FILL_HOVER, STAMP_FILL_PRESSED, STAMP_EDGE, STAMP_ON];
+var STOPS = Array.from({ length: SCALE_STOP_COUNT }, (_, i) => stopTokenName(i + 1));
+function tokenPaths() {
+  const family = (word, poles) => [
+    ...poles ? [familyPath(word, PAPER_0)] : [],
+    ...STOPS.map((leaf) => familyPath(word, leaf)),
+    ...poles ? [familyPath(word, PEN_100)] : [],
+    ...STAMP.map((leaf) => familyPath(word, leaf))
+  ];
+  return [
+    ...family(CSS_FAMILY.neutral, true),
+    ...family(CSS_FAMILY.brandPrimary, false),
+    ...family(CSS_FAMILY.brandSecondary, false),
+    ...SIGNALS2.flatMap((s) => family(s.emitName, false)),
+    ...LINK_POSTURES.flatMap((posture) => LINK_STATES.map((state) => linkPath(posture, state))),
+    absolutePath(CSS_FAMILY.brandPrimary),
+    absolutePath(CSS_FAMILY.brandSecondary)
+  ];
+}
+var byName = () => new Map(tokenPaths().map((p) => [cssVarName(p).slice(2), p]));
+function tokenPathOf(name) {
+  return byName().get(name);
+}
+function descriptionPathOf(name) {
+  const p = tokenPathOf(name);
+  return p && figmaPathOf(p);
+}
+var component = (c8) => Math.round(c8 / 255 * 1e4) / 1e4;
+var colorValue = (r, g2, b, alpha) => ({
+  colorSpace: "srgb",
+  components: [component(r), component(g2), component(b)],
+  alpha,
+  hex: "#" + [r, g2, b].map((c) => c.toString(16).padStart(2, "0")).join("")
+});
+function dtcgColor(value) {
+  let m;
+  if (m = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(value)) return colorValue(parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16), 1);
+  if (m = /^rgba\((\d+), (\d+), (\d+), ([0-9.]+)\)$/.exec(value)) return colorValue(+m[1], +m[2], +m[3], +m[4]);
+  if (value === "transparent") return colorValue(0, 0, 0, 0);
+  throw new Error(`dtcgColor: not a color the emitters write: ${value}`);
+}
+var ALIAS = /^var\(--([a-z0-9-]+)\)$/;
+var SEGMENT = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function tokensToDtcg(tokens, options = {}) {
+  const { rootGroup } = options;
+  if (rootGroup !== void 0 && !SEGMENT.test(rootGroup)) throw new Error(`tokensToDtcg: rootGroup must be lower-case words and digits joined by hyphens: ${JSON.stringify(rootGroup)}`);
+  const rooted = (path) => rootGroup === void 0 ? path : [rootGroup, ...path];
+  const paths = byName();
+  const roster = new Set(paths.keys());
+  for (const name of tokens.names) if (!roster.has(name)) throw new Error(`tokensToDtcg: the emit carries a name the roster does not know: ${name}`);
+  for (const name of roster) if (!(name in tokens.light)) throw new Error(`tokensToDtcg: the emit lacks ${name}`);
+  const build = (mode) => {
+    const doc = {};
+    for (const [name, path] of paths) {
+      const raw = tokens.raw[mode][name] ?? tokens.raw.light[name];
+      const alias = ALIAS.exec(raw);
+      let token;
+      if (alias) {
+        const target = paths.get(alias[1]);
+        if (!target) throw new Error(`tokensToDtcg: ${name} references a name outside the roster: ${alias[1]}`);
+        token = { $type: "color", $value: `{${rooted(target).join(".")}}` };
+      } else {
+        token = { $type: "color", $value: dtcgColor(tokens[mode][name]) };
+      }
+      const body = describeDocument(figmaPathOf(path));
+      if (body) token.$description = body;
+      let cur = doc;
+      for (const seg of rooted(path).slice(0, -1)) {
+        const next = cur[seg];
+        if (next && "$type" in next) throw new Error(`tokensToDtcg: ${seg} is both a token and a group on the way to ${path.join("/")}`);
+        cur = cur[seg] ?? (cur[seg] = {});
+      }
+      const leaf = path[path.length - 1];
+      if (leaf in cur) throw new Error(`tokensToDtcg: duplicate path ${path.join("/")}`);
+      cur[leaf] = token;
+    }
+    return doc;
   };
-  for (const rr of spec.roles) {
-    const rv = roleVal[rr.role];
-    group[rr.role] = { $type: "color", $value: hexToValue(rv.hex), $extensions: { [EXT_KEY]: { resolver: RESOLVER_ID, seed: seedRef, mode, ...rr } } };
-  }
-  return group;
-}
-function parseToken(token) {
-  const ext = token.$extensions?.[EXT_KEY];
-  if (!ext) throw new Error("missing $extensions." + EXT_KEY);
-  if (ext.resolver !== RESOLVER_ID) throw new Error(`unknown resolver "${ext.resolver}" (this resolver is ${RESOLVER_ID})`);
-  const { resolver, seed, mode, ...req } = ext;
-  const isRole = "role" in req;
-  if (!isRole) {
-    for (const k of ["stop", "rootL", "group", "produce"]) if (req[k] === void 0) throw new Error(`stop requirement missing "${k}"`);
-  }
-  if (isRole) {
-    for (const k of ["role", "produce", "floorL", "chromaMult"]) if (req[k] === void 0) throw new Error(`role requirement missing "${k}"`);
-  }
-  if (isRole && LEGACY_ROLE_NAMES[req.role]) req.role = LEGACY_ROLE_NAMES[req.role];
-  return { req, seedRef: seed, mode };
-}
-function resolveDtcgRamp(group) {
-  const seedHex = group.seed.$value.hex;
-  const ons = group.$extensions?.[EXT_KEY]?.ons;
-  if (!ons) throw new Error("missing group-level ons declaration");
-  const stops = [];
-  const roles = [];
-  let mode;
-  for (const [k, t] of Object.entries(group)) {
-    if (k === "seed" || k === "$extensions") continue;
-    const { req, mode: m } = parseToken(t);
-    mode ?? (mode = m);
-    "role" in req ? roles.push(req) : stops.push(req);
-  }
-  if (!mode) throw new Error("empty ramp group");
-  stops.sort((a, b) => a.stop - b.stop);
-  return resolveRamp(seedHex, mode, { stops, roles, ons });
+  return { light: build("light"), dark: build("dark") };
 }
 export {
+  ABSOLUTE_GROUP,
+  BAND_STOPS,
+  COLOR_GROUP,
   CSS_FAMILY,
   DEFAULT_LINK_HEX,
-  DISABLED_OPACITY,
-  EXT_KEY,
-  INTERACTION_FAMILIES,
-  INTERACTION_LADDER,
-  INTERACTION_POLE_FAMILY,
-  INTERACTION_ROWS,
-  INTERACTION_RUNGS,
-  INTERACTION_STATES,
+  GUARANTEE_SCOPE,
+  LINK_GROUP,
+  LINK_POSTURES,
+  LINK_STATES,
   MODE_SPECS,
   OFFSET_ALPHAS,
-  OPACITY_RUNGS,
   OUTLINE_HOVER_ALPHA,
   PAPER_0,
   PEN_100,
-  RESOLVER_ID,
   SCALE_STOP_COUNT,
-  SCRIM_ALPHA,
   SECONDARY_DISTINCT_DELTA_E,
-  SHADOW_ALPHAS,
   SIGNALS2 as SIGNALS,
   SIGNAL_EMIT_NAME,
   SIGNAL_SCALES,
@@ -4247,38 +4022,35 @@ export {
   STAMP_FILL,
   STAMP_FILL_HOVER,
   STAMP_FILL_PRESSED,
+  STAMP_LEAF,
   STAMP_ON,
   STAMP_STATE_LEAVES,
   SUBTLE_PASTEL_K,
   SUBTLE_TINT_MULT,
-  SURFACE_PLANE_LAW,
-  SYSTEM_LEAF,
+  absolutePath,
   brandCss,
   checkAllCollisions,
   checkCollision,
   checkHueCollision,
   classifyArchetype,
+  cssVarName,
   ctaBorderRung,
   ctaNeedsBorder,
-  emitDtcgRamp,
+  describeDocument,
+  describeToken,
+  descriptionPathOf,
+  familyPath,
+  figmaPathOf,
   generateNeutralScale,
   generateScale,
   generateSubtleSecondary,
-  interactionCss,
-  interactionRows,
-  interactionTintName,
-  interactionTokens,
-  interactionVarName,
+  groupEntries,
+  linkPath,
   neutralCss,
   neutralTintHue,
-  opacityLeafName,
-  opacityTokenPath,
-  opacityVarName,
   pageStopFor,
-  parseToken,
   readEmission,
   resolveBrand,
-  resolveDtcgRamp,
   resolveLinkInverseTrio,
   resolveLinkTrio,
   resolveReferences,
@@ -4288,10 +4060,11 @@ export {
   stopHex,
   stopTokenName,
   stopsToVars,
-  systemCss,
   themeToFigma,
   themeTokens,
   toHex2 as toHex,
   tokenOrder,
-  tokensFromEmission
+  tokenPathOf,
+  tokensFromEmission,
+  tokensToDtcg
 };