rafters 0.0.64 → 0.0.65

package/dist/index.js

@@ -18394,94 +18394,6 @@ function generateHarmony(baseColor) {
     monochromatic
   };
 }
-function generateSemanticColorSuggestions(baseColor) {
-  const danger = [
-    roundOKLCH({
-      l: Math.max(0.55, Math.min(0.7, baseColor.l + 0.1)),
-      c: Math.min(0.25, baseColor.c * 1.2),
-      h: 15,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.6, Math.min(0.75, baseColor.l + 0.15)),
-      c: Math.min(0.22, baseColor.c * 1.1),
-      h: 25,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.5, Math.min(0.65, baseColor.l + 0.05)),
-      c: Math.min(0.23, baseColor.c * 1.15),
-      h: 5,
-      alpha: 1
-    })
-  ];
-  const success2 = [
-    roundOKLCH({
-      l: Math.max(0.6, Math.min(0.75, baseColor.l + 0.15)),
-      c: Math.min(0.2, baseColor.c * 0.9),
-      h: 135,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.55, Math.min(0.7, baseColor.l + 0.1)),
-      c: Math.min(0.22, baseColor.c * 1),
-      h: 145,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.65, Math.min(0.8, baseColor.l + 0.2)),
-      c: Math.min(0.24, baseColor.c * 1.1),
-      h: 125,
-      alpha: 1
-    })
-  ];
-  const warning = [
-    roundOKLCH({
-      l: Math.max(0.7, Math.min(0.8, baseColor.l + 0.15)),
-      c: Math.min(0.2, baseColor.c * 0.95),
-      h: 45,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.75, Math.min(0.85, baseColor.l + 0.2)),
-      c: Math.min(0.18, baseColor.c * 0.9),
-      h: 55,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.72, Math.min(0.82, baseColor.l + 0.17)),
-      c: Math.min(0.19, baseColor.c * 0.92),
-      h: 35,
-      alpha: 1
-    })
-  ];
-  const info = [
-    roundOKLCH({
-      l: Math.max(0.6, Math.min(0.75, baseColor.l + 0.1)),
-      c: Math.min(0.2, baseColor.c * 0.9),
-      h: 220,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.55, Math.min(0.7, baseColor.l + 0.05)),
-      c: Math.min(0.22, baseColor.c * 1),
-      h: 230,
-      alpha: 1
-    }),
-    roundOKLCH({
-      l: Math.max(0.5, Math.min(0.65, baseColor.l)),
-      c: Math.min(0.25, baseColor.c * 1.1),
-      h: 240,
-      alpha: 1
-    })
-  ];
-  return {
-    danger: danger.map(clampColor),
-    success: success2.map(clampColor),
-    warning: warning.map(clampColor),
-    info: info.map(clampColor)
-  };
-}
 function validateScaleGeneration(baseColor) {
   const l = baseColor.l;
   if (l > 0.85) {
@@ -21213,44 +21125,255 @@ var POSITION_TO_INDEX = SCALE_POSITIONS.reduce(
   },
   {}
 );
-var MIN_WCAG_PAIR_DISTANCE = 3;
-function findBestWcagPair(sourceIndex, pairs, wantHigher) {
-  let best;
-  let bestDistance = -1;
+
+// ../color-utils/src/semantic.ts
+var SemanticSelectionError = class extends Error {
+  constructor(familyName, message) {
+    super(`semantic selection: family "${familyName}" ${message}`);
+    this.familyName = familyName;
+    this.name = "SemanticSelectionError";
+  }
+};
+var STATE_USES = ["hover", "active", "focus", "disabled"];
+var STATE_RANK_STEP = {
+  hover: (rank) => rank + 1,
+  active: (rank) => rank + 2,
+  focus: (rank) => rank + 1,
+  disabled: (_rank, ladder) => closestRankTo(ladder, 5)
+};
+function partnerForBase(pairs, base) {
+  if (!pairs) return void 0;
+  for (const [p1, p2] of pairs) {
+    if (p1 === base) return p2;
+    if (p2 === base) return p1;
+  }
+  return void 0;
+}
+function nearestPartner(pairs, base) {
+  if (!pairs || pairs.length === 0) return void 0;
+  const anchors = /* @__PURE__ */ new Set();
   for (const pair of pairs) {
-    if (!pair || pair.length < 2) continue;
-    const [a2, b2] = pair;
-    if (a2 === void 0 || b2 === void 0) continue;
-    let partner;
-    if (a2 === sourceIndex) partner = b2;
-    else if (b2 === sourceIndex) partner = a2;
-    else continue;
-    if (wantHigher && partner <= sourceIndex) continue;
-    if (!wantHigher && partner >= sourceIndex) continue;
-    const distance2 = Math.abs(partner - sourceIndex);
-    if (distance2 > bestDistance) {
+    for (const position of pair) anchors.add(position);
+  }
+  let nearest = -1;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const anchor of anchors) {
+    const distance2 = Math.abs(anchor - base);
+    if (distance2 < bestDistance) {
       bestDistance = distance2;
-      best = partner;
+      nearest = anchor;
     }
   }
-  return best;
+  return nearest === -1 ? void 0 : partnerForBase(pairs, nearest);
 }
-function findDarkCounterpartIndex(lightIndex, colorValue) {
-  const aaaPairs = colorValue.accessibility?.wcagAAA?.normal ?? [];
-  const aaPairs = colorValue.accessibility?.wcagAA?.normal ?? [];
-  if (aaaPairs.length === 0 && aaPairs.length === 0) {
-    throw new Error(
-      `No WCAG accessibility data available for dark mode counterpart of index ${lightIndex}. ColorValue must include accessibility.wcagAAA or wcagAA pair matrices.`
-    );
+function collectLadder(pairs) {
+  const positions = /* @__PURE__ */ new Set();
+  for (const pair of pairs) {
+    for (const position of pair) positions.add(position);
   }
-  const wantHigher = lightIndex <= 5;
-  for (const pairs of [aaaPairs, aaPairs]) {
-    const match = findBestWcagPair(lightIndex, pairs, wantHigher);
-    if (match !== void 0 && Math.abs(match - lightIndex) >= MIN_WCAG_PAIR_DISTANCE) {
-      return match;
+  return Array.from(positions).sort((a2, b2) => a2 - b2);
+}
+function closestRankTo(ladder, target) {
+  let bestRank = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let rank = 0; rank < ladder.length; rank++) {
+    const position = ladder[rank];
+    if (position === void 0) continue;
+    const distance2 = Math.abs(position - target);
+    if (distance2 < bestDistance) {
+      bestDistance = distance2;
+      bestRank = rank;
     }
   }
-  return Math.max(0, Math.min(10, 10 - lightIndex));
+  return bestRank;
+}
+function requirePosition(index, familyName) {
+  const position = SCALE_POSITIONS[index];
+  if (!position) {
+    throw new SemanticSelectionError(familyName, `produced invalid scale index ${index}`);
+  }
+  return position;
+}
+function requireIndex(position, familyName) {
+  const index = POSITION_TO_INDEX[position];
+  if (index === void 0) {
+    throw new SemanticSelectionError(familyName, `has no scale position "${position}"`);
+  }
+  return index;
+}
+var STATUS_ROLE_ANCHORS = {
+  // band is the recognizability range a variant may never leave;
+  // [min > max] means the band wraps through 0 (destructive: 330..360..30).
+  destructive: { hue: 25, l: 0.55, cCap: 0.2, cScale: 1, band: [330, 30] },
+  success: { hue: 145, l: 0.55, cCap: 0.18, cScale: 0.9, band: [120, 160] },
+  warning: { hue: 85, l: 0.75, cCap: 0.18, cScale: 0.9, band: [60, 110] },
+  info: { hue: 230, l: 0.58, cCap: 0.15, cScale: 0.85, band: [200, 250] }
+};
+function statusAnchor(role, seed) {
+  const spec = STATUS_ROLE_ANCHORS[role];
+  return roundOKLCH({
+    l: spec.l,
+    c: Math.min(spec.cCap, seed.c * spec.cScale),
+    h: spec.hue,
+    alpha: seed.alpha ?? 1
+  });
+}
+function clampHueToBand(hue, band) {
+  const h = (hue % 360 + 360) % 360;
+  const [min, max2] = band;
+  if (min <= max2) return Math.max(min, Math.min(max2, h));
+  if (h >= min || h <= max2) return h;
+  const toMin = Math.abs(h - min);
+  const toMax = Math.abs(h - max2);
+  return toMin < toMax ? min : max2;
+}
+var VARIANT_OFFSETS = [
+  { dh: 0, dl: 0 },
+  { dh: 10, dl: 0.05 },
+  { dh: -10, dl: -0.05 }
+];
+function generateSemanticColorSuggestions(baseColor) {
+  const roles = {};
+  for (const role of Object.keys(STATUS_ROLE_ANCHORS)) {
+    const anchor = statusAnchor(role, baseColor);
+    const { band } = STATUS_ROLE_ANCHORS[role];
+    roles[role] = VARIANT_OFFSETS.map(({ dh, dl }) => {
+      const raw = roundOKLCH({
+        l: Math.max(0, Math.min(1, anchor.l + dl)),
+        c: anchor.c,
+        h: clampHueToBand(anchor.h + dh, band),
+        alpha: anchor.alpha ?? 1
+      });
+      return roundOKLCH(toNearestGamut(raw).color);
+    });
+  }
+  return { ...roles, danger: roles.destructive };
+}
+function semanticFor(family, options) {
+  const familyName = options?.name ?? family.name;
+  const refs = family;
+  const aaaPairs = family.accessibility?.wcagAAA?.normal;
+  const aaPairs = family.accessibility?.wcagAA?.normal;
+  function foregroundPair(from, level) {
+    const auto = refs.foregroundReferences?.auto;
+    if (auto) {
+      return {
+        from: { family: familyName, position: from },
+        to: { family: auto.family, position: auto.position },
+        standard: level,
+        tier: "reference"
+      };
+    }
+    const base = requireIndex(from, familyName);
+    const exactAAA = partnerForBase(aaaPairs, base);
+    const aaa = exactAAA ?? nearestPartner(aaaPairs, base);
+    const exactAA = partnerForBase(aaPairs, base);
+    const aa = exactAA ?? nearestPartner(aaPairs, base);
+    const partner = level === "AAA" ? aaa ?? aa : aa;
+    if (partner === void 0) {
+      throw new SemanticSelectionError(
+        familyName,
+        `has no WCAG pair partner for position ${from} (accessibility metadata required)`
+      );
+    }
+    const fromAAA = level === "AAA" && aaa !== void 0;
+    return {
+      from: { family: familyName, position: from },
+      to: { family: familyName, position: requirePosition(partner, familyName) },
+      standard: fromAAA ? "AAA" : "AA",
+      tier: (fromAAA ? exactAAA : exactAA) !== void 0 ? "pair-exact" : "pair-nearest"
+    };
+  }
+  function statePair(use, from) {
+    const precomputed = refs.stateReferences?.[use];
+    if (precomputed) {
+      return {
+        from: { family: familyName, position: from },
+        to: { family: precomputed.family, position: String(precomputed.position) },
+        standard: "AAA",
+        tier: "reference"
+      };
+    }
+    if (!aaaPairs || aaaPairs.length === 0) {
+      throw new SemanticSelectionError(
+        familyName,
+        "has no accessibility.wcagAAA.normal ladder (color generator must emit accessibility metadata)"
+      );
+    }
+    const base = requireIndex(from, familyName);
+    const ladder = collectLadder(aaaPairs);
+    const baseRank = closestRankTo(ladder, base);
+    const targetRank = STATE_RANK_STEP[use](baseRank, ladder);
+    const clampedRank = Math.max(0, Math.min(ladder.length - 1, targetRank));
+    const targetIndex = ladder[clampedRank];
+    if (targetIndex === void 0) {
+      throw new SemanticSelectionError(familyName, `ladder lookup failed at rank ${clampedRank}`);
+    }
+    return {
+      from: { family: familyName, position: from },
+      to: { family: familyName, position: requirePosition(targetIndex, familyName) },
+      standard: "AAA",
+      tier: "ladder"
+    };
+  }
+  function invert(pair) {
+    if (pair.to.family !== familyName && pair.tier !== "reference") {
+      throw new SemanticSelectionError(
+        familyName,
+        `cannot invert a pair whose legs belong to "${pair.from.family}"/"${pair.to.family}"`
+      );
+    }
+    const fromTarget = 10 - requireIndex(pair.from.position, familyName);
+    const toIndex = POSITION_TO_INDEX[pair.to.position];
+    const toTarget = toIndex === void 0 ? void 0 : 10 - toIndex;
+    for (const [pairs, standard] of [
+      [aaaPairs, "AAA"],
+      [aaPairs, "AA"]
+    ]) {
+      if (!pairs || pairs.length === 0) continue;
+      let best = null;
+      for (const [p1, p2] of pairs) {
+        if (p1 === void 0 || p2 === void 0) continue;
+        for (const [a2, b2] of [
+          [p1, p2],
+          [p2, p1]
+        ]) {
+          const fromDist = Math.abs(a2 - fromTarget);
+          const toDist = toTarget === void 0 ? 0 : Math.abs(b2 - toTarget);
+          const better = best === null || fromDist < best.fromDist || fromDist === best.fromDist && toDist < best.toDist || fromDist === best.fromDist && toDist === best.toDist && a2 < best.from;
+          if (better) best = { from: a2, to: b2, fromDist, toDist };
+        }
+      }
+      if (best) {
+        return {
+          from: { family: familyName, position: requirePosition(best.from, familyName) },
+          to: { family: familyName, position: requirePosition(best.to, familyName) },
+          standard,
+          tier: best.fromDist === 0 && best.toDist === 0 ? "pair-exact" : "pair-nearest"
+        };
+      }
+    }
+    const toFallback = toTarget === void 0 ? fromTarget : toTarget;
+    return {
+      from: { family: familyName, position: requirePosition(fromTarget, familyName) },
+      to: { family: familyName, position: requirePosition(toFallback, familyName) },
+      standard: "none",
+      tier: "inversion"
+    };
+  }
+  return {
+    pair(request) {
+      const level = request.level ?? "AAA";
+      if (request.use === "foreground") return foregroundPair(request.from, level);
+      return statePair(request.use, request.from);
+    },
+    states(from) {
+      const out = {};
+      for (const use of STATE_USES) out[use] = statePair(use, from);
+      return out;
+    },
+    invert
+  };
 }
 
 // ../color-utils/src/builder.ts
@@ -21603,12 +21726,22 @@ var PerceptualWeightSchema = external_exports.object({
   density: external_exports.enum(["light", "medium", "heavy"]),
   balancingRecommendation: external_exports.string()
 });
-var SemanticColorSuggestionsSchema = external_exports.object({
-  danger: external_exports.array(OKLCHSchema),
-  success: external_exports.array(OKLCHSchema),
-  warning: external_exports.array(OKLCHSchema),
-  info: external_exports.array(OKLCHSchema)
-});
+var SemanticColorSuggestionsSchema = external_exports.preprocess(
+  (raw) => {
+    if (raw && typeof raw === "object" && !("destructive" in raw) && "danger" in raw) {
+      return { ...raw, destructive: raw.danger };
+    }
+    return raw;
+  },
+  external_exports.object({
+    destructive: external_exports.array(OKLCHSchema),
+    success: external_exports.array(OKLCHSchema),
+    warning: external_exports.array(OKLCHSchema),
+    info: external_exports.array(OKLCHSchema),
+    /** @deprecated mirror of `destructive`; dies when apps/api leaves the repo */
+    danger: external_exports.array(OKLCHSchema).optional()
+  })
+);
 var ColorValueSchema = external_exports.object({
   name: external_exports.string(),
   // the fancy name from color-utils, IE ocean-blue
@@ -27376,12 +27509,12 @@ function derivationParent(derivation, suffix = "") {
       return `${derivation.against}${suffix}`;
   }
 }
-function deriveDarkBinding(derivation) {
+function deriveDarkBinding(derivation, parentName) {
   switch (derivation.kind) {
     case "scale":
       return {
         plugin: "invert",
-        input: { familyName: derivation.family, basePosition: derivation.scalePosition }
+        input: { fromToken: parentName }
       };
     case "state":
       return {
@@ -27406,7 +27539,7 @@ function generateSemanticTokens(_config) {
     const binding = derivationToBinding(derivation);
     const parent = derivationParent(derivation);
     const darkName = `${name}--dark`;
-    const darkBinding = deriveDarkBinding(derivation);
+    const darkBinding = deriveDarkBinding(derivation, name);
     const darkParent = derivationParent(derivation, "--dark");
     const dependsOn = [parent, darkName];
     tokens.push({
@@ -28883,14 +29016,30 @@ function readEnvelopes(dir) {
 // ../design-tokens/src/plugin.ts
 function resolveFamily(familyName, get3) {
   let resolved = get3(familyName);
-  let resolvedName = familyName;
+  let name = familyName;
   if (resolved && typeof resolved === "object" && "family" in resolved && "position" in resolved) {
-    resolvedName = resolved.family;
-    resolved = get3(resolvedName);
+    name = resolved.family;
+    resolved = get3(name);
   }
-  const family = resolved;
-  if (!family) return null;
-  return { family, resolvedName };
+  if (!resolved || typeof resolved !== "object" || !("scale" in resolved)) return null;
+  return { family: resolved, familyName: name };
+}
+function resolveParent(tokenName, get3) {
+  const raw = get3(tokenName);
+  if (!raw || typeof raw !== "object" || !("family" in raw) || !("position" in raw)) return null;
+  const ref = raw;
+  const positionIndex = POSITION_TO_INDEX[ref.position];
+  if (positionIndex === void 0) return null;
+  const result = resolveFamily(ref.family, get3);
+  if (!result) return null;
+  return { ref, positionIndex, ...result };
+}
+function requireSemanticParent(tokenName, get3, pluginName) {
+  const resolved = resolveParent(tokenName, get3);
+  if (!resolved) {
+    throw new Error(`${pluginName} plugin: "${tokenName}" could not resolve`);
+  }
+  return { sem: semanticFor(resolved.family, { name: resolved.familyName }), resolved };
 }
 function definePlugin(spec) {
   return {
@@ -28944,132 +29093,32 @@ var ContrastInputSchema = external_exports.object({
   against: external_exports.string(),
   level: external_exports.enum(["AA", "AAA"]).default("AAA")
 });
-function partnerForBase(pairs, basePosition) {
-  if (!pairs) return void 0;
-  for (const [p1, p2] of pairs) {
-    if (p1 === basePosition) return p2;
-    if (p2 === basePosition) return p1;
-  }
-  return void 0;
-}
-function nearestPartner(pairs, basePosition) {
-  if (!pairs || pairs.length === 0) return void 0;
-  const anchors = /* @__PURE__ */ new Set();
-  for (const pair of pairs) {
-    for (const position of pair) anchors.add(position);
-  }
-  if (anchors.size === 0) return void 0;
-  let nearest = -1;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (const anchor of anchors) {
-    const distance2 = Math.abs(anchor - basePosition);
-    if (distance2 < bestDistance) {
-      bestDistance = distance2;
-      nearest = anchor;
-    }
-  }
-  if (nearest === -1) return void 0;
-  return partnerForBase(pairs, nearest);
-}
-function requireScalePosition(index, label) {
-  const position = SCALE_POSITIONS[index];
-  if (!position) {
-    throw new Error(`contrast plugin: invalid scale index ${index} (${label})`);
-  }
-  return position;
-}
-function isPositionString(value) {
-  return typeof value === "string";
-}
-function resolveBasePosition(position) {
-  const map2 = {
-    "50": 0,
-    "100": 1,
-    "200": 2,
-    "300": 3,
-    "400": 4,
-    "500": 5,
-    "600": 6,
-    "700": 7,
-    "800": 8,
-    "900": 9,
-    "950": 10
-  };
-  const index = map2[position];
-  if (index === void 0) {
-    throw new Error(`contrast plugin: unknown scale position "${position}"`);
-  }
-  return index;
-}
 var contrastPlugin = definePlugin({
   name: "contrast",
   inputSchema: ContrastInputSchema,
   outputSchema: ColorReferenceSchema,
   dependsOn: (input2) => [input2.against],
   transform: (input2, get3) => {
-    const parent = get3(input2.against);
-    if (!parent || typeof parent !== "object" || !("family" in parent) || !("position" in parent)) {
-      throw new Error(
-        `contrast plugin: parent token "${input2.against}" did not resolve to a ColorReference`
-      );
-    }
-    const parentRef = parent;
-    if (!isPositionString(parentRef.position)) {
-      throw new Error(
-        `contrast plugin: parent token "${input2.against}" position is not a scale string`
-      );
-    }
-    const basePosition = resolveBasePosition(parentRef.position);
-    const family = get3(parentRef.family);
-    if (!family) {
-      throw new Error(
-        `contrast plugin: family "${parentRef.family}" (from "${input2.against}") not in registry`
-      );
-    }
-    if (family.foregroundReferences?.auto) {
-      const ref = family.foregroundReferences.auto;
-      return { family: ref.family, position: ref.position };
-    }
-    if (family.accessibility) {
-      const aaaPartner = partnerForBase(family.accessibility.wcagAAA?.normal, basePosition) ?? nearestPartner(family.accessibility.wcagAAA?.normal, basePosition);
-      const aaPartner = partnerForBase(family.accessibility.wcagAA?.normal, basePosition) ?? nearestPartner(family.accessibility.wcagAA?.normal, basePosition);
-      const partner = input2.level === "AAA" ? aaaPartner ?? aaPartner : aaPartner;
-      if (partner !== void 0) {
-        return {
-          family: parentRef.family,
-          position: requireScalePosition(partner, `${parentRef.family} pair`)
-        };
-      }
-    }
-    throw new Error(
-      `contrast plugin: family "${parentRef.family}" has no foregroundReferences and no accessibility WCAG pair partner for position ${parentRef.position} (against ${input2.against})`
-    );
+    const { sem, resolved } = requireSemanticParent(input2.against, get3, "contrast");
+    const pair = sem.pair({ use: "foreground", from: resolved.ref.position, level: input2.level });
+    return { family: pair.to.family, position: pair.to.position };
   }
 });
 
 // ../design-tokens/src/plugins/invert.ts
 var InvertInputSchema = external_exports.object({
-  familyName: external_exports.string(),
-  basePosition: external_exports.number().int().min(0).max(10)
+  fromToken: external_exports.string()
 });
 var invertPlugin = definePlugin({
   name: "invert",
   inputSchema: InvertInputSchema,
   outputSchema: ColorReferenceSchema,
-  dependsOn: (input2) => [input2.familyName],
+  dependsOn: (input2) => [input2.fromToken],
   transform: (input2, get3) => {
-    const result = resolveFamily(input2.familyName, get3);
-    if (!result) {
-      throw new Error(`invert plugin: family "${input2.familyName}" not found in registry`);
-    }
-    const darkIndex = findDarkCounterpartIndex(input2.basePosition, result.family);
-    const darkPosition = SCALE_POSITIONS[darkIndex];
-    if (!darkPosition) {
-      throw new Error(
-        `invert plugin: invalid dark index ${darkIndex} for base position ${input2.basePosition}`
-      );
-    }
-    return { family: result.resolvedName, position: darkPosition };
+    const { sem, resolved } = requireSemanticParent(input2.fromToken, get3, "invert");
+    const lightPair = sem.pair({ use: "foreground", from: resolved.ref.position });
+    const darkPair = sem.invert(lightPair);
+    return { family: resolved.familyName, position: darkPair.from.position };
   }
 });
 
@@ -29092,7 +29141,7 @@ var scalePlugin = definePlugin({
     if (position === void 0) {
       throw new Error(`scale plugin: invalid position index ${input2.scalePosition}`);
     }
-    return { family: result.resolvedName, position };
+    return { family: result.familyName, position };
   }
 });
 
@@ -29102,115 +29151,15 @@ var StateInputSchema = external_exports.object({
   from: external_exports.string(),
   stateType: StateTypeSchema
 });
-var POSITION_TO_INDEX3 = {
-  "50": 0,
-  "100": 1,
-  "200": 2,
-  "300": 3,
-  "400": 4,
-  "500": 5,
-  "600": 6,
-  "700": 7,
-  "800": 8,
-  "900": 9,
-  "950": 10
-};
-var STEP_BY_STATE = {
-  hover: (rank) => rank + 1,
-  active: (rank) => rank + 2,
-  focus: (rank) => rank + 1,
-  disabled: (_rank, ladder) => closestRankToMidpoint(ladder)
-};
-function closestRankToMidpoint(ladder) {
-  let bestRank = 0;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (let r = 0; r < ladder.length; r++) {
-    const position = ladder[r];
-    if (position === void 0) continue;
-    const distance2 = Math.abs(position - 5);
-    if (distance2 < bestDistance) {
-      bestDistance = distance2;
-      bestRank = r;
-    }
-  }
-  return bestRank;
-}
-function nearestRankOnLadder(ladder, position) {
-  let bestRank = 0;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (let r = 0; r < ladder.length; r++) {
-    const candidate = ladder[r];
-    if (candidate === void 0) continue;
-    const distance2 = Math.abs(candidate - position);
-    if (distance2 < bestDistance) {
-      bestDistance = distance2;
-      bestRank = r;
-    }
-  }
-  return bestRank;
-}
-function collectLadder(pairs) {
-  const positions = /* @__PURE__ */ new Set();
-  for (const pair of pairs) {
-    for (const position of pair) positions.add(position);
-  }
-  return Array.from(positions).sort((a2, b2) => a2 - b2);
-}
 var statePlugin = definePlugin({
   name: "state",
   inputSchema: StateInputSchema,
   outputSchema: ColorReferenceSchema,
   dependsOn: (input2) => [input2.from],
   transform: (input2, get3) => {
-    const parent = get3(input2.from);
-    if (!parent || typeof parent !== "object" || !("family" in parent) || !("position" in parent)) {
-      throw new Error(
-        `state plugin: parent token "${input2.from}" did not resolve to a ColorReference`
-      );
-    }
-    const parentRef = parent;
-    if (typeof parentRef.position !== "string") {
-      throw new Error(`state plugin: parent token "${input2.from}" position is not a scale string`);
-    }
-    const basePosition = POSITION_TO_INDEX3[parentRef.position];
-    if (basePosition === void 0) {
-      throw new Error(
-        `state plugin: parent token "${input2.from}" position "${parentRef.position}" is not a known scale step`
-      );
-    }
-    const family = get3(parentRef.family);
-    if (!family) {
-      throw new Error(
-        `state plugin: family "${parentRef.family}" (from "${input2.from}") not in registry`
-      );
-    }
-    const precomputed = family.stateReferences?.[input2.stateType];
-    if (precomputed) {
-      return { family: precomputed.family, position: String(precomputed.position) };
-    }
-    const pairs = family.accessibility?.wcagAAA?.normal;
-    if (!pairs || pairs.length === 0) {
-      throw new Error(
-        `state plugin: family "${parentRef.family}" has no accessibility.wcagAAA.normal ladder (color generator must emit accessibility metadata)`
-      );
-    }
-    const ladder = collectLadder(pairs);
-    const baseRank = nearestRankOnLadder(ladder, basePosition);
-    const targetRank = STEP_BY_STATE[input2.stateType](baseRank, ladder);
-    const clampedRank = Math.max(0, Math.min(ladder.length - 1, targetRank));
-    const targetIndex = ladder[clampedRank];
-    if (targetIndex === void 0) {
-      throw new Error(
-        `state plugin: ladder lookup failed for rank ${clampedRank} on family "${parentRef.family}"`
-      );
-    }
-    const position = SCALE_POSITIONS[targetIndex];
-    if (!position) {
-      throw new Error(
-        `state plugin: invalid scale index ${targetIndex} for family "${parentRef.family}"`
-      );
-    }
-    return { family: parentRef.family, position };
+    const { sem, resolved } = requireSemanticParent(input2.from, get3, "state");
+    const pair = sem.pair({ use: input2.stateType, from: resolved.ref.position });
+    return { family: pair.to.family, position: pair.to.position };
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rafters",
-  "version": "0.0.64",
+  "version": "0.0.65",
   "description": "Design Intelligence CLI. Scaffold tokens, import existing shadcn/Tailwind v4 sources, add components, and serve an MCP server so AI agents read decisions instead of guessing.",
   "homepage": "https://rafters.studio",
   "license": "MIT",