rafters 0.0.64 → 0.0.67

package/dist/index.js

@@ -735,10 +735,10 @@ function jsonStringifyReplacer(_, value) {
   return value;
 }
 function cached(getter) {
-  const set4 = false;
+  const set3 = false;
   return {
     get value() {
-      if (!set4) {
+      if (!set3) {
         const value = getter();
         Object.defineProperty(this, "value", { value });
         return value;
@@ -747,8 +747,8 @@ function cached(getter) {
     }
   };
 }
-function nullish(input2) {
-  return input2 === null || input2 === void 0;
+function nullish(input) {
+  return input === null || input === void 0;
 }
 function cleanRegex(source) {
   const start = source.startsWith("^") ? 1 : 0;
@@ -1203,29 +1203,29 @@ function finalizeIssue(iss, ctx, config2) {
   }
   return full;
 }
-function getSizableOrigin(input2) {
-  if (input2 instanceof Set)
+function getSizableOrigin(input) {
+  if (input instanceof Set)
     return "set";
-  if (input2 instanceof Map)
+  if (input instanceof Map)
     return "map";
-  if (input2 instanceof File)
+  if (input instanceof File)
     return "file";
   return "unknown";
 }
-function getLengthableOrigin(input2) {
-  if (Array.isArray(input2))
+function getLengthableOrigin(input) {
+  if (Array.isArray(input))
     return "array";
-  if (typeof input2 === "string")
+  if (typeof input === "string")
     return "string";
   return "unknown";
 }
 function issue(...args) {
-  const [iss, input2, inst] = args;
+  const [iss, input, inst] = args;
   if (typeof iss === "string") {
     return {
       message: iss,
       code: "custom",
-      input: input2,
+      input,
       inst
     };
   }
@@ -1759,23 +1759,23 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
       bag.pattern = integer;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
+    const input = payload.value;
     if (isInt) {
-      if (!Number.isInteger(input2)) {
+      if (!Number.isInteger(input)) {
         payload.issues.push({
           expected: origin,
           format: def.format,
           code: "invalid_type",
           continue: false,
-          input: input2,
+          input,
           inst
         });
         return;
       }
-      if (!Number.isSafeInteger(input2)) {
-        if (input2 > 0) {
+      if (!Number.isSafeInteger(input)) {
+        if (input > 0) {
           payload.issues.push({
-            input: input2,
+            input,
             code: "too_big",
             maximum: Number.MAX_SAFE_INTEGER,
             note: "Integers must be within the safe integer range.",
@@ -1785,7 +1785,7 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
           });
         } else {
           payload.issues.push({
-            input: input2,
+            input,
             code: "too_small",
             minimum: Number.MIN_SAFE_INTEGER,
             note: "Integers must be within the safe integer range.",
@@ -1797,10 +1797,10 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
         return;
       }
     }
-    if (input2 < minimum) {
+    if (input < minimum) {
       payload.issues.push({
         origin: "number",
-        input: input2,
+        input,
         code: "too_small",
         minimum,
         inclusive: true,
@@ -1808,10 +1808,10 @@ var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat"
         continue: !def.abort
       });
     }
-    if (input2 > maximum) {
+    if (input > maximum) {
       payload.issues.push({
         origin: "number",
-        input: input2,
+        input,
         code: "too_big",
         maximum,
         inst
@@ -1829,11 +1829,11 @@ var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat"
     bag.maximum = maximum;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    if (input2 < minimum) {
+    const input = payload.value;
+    if (input < minimum) {
       payload.issues.push({
         origin: "bigint",
-        input: input2,
+        input,
         code: "too_small",
         minimum,
         inclusive: true,
@@ -1841,10 +1841,10 @@ var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat"
         continue: !def.abort
       });
     }
-    if (input2 > maximum) {
+    if (input > maximum) {
       payload.issues.push({
         origin: "bigint",
-        input: input2,
+        input,
         code: "too_big",
         maximum,
         inst
@@ -1865,16 +1865,16 @@ var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, d
       inst2._zod.bag.maximum = def.maximum;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const size = input2.size;
+    const input = payload.value;
+    const size = input.size;
     if (size <= def.maximum)
       return;
     payload.issues.push({
-      origin: getSizableOrigin(input2),
+      origin: getSizableOrigin(input),
       code: "too_big",
       maximum: def.maximum,
       inclusive: true,
-      input: input2,
+      input,
       inst,
       continue: !def.abort
     });
@@ -1893,16 +1893,16 @@ var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, d
       inst2._zod.bag.minimum = def.minimum;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const size = input2.size;
+    const input = payload.value;
+    const size = input.size;
     if (size >= def.minimum)
       return;
     payload.issues.push({
-      origin: getSizableOrigin(input2),
+      origin: getSizableOrigin(input),
       code: "too_small",
       minimum: def.minimum,
       inclusive: true,
-      input: input2,
+      input,
       inst,
       continue: !def.abort
     });
@@ -1922,13 +1922,13 @@ var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (i
     bag.size = def.size;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const size = input2.size;
+    const input = payload.value;
+    const size = input.size;
     if (size === def.size)
       return;
     const tooBig = size > def.size;
     payload.issues.push({
-      origin: getSizableOrigin(input2),
+      origin: getSizableOrigin(input),
       ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
       inclusive: true,
       exact: true,
@@ -1951,17 +1951,17 @@ var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (ins
       inst2._zod.bag.maximum = def.maximum;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const length = input2.length;
+    const input = payload.value;
+    const length = input.length;
     if (length <= def.maximum)
       return;
-    const origin = getLengthableOrigin(input2);
+    const origin = getLengthableOrigin(input);
     payload.issues.push({
       origin,
       code: "too_big",
       maximum: def.maximum,
       inclusive: true,
-      input: input2,
+      input,
       inst,
       continue: !def.abort
     });
@@ -1980,17 +1980,17 @@ var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (ins
       inst2._zod.bag.minimum = def.minimum;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const length = input2.length;
+    const input = payload.value;
+    const length = input.length;
     if (length >= def.minimum)
       return;
-    const origin = getLengthableOrigin(input2);
+    const origin = getLengthableOrigin(input);
     payload.issues.push({
       origin,
       code: "too_small",
       minimum: def.minimum,
       inclusive: true,
-      input: input2,
+      input,
       inst,
       continue: !def.abort
     });
@@ -2010,11 +2010,11 @@ var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals"
     bag.length = def.length;
   });
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const length = input2.length;
+    const input = payload.value;
+    const length = input.length;
     if (length === def.length)
       return;
-    const origin = getLengthableOrigin(input2);
+    const origin = getLengthableOrigin(input);
     const tooBig = length > def.length;
     payload.issues.push({
       origin,
@@ -2673,15 +2673,15 @@ var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
         payload.value = Number(payload.value);
       } catch (_) {
       }
-    const input2 = payload.value;
-    if (typeof input2 === "number" && !Number.isNaN(input2) && Number.isFinite(input2)) {
+    const input = payload.value;
+    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
       return payload;
     }
-    const received = typeof input2 === "number" ? Number.isNaN(input2) ? "NaN" : !Number.isFinite(input2) ? "Infinity" : void 0 : void 0;
+    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
     payload.issues.push({
       expected: "number",
       code: "invalid_type",
-      input: input2,
+      input,
       inst,
       ...received ? { received } : {}
     });
@@ -2701,13 +2701,13 @@ var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
         payload.value = Boolean(payload.value);
       } catch (_) {
       }
-    const input2 = payload.value;
-    if (typeof input2 === "boolean")
+    const input = payload.value;
+    if (typeof input === "boolean")
       return payload;
     payload.issues.push({
       expected: "boolean",
       code: "invalid_type",
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -2740,13 +2740,13 @@ var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) =>
 var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (typeof input2 === "symbol")
+    const input = payload.value;
+    if (typeof input === "symbol")
       return payload;
     payload.issues.push({
       expected: "symbol",
       code: "invalid_type",
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -2759,13 +2759,13 @@ var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) =>
   inst._zod.optin = "optional";
   inst._zod.optout = "optional";
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (typeof input2 === "undefined")
+    const input = payload.value;
+    if (typeof input === "undefined")
       return payload;
     payload.issues.push({
       expected: "undefined",
       code: "invalid_type",
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -2776,13 +2776,13 @@ var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
   inst._zod.pattern = _null;
   inst._zod.values = /* @__PURE__ */ new Set([null]);
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (input2 === null)
+    const input = payload.value;
+    if (input === null)
       return payload;
     payload.issues.push({
       expected: "null",
       code: "invalid_type",
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -2811,13 +2811,13 @@ var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
 var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (typeof input2 === "undefined")
+    const input = payload.value;
+    if (typeof input === "undefined")
       return payload;
     payload.issues.push({
       expected: "void",
       code: "invalid_type",
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -2832,15 +2832,15 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
       } catch (_err) {
       }
     }
-    const input2 = payload.value;
-    const isDate = input2 instanceof Date;
-    const isValidDate = isDate && !Number.isNaN(input2.getTime());
+    const input = payload.value;
+    const isDate = input instanceof Date;
+    const isValidDate = isDate && !Number.isNaN(input.getTime());
     if (isValidDate)
       return payload;
     payload.issues.push({
       expected: "date",
       code: "invalid_type",
-      input: input2,
+      input,
       ...isDate ? { received: "Invalid Date" } : {},
       inst
     });
@@ -2856,20 +2856,20 @@ function handleArrayResult(result, final, index) {
 var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    if (!Array.isArray(input2)) {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
       payload.issues.push({
         expected: "array",
         code: "invalid_type",
-        input: input2,
+        input,
         inst
       });
       return payload;
     }
-    payload.value = Array(input2.length);
+    payload.value = Array(input.length);
     const proms = [];
-    for (let i = 0; i < input2.length; i++) {
-      const item = input2[i];
+    for (let i = 0; i < input.length; i++) {
+      const item = input[i];
       const result = def.element._zod.run({
         value: item,
         issues: []
@@ -2886,12 +2886,12 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input2) {
+function handlePropertyResult(result, final, key, input) {
   if (result.issues.length) {
     final.issues.push(...prefixIssues(key, result.issues));
   }
   if (result.value === void 0) {
-    if (key in input2) {
+    if (key in input) {
       final.value[key] = void 0;
     }
   } else {
@@ -2914,30 +2914,30 @@ function normalizeDef(def) {
     optionalKeys: new Set(okeys)
   };
 }
-function handleCatchall(proms, input2, payload, ctx, def, inst) {
+function handleCatchall(proms, input, payload, ctx, def, inst) {
   const unrecognized = [];
   const keySet = def.keySet;
   const _catchall = def.catchall._zod;
   const t = _catchall.def.type;
-  for (const key of Object.keys(input2)) {
+  for (const key of Object.keys(input)) {
     if (keySet.has(key))
       continue;
     if (t === "never") {
       unrecognized.push(key);
       continue;
     }
-    const r = _catchall.run({ value: input2[key], issues: [] }, ctx);
+    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input2)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
     } else {
-      handlePropertyResult(r, payload, key, input2);
+      handlePropertyResult(r, payload, key, input);
     }
   }
   if (unrecognized.length) {
     payload.issues.push({
       code: "unrecognized_keys",
       keys: unrecognized,
-      input: input2,
+      input,
       inst
     });
   }
@@ -2981,12 +2981,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
-    const input2 = payload.value;
-    if (!isObject2(input2)) {
+    const input = payload.value;
+    if (!isObject2(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
-        input: input2,
+        input,
         inst
       });
       return payload;
@@ -2996,17 +2996,17 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = value.shape;
     for (const key of value.keys) {
       const el = shape[key];
-      const r = el._zod.run({ value: input2[key], issues: [] }, ctx);
+      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input2)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input)));
       } else {
-        handlePropertyResult(r, payload, key, input2);
+        handlePropertyResult(r, payload, key, input);
       }
     }
     if (!catchall) {
       return proms.length ? Promise.all(proms).then(() => payload) : payload;
     }
-    return handleCatchall(proms, input2, payload, ctx, _normalized.value, inst);
+    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
   };
 });
 var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
@@ -3064,12 +3064,12 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
-    const input2 = payload.value;
-    if (!isObject2(input2)) {
+    const input = payload.value;
+    if (!isObject2(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
-        input: input2,
+        input,
         inst
       });
       return payload;
@@ -3080,7 +3080,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
       payload = fastpass(payload, ctx);
       if (!catchall)
         return payload;
-      return handleCatchall([], input2, payload, ctx, value, inst);
+      return handleCatchall([], input, payload, ctx, value, inst);
     }
     return superParse(payload, ctx);
   };
@@ -3187,17 +3187,17 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
     return map2;
   });
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    if (!isObject(input2)) {
+    const input = payload.value;
+    if (!isObject(input)) {
       payload.issues.push({
         code: "invalid_type",
         expected: "object",
-        input: input2,
+        input,
         inst
       });
       return payload;
     }
-    const opt = disc.value.get(input2?.[def.discriminator]);
+    const opt = disc.value.get(input?.[def.discriminator]);
     if (opt) {
       return opt._zod.run(payload, ctx);
     }
@@ -3209,7 +3209,7 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
       errors: [],
       note: "No matching discriminator",
       discriminator: def.discriminator,
-      input: input2,
+      input,
       path: [def.discriminator],
       inst
     });
@@ -3219,9 +3219,9 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
 var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    const left = def.left._zod.run({ value: input2, issues: [] }, ctx);
-    const right = def.right._zod.run({ value: input2, issues: [] }, ctx);
+    const input = payload.value;
+    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
+    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
     const async = left instanceof Promise || right instanceof Promise;
     if (async) {
       return Promise.all([left, right]).then(([left2, right2]) => {
@@ -3296,10 +3296,10 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
   const items = def.items;
   const optStart = items.length - [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    if (!Array.isArray(input2)) {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
       payload.issues.push({
-        input: input2,
+        input,
         inst,
         expected: "tuple",
         code: "invalid_type"
@@ -3309,12 +3309,12 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     payload.value = [];
     const proms = [];
     if (!def.rest) {
-      const tooBig = input2.length > items.length;
-      const tooSmall = input2.length < optStart - 1;
+      const tooBig = input.length > items.length;
+      const tooSmall = input.length < optStart - 1;
       if (tooBig || tooSmall) {
         payload.issues.push({
           ...tooBig ? { code: "too_big", maximum: items.length } : { code: "too_small", minimum: items.length },
-          input: input2,
+          input,
           inst,
           origin: "array"
         });
@@ -3324,12 +3324,12 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     let i = -1;
     for (const item of items) {
       i++;
-      if (i >= input2.length) {
+      if (i >= input.length) {
         if (i >= optStart)
           continue;
       }
       const result = item._zod.run({
-        value: input2[i],
+        value: input[i],
         issues: []
       }, ctx);
       if (result instanceof Promise) {
@@ -3339,7 +3339,7 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
       }
     }
     if (def.rest) {
-      const rest = input2.slice(items.length);
+      const rest = input.slice(items.length);
       for (const el of rest) {
         i++;
         const result = def.rest._zod.run({
@@ -3367,12 +3367,12 @@ function handleTupleResult(result, final, index) {
 var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    if (!isPlainObject(input2)) {
+    const input = payload.value;
+    if (!isPlainObject(input)) {
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
-        input: input2,
+        input,
         inst
       });
       return payload;
@@ -3383,7 +3383,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       payload.value = {};
       for (const key of values) {
         if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          const result = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
@@ -3400,7 +3400,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         }
       }
       let unrecognized;
-      for (const key in input2) {
+      for (const key in input) {
         if (!values.has(key)) {
           unrecognized = unrecognized ?? [];
           unrecognized.push(key);
@@ -3409,14 +3409,14 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       if (unrecognized && unrecognized.length > 0) {
         payload.issues.push({
           code: "unrecognized_keys",
-          input: input2,
+          input,
           inst,
           keys: unrecognized
         });
       }
     } else {
       payload.value = {};
-      for (const key of Reflect.ownKeys(input2)) {
+      for (const key of Reflect.ownKeys(input)) {
         if (key === "__proto__")
           continue;
         const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
@@ -3435,7 +3435,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
           payload.value[keyResult.value] = keyResult.value;
           continue;
         }
-        const result = def.valueType._zod.run({ value: input2[key], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
@@ -3460,27 +3460,27 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
 var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    if (!(input2 instanceof Map)) {
+    const input = payload.value;
+    if (!(input instanceof Map)) {
       payload.issues.push({
         expected: "map",
         code: "invalid_type",
-        input: input2,
+        input,
         inst
       });
       return payload;
     }
     const proms = [];
     payload.value = /* @__PURE__ */ new Map();
-    for (const [key, value] of input2) {
+    for (const [key, value] of input) {
       const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
       const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
       if (keyResult instanceof Promise || valueResult instanceof Promise) {
         proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-          handleMapResult(keyResult2, valueResult2, payload, key, input2, inst, ctx);
+          handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
         }));
       } else {
-        handleMapResult(keyResult, valueResult, payload, key, input2, inst, ctx);
+        handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
       }
     }
     if (proms.length)
@@ -3488,7 +3488,7 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     return payload;
   };
 });
-function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
   if (keyResult.issues.length) {
     if (propertyKeyTypes.has(typeof key)) {
       final.issues.push(...prefixIssues(key, keyResult.issues));
@@ -3496,7 +3496,7 @@ function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx)
       final.issues.push({
         code: "invalid_key",
         origin: "map",
-        input: input2,
+        input,
         inst,
         issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
       });
@@ -3509,7 +3509,7 @@ function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx)
       final.issues.push({
         origin: "map",
         code: "invalid_element",
-        input: input2,
+        input,
         inst,
         key,
         issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
@@ -3521,10 +3521,10 @@ function handleMapResult(keyResult, valueResult, final, key, input2, inst, ctx)
 var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
-    const input2 = payload.value;
-    if (!(input2 instanceof Set)) {
+    const input = payload.value;
+    if (!(input instanceof Set)) {
       payload.issues.push({
-        input: input2,
+        input,
         inst,
         expected: "set",
         code: "invalid_type"
@@ -3533,7 +3533,7 @@ var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
     }
     const proms = [];
     payload.value = /* @__PURE__ */ new Set();
-    for (const item of input2) {
+    for (const item of input) {
       const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
       if (result instanceof Promise) {
         proms.push(result.then((result2) => handleSetResult(result2, payload)));
@@ -3558,14 +3558,14 @@ var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   inst._zod.values = valuesSet;
   inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (valuesSet.has(input2)) {
+    const input = payload.value;
+    if (valuesSet.has(input)) {
       return payload;
     }
     payload.issues.push({
       code: "invalid_value",
       values,
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -3579,14 +3579,14 @@ var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
   inst._zod.values = new Set(def.values);
   inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (inst._zod.values.has(input2)) {
+    const input = payload.value;
+    if (inst._zod.values.has(input)) {
       return payload;
     }
     payload.issues.push({
       code: "invalid_value",
       values: def.values,
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -3595,13 +3595,13 @@ var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
 var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, _ctx) => {
-    const input2 = payload.value;
-    if (input2 instanceof File)
+    const input = payload.value;
+    if (input instanceof File)
       return payload;
     payload.issues.push({
       expected: "file",
       code: "invalid_type",
-      input: input2,
+      input,
       inst
     });
     return payload;
@@ -3628,8 +3628,8 @@ var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) =>
     return payload;
   };
 });
-function handleOptionalResult(result, input2) {
-  if (result.issues.length && input2 === void 0) {
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === void 0) {
     return { issues: [], value: void 0 };
   }
   return result;
@@ -4057,20 +4057,20 @@ var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
     return payload;
   };
   inst._zod.check = (payload) => {
-    const input2 = payload.value;
-    const r = def.fn(input2);
+    const input = payload.value;
+    const r = def.fn(input);
     if (r instanceof Promise) {
-      return r.then((r2) => handleRefineResult(r2, payload, input2, inst));
+      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
     }
-    handleRefineResult(r, payload, input2, inst);
+    handleRefineResult(r, payload, input, inst);
     return;
   };
 });
-function handleRefineResult(result, payload, input2, inst) {
+function handleRefineResult(result, payload, input, inst) {
   if (!result) {
     const _iss = {
       code: "custom",
-      input: input2,
+      input,
       inst,
       // incorporates params.error into issue reporting
       path: [...inst._zod.def.path ?? []],
@@ -10385,16 +10385,16 @@ function _overwrite(tx) {
   });
 }
 function _normalize(form) {
-  return _overwrite((input2) => input2.normalize(form));
+  return _overwrite((input) => input.normalize(form));
 }
 function _trim() {
-  return _overwrite((input2) => input2.trim());
+  return _overwrite((input) => input.trim());
 }
 function _toLowerCase() {
-  return _overwrite((input2) => input2.toLowerCase());
+  return _overwrite((input) => input.toLowerCase());
 }
 function _toUpperCase() {
-  return _overwrite((input2) => input2.toUpperCase());
+  return _overwrite((input) => input.toUpperCase());
 }
 function _array(Class2, element, params) {
   return new Class2({
@@ -10636,8 +10636,8 @@ function _stringbool(Classes, _params) {
     type: "pipe",
     in: stringSchema,
     out: booleanSchema,
-    transform: ((input2, payload) => {
-      let data = input2;
+    transform: ((input, payload) => {
+      let data = input;
       if (params.case !== "sensitive")
         data = data.toLowerCase();
       if (truthySet.has(data)) {
@@ -10656,8 +10656,8 @@ function _stringbool(Classes, _params) {
         return {};
       }
     }),
-    reverseTransform: ((input2, _payload) => {
-      if (input2 === true) {
+    reverseTransform: ((input, _payload) => {
+      if (input === true) {
         return truthyArray[0] || "true";
       } else {
         return falsyArray[0] || "false";
@@ -11368,21 +11368,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
 };
-function toJSONSchema(input2, _params) {
-  if (input2 instanceof $ZodRegistry) {
+function toJSONSchema(input, _params) {
+  if (input instanceof $ZodRegistry) {
     const gen2 = new JSONSchemaGenerator(_params);
     const defs = {};
-    for (const entry of input2._idmap.entries()) {
+    for (const entry of input._idmap.entries()) {
       const [_, schema] = entry;
       gen2.process(schema);
     }
     const schemas = {};
     const external = {
-      registry: input2,
+      registry: input,
       uri: _params?.uri,
       defs
     };
-    for (const entry of input2._idmap.entries()) {
+    for (const entry of input._idmap.entries()) {
       const [key, schema] = entry;
       schemas[key] = gen2.emit(schema, {
         ..._params,
@@ -11398,8 +11398,8 @@ function toJSONSchema(input2, _params) {
     return { schemas };
   }
   const gen = new JSONSchemaGenerator(_params);
-  gen.process(input2);
-  return gen.emit(input2, _params);
+  gen.process(input);
+  return gen.emit(input, _params);
 }
 function isTransforming(_schema, _ctx) {
   const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
@@ -18278,6 +18278,39 @@ function generateAccessibilityMetadata(scale2) {
   }
   return metadata;
 }
+var CONTRAST_WHITE = { l: 1, c: 0, h: 0, alpha: 1 };
+var CONTRAST_BLACK = { l: 0, c: 0, h: 0, alpha: 1 };
+var WCAG_AA_NORMAL = 4.5;
+var WCAG_AAA_NORMAL = 7;
+function assembleWcagAccessibility(scale2, reference) {
+  const meta = generateAccessibilityMetadata([...scale2]);
+  const onWhiteRatio = calculateWCAGContrast(reference, CONTRAST_WHITE);
+  const onBlackRatio = calculateWCAGContrast(reference, CONTRAST_BLACK);
+  return {
+    wcagAA: meta.wcagAA,
+    wcagAAA: meta.wcagAAA,
+    onWhite: {
+      wcagAA: onWhiteRatio >= WCAG_AA_NORMAL,
+      wcagAAA: onWhiteRatio >= WCAG_AAA_NORMAL,
+      contrastRatio: onWhiteRatio,
+      aa: meta.onWhite.aa,
+      aaa: meta.onWhite.aaa
+    },
+    onBlack: {
+      wcagAA: onBlackRatio >= WCAG_AA_NORMAL,
+      wcagAAA: onBlackRatio >= WCAG_AAA_NORMAL,
+      contrastRatio: onBlackRatio,
+      aa: meta.onBlack.aa,
+      aaa: meta.onBlack.aaa
+    }
+  };
+}
+function rebakeAccessibility(value) {
+  if (!("scale" in value) || !Array.isArray(value.scale)) return value;
+  const reference = value.scale[5] ?? value.scale[0];
+  if (!reference) return value;
+  return { ...value, accessibility: assembleWcagAccessibility(value.scale, reference) };
+}
 
 // ../color-utils/src/analysis.ts
 function isLightColor(color) {
@@ -18394,94 +18427,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 +21158,256 @@ 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, _l, s) => rank + s,
+  active: (rank, _l, s) => rank + 2 * s,
+  focus: (rank, _l, s) => rank + s,
+  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) {
+    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;
+      nearest = anchor;
+    }
+  }
+  return nearest === -1 ? void 0 : partnerForBase(pairs, nearest);
+}
+function collectLadder(pairs) {
+  const positions = /* @__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) positions.add(position);
+  }
+  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;
-      best = partner;
+      bestRank = rank;
     }
   }
-  return best;
+  return bestRank;
 }
-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 requirePosition(index, familyName) {
+  const position = SCALE_POSITIONS[index];
+  if (!position) {
+    throw new SemanticSelectionError(familyName, `produced invalid scale index ${index}`);
   }
-  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 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, dark) {
+    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 sign = dark ? -1 : 1;
+    const targetRank = STATE_RANK_STEP[use](baseRank, ladder, sign);
+    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 Math.max(0, Math.min(10, 10 - lightIndex));
+  return {
+    pair(request) {
+      const level = request.level ?? "AAA";
+      if (request.use === "foreground") return foregroundPair(request.from, level);
+      return statePair(request.use, request.from, request.dark);
+    },
+    states(from, dark) {
+      const out = {};
+      for (const use of STATE_USES) out[use] = statePair(use, from, dark);
+      return out;
+    },
+    invert
+  };
 }
 
 // ../color-utils/src/builder.ts
@@ -21262,9 +21419,7 @@ function buildColorValue(oklch2, options = {}) {
     (v) => v !== void 0
   );
   const harmony = generateHarmony(oklch2);
-  const accessibilityMeta = generateAccessibilityMetadata(scale2);
-  const contrastOnWhite = calculateWCAGContrast(oklch2, WHITE);
-  const contrastOnBlack = calculateWCAGContrast(oklch2, BLACK);
+  const wcagAccessibility = assembleWcagAccessibility(scale2, oklch2);
   const apcaOnWhite = calculateAPCAContrast(oklch2, WHITE);
   const apcaOnBlack = calculateAPCAContrast(oklch2, BLACK);
   const temperature = getColorTemperature(oklch2);
@@ -21293,22 +21448,7 @@ function buildColorValue(oklch2, options = {}) {
     },
     // Accessibility
     accessibility: {
-      wcagAA: accessibilityMeta.wcagAA,
-      wcagAAA: accessibilityMeta.wcagAAA,
-      onWhite: {
-        wcagAA: contrastOnWhite >= 4.5,
-        wcagAAA: contrastOnWhite >= 7,
-        contrastRatio: contrastOnWhite,
-        aa: accessibilityMeta.onWhite.aa,
-        aaa: accessibilityMeta.onWhite.aaa
-      },
-      onBlack: {
-        wcagAA: contrastOnBlack >= 4.5,
-        wcagAAA: contrastOnBlack >= 7,
-        contrastRatio: contrastOnBlack,
-        aa: accessibilityMeta.onBlack.aa,
-        aaa: accessibilityMeta.onBlack.aaa
-      },
+      ...wcagAccessibility,
       apca: {
         onWhite: apcaOnWhite,
         onBlack: apcaOnBlack,
@@ -21375,6 +21515,10 @@ var ComponentCategorySchema = external_exports.object({
   description: external_exports.string().optional()
 });
 
+// ../shared/src/fill-signature.ts
+var RESERVED_FILL_SEGMENTS = ["to", "via", "from"];
+var SEPARATOR = `-${RESERVED_FILL_SEGMENTS[0]}-`;
+
 // ../shared/src/types.ts
 var COMPUTED = Symbol.for(
   "rafters.computed"
@@ -21603,12 +21747,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
@@ -22250,10 +22404,8 @@ function groupTokens(tokens) {
     depth: [],
     motion: [],
     breakpoint: [],
-    elevation: [],
     focus: [],
     "typography-composite": [],
-    fill: [],
     other: []
   };
   for (const token of tokens) {
@@ -22285,18 +22437,12 @@ function groupTokens(tokens) {
       case "breakpoint":
         groups.breakpoint.push(token);
         break;
-      case "elevation":
-        groups.elevation.push(token);
-        break;
       case "focus":
         groups.focus.push(token);
         break;
       case "typography-composite":
         groups["typography-composite"].push(token);
         break;
-      case "fill":
-        groups.fill.push(token);
-        break;
       default:
         groups.other.push(token);
     }
@@ -22449,14 +22595,6 @@ function generateThemeBlock(groups) {
     }
     lines.push("");
   }
-  if (groups.elevation.length > 0) {
-    for (const token of groups.elevation) {
-      const value = tokenValueToCSS(token);
-      if (value === null) continue;
-      lines.push(`  --${token.name}: ${value};`);
-    }
-    lines.push("");
-  }
   if (groups.focus.length > 0) {
     for (const token of groups.focus) {
       const value = tokenValueToCSS(token);
@@ -22465,13 +22603,6 @@ function generateThemeBlock(groups) {
     }
     lines.push("");
   }
-  if (groups.fill.length > 0) {
-    for (const token of groups.fill) {
-      const value = typeof token.value === "string" ? token.value : JSON.stringify(token.value);
-      lines.push(`  --${token.name}: ${value};`);
-    }
-    lines.push("");
-  }
   if (groups.other.length > 0) {
     for (const token of groups.other) {
       const value = tokenValueToCSS(token);
@@ -22586,6 +22717,17 @@ function generateAnimationTokens(motionTokens) {
   }
   return lines.join("\n");
 }
+function generateDepthUtilities(depthTokens) {
+  if (depthTokens.length === 0) return "";
+  const lines = ["/* Depth (z-index) utilities -- words over numbers */"];
+  for (const token of depthTokens) {
+    if (typeof token.value !== "string" || !/^-?\d+$/.test(token.value)) continue;
+    lines.push(`@utility z-${token.name} {`);
+    lines.push(`  z-index: var(--${token.name});`);
+    lines.push("}");
+  }
+  return lines.join("\n");
+}
 function generateTypographyCompositeUtilities(compositeTokens) {
   if (compositeTokens.length === 0) {
     return "";
@@ -22703,6 +22845,11 @@ function tokensToTailwind(tokens, options = {}, typographyOverrides = []) {
     sections.push("");
     sections.push(typographyUtilities);
   }
+  const depthUtilities = generateDepthUtilities(groups.depth);
+  if (depthUtilities) {
+    sections.push("");
+    sections.push(depthUtilities);
+  }
   const overrideCSS = generateTypographyOverrideCSS(typographyOverrides);
   if (overrideCSS) {
     sections.push("");
@@ -22805,14 +22952,6 @@ function generateVarsRootBlock(groups) {
     }
     lines.push("");
   }
-  if (groups.elevation.length > 0) {
-    for (const token of groups.elevation) {
-      const value = tokenValueToCSS(token);
-      if (value === null) continue;
-      lines.push(`  --rafters-${token.name}: ${value};`);
-    }
-    lines.push("");
-  }
   if (groups.focus.length > 0) {
     for (const token of groups.focus) {
       const value = tokenValueToCSS(token);
@@ -22821,13 +22960,6 @@ function generateVarsRootBlock(groups) {
     }
     lines.push("");
   }
-  if (groups.fill.length > 0) {
-    for (const token of groups.fill) {
-      const value = typeof token.value === "string" ? token.value : JSON.stringify(token.value);
-      lines.push(`  --rafters-${token.name}: ${value};`);
-    }
-    lines.push("");
-  }
   if (groups.other.length > 0) {
     for (const token of groups.other) {
       const value = tokenValueToCSS(token);
@@ -23143,15 +23275,6 @@ var DEPTH_LEVELS = [
   "tooltip",
   "overlay"
 ];
-var ELEVATION_LEVELS = [
-  "surface",
-  "raised",
-  "overlay",
-  "sticky",
-  "modal",
-  "popover",
-  "tooltip"
-];
 var MOTION_DURATION_SCALE = ["instant", "fast", "normal", "slow", "slower"];
 var EASING_CURVES = [
   "linear",
@@ -23426,8 +23549,8 @@ function generateColorTokens(_config, colorScales) {
 }
 var WHITE2 = { l: 1, c: 0, h: 0, alpha: 1 };
 var BLACK2 = { l: 0, c: 0, h: 0, alpha: 1 };
-var WCAG_AA_NORMAL = 4.5;
-var WCAG_AAA_NORMAL = 7;
+var WCAG_AA_NORMAL2 = 4.5;
+var WCAG_AAA_NORMAL2 = 7;
 var FAMILY_REFERENCE_INDEX = 5;
 function buildColorAccessibility(scale2) {
   const meta = generateAccessibilityMetadata(scale2);
@@ -23441,15 +23564,15 @@ function buildColorAccessibility(scale2) {
     wcagAA: meta.wcagAA,
     wcagAAA: meta.wcagAAA,
     onWhite: {
-      wcagAA: onWhiteRatio >= WCAG_AA_NORMAL,
-      wcagAAA: onWhiteRatio >= WCAG_AAA_NORMAL,
+      wcagAA: onWhiteRatio >= WCAG_AA_NORMAL2,
+      wcagAAA: onWhiteRatio >= WCAG_AAA_NORMAL2,
       contrastRatio: onWhiteRatio,
       aa: meta.onWhite.aa,
       aaa: meta.onWhite.aaa
     },
     onBlack: {
-      wcagAA: onBlackRatio >= WCAG_AA_NORMAL,
-      wcagAAA: onBlackRatio >= WCAG_AAA_NORMAL,
+      wcagAA: onBlackRatio >= WCAG_AA_NORMAL2,
+      wcagAAA: onBlackRatio >= WCAG_AAA_NORMAL2,
       contrastRatio: onBlackRatio,
       aa: meta.onBlack.aa,
       aaa: meta.onBlack.aaa
@@ -23584,7 +23707,9 @@ var DEFAULT_DEPTH_DEFINITIONS = {
     stackingContext: false
   },
   dropdown: {
-    value: 10,
+    // The shadcn menu-content band (z-50): menu content must beat sticky
+    // chrome and survive opening inside a dialog; DOM order breaks ties.
+    value: 50,
     meaning: "Dropdown menus and select options",
     contexts: ["dropdowns", "select-menus", "autocomplete"],
     stackingContext: true
@@ -23626,7 +23751,9 @@ var DEFAULT_DEPTH_DEFINITIONS = {
     stackingContext: true
   },
   overlay: {
-    value: 70,
+    // Backdrops dim BEHIND the modal they serve: below modal (40), above
+    // fixed chrome (30) so the dim still covers sticky/fixed elements.
+    value: 35,
     meaning: "Overlay backdrops - screen-dimming layers behind modals",
     contexts: ["modal-backdrop", "drawer-backdrop", "sheet-backdrop"],
     stackingContext: true
@@ -23728,109 +23855,6 @@ var DEFAULT_SHADOW_DEFINITIONS = {
     contexts: ["critical-modals", "overlays", "drawer-panels"]
   }
 };
-var DEFAULT_FILL_DEFINITIONS = {
-  surface: {
-    color: "neutral-900",
-    foreground: "neutral-100",
-    meaning: "Primary content surface",
-    contexts: ["surface"]
-  },
-  panel: {
-    color: "neutral-800",
-    opacity: 0.95,
-    foreground: "neutral-100",
-    meaning: "Elevated panel",
-    contexts: ["surface"]
-  },
-  overlay: {
-    color: "neutral-950",
-    opacity: 0.8,
-    backdropBlur: "sm",
-    foreground: "neutral-50",
-    meaning: "Modal backdrop",
-    contexts: ["surface"]
-  },
-  glass: {
-    color: "neutral-900",
-    opacity: 0.6,
-    backdropBlur: "md",
-    foreground: "neutral-100",
-    meaning: "Glass morphism",
-    contexts: ["surface"]
-  },
-  primary: {
-    color: "primary",
-    foreground: "primary-foreground",
-    meaning: "Primary brand surface",
-    contexts: ["surface", "text"]
-  },
-  muted: {
-    color: "muted",
-    foreground: "muted-foreground",
-    meaning: "Subdued surface for secondary content",
-    contexts: ["surface"]
-  },
-  hero: {
-    gradient: {
-      direction: "to-b",
-      stops: [{ color: "primary" }, { color: "primary", opacity: 0 }]
-    },
-    foreground: "primary-foreground",
-    meaning: "Hero fade gradient",
-    contexts: ["surface", "text"]
-  }
-};
-var DEFAULT_ELEVATION_DEFINITIONS = {
-  surface: {
-    depth: "depth-base",
-    shadow: "shadow-none",
-    meaning: "Surface level - flat, in-flow elements",
-    contexts: ["page-content", "inline-elements", "flat-cards"],
-    useCase: "Default level for content that doesn't need elevation"
-  },
-  raised: {
-    depth: "depth-base",
-    shadow: "shadow-sm",
-    meaning: "Slightly raised - subtle depth without z-index change",
-    contexts: ["cards", "panels", "list-items"],
-    useCase: "Cards and containers that need subtle visual separation"
-  },
-  overlay: {
-    depth: "depth-dropdown",
-    shadow: "shadow",
-    meaning: "Overlay level - dropdowns and menus",
-    contexts: ["dropdowns", "select-menus", "autocomplete", "context-menus"],
-    useCase: "Elements that appear over content but aren't blocking"
-  },
-  sticky: {
-    depth: "depth-sticky",
-    shadow: "shadow-md",
-    meaning: "Sticky level - persistent navigation",
-    contexts: ["sticky-header", "sticky-sidebar", "floating-nav"],
-    useCase: "Elements that stick to viewport edges during scroll"
-  },
-  modal: {
-    depth: "depth-modal",
-    shadow: "shadow-lg",
-    meaning: "Modal level - blocking dialogs",
-    contexts: ["modals", "dialogs", "sheets", "drawers"],
-    useCase: "Elements that block interaction with content below"
-  },
-  popover: {
-    depth: "depth-popover",
-    shadow: "shadow-xl",
-    meaning: "Popover level - above modals",
-    contexts: ["popovers", "nested-dialogs", "command-palette"],
-    useCase: "Elements that can appear above modals (rare)"
-  },
-  tooltip: {
-    depth: "depth-tooltip",
-    shadow: "shadow-lg",
-    meaning: "Tooltip level - highest common UI",
-    contexts: ["tooltips", "toast-notifications", "snackbars"],
-    useCase: "Transient information that appears above everything"
-  }
-};
 var DEFAULT_DURATION_DEFINITIONS = {
   instant: {
     step: "instant",
@@ -24308,7 +24332,7 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   // Card surfaces
   card: {
     light: { family: "neutral", position: "50" },
-    dark: { family: "neutral", position: "950" },
+    dark: { family: "neutral", position: "700" },
     meaning: "Card and contained surface background",
     contexts: ["cards", "modals", "dialogs", "panels"],
     do: ["Use for elevated surfaces"],
@@ -24324,7 +24348,7 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   },
   "card-hover": {
     light: { family: "neutral", position: "100" },
-    dark: { family: "neutral", position: "900" },
+    dark: { family: "neutral", position: "600" },
     meaning: "Card hover state background",
     contexts: ["card-hover"],
     do: ["Use for card hover states"],
@@ -24332,16 +24356,48 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   },
   "card-border": {
     light: { family: "neutral", position: "200" },
-    dark: { family: "neutral", position: "800" },
+    dark: { family: "neutral", position: "500" },
     meaning: "Card border color",
     contexts: ["card-borders"],
     do: ["Use for card borders"],
     never: ["Use for dividers within cards"]
   },
+  panel: {
+    light: { family: "neutral", position: "100" },
+    dark: { family: "neutral", position: "800" },
+    meaning: "Elevated panel surface -- one level above the page",
+    contexts: ["panels", "toolbars", "headers", "docks"],
+    do: ["Use for persistent elevated chrome", "Pair with panel-foreground"],
+    never: ["Use for page-level backgrounds", "Stack directly on card without a border"]
+  },
+  "panel-foreground": {
+    light: { family: "neutral", position: "950" },
+    dark: { family: "neutral", position: "50" },
+    meaning: "Text and icons on panel surfaces",
+    contexts: ["panel-text"],
+    do: ["Use on panel backgrounds"],
+    never: ["Use on page background"]
+  },
+  "panel-hover": {
+    light: { family: "neutral", position: "200" },
+    dark: { family: "neutral", position: "700" },
+    meaning: "Panel surface hover state",
+    contexts: ["panel-interaction"],
+    do: ["Use for hoverable panel regions"],
+    never: ["Use as a resting surface"]
+  },
+  "panel-border": {
+    light: { family: "neutral", position: "200" },
+    dark: { family: "neutral", position: "600" },
+    meaning: "Borders separating panel from surrounding surfaces",
+    contexts: ["panel-edges"],
+    do: ["Use to delimit panels"],
+    never: ["Use as text color"]
+  },
   // Popover surfaces
   popover: {
     light: { family: "neutral", position: "50" },
-    dark: { family: "neutral", position: "950" },
+    dark: { family: "neutral", position: "700" },
     meaning: "Popover and dropdown background",
     contexts: ["dropdowns", "tooltips", "menus"],
     do: ["Use for floating elements"],
@@ -25456,7 +25512,7 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   // ============================================================================
   sidebar: {
     light: { family: "neutral", position: "50" },
-    dark: { family: "neutral", position: "950" },
+    dark: { family: "neutral", position: "900" },
     meaning: "Sidebar background",
     contexts: ["navigation-sidebar", "side-panels"],
     do: ["Use for sidebar backgrounds"],
@@ -25544,7 +25600,7 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   },
   "sidebar-item": {
     light: { family: "neutral", position: "50" },
-    dark: { family: "neutral", position: "950" },
+    dark: { family: "neutral", position: "900" },
     meaning: "Sidebar item background",
     contexts: ["sidebar-items"],
     do: ["Use for sidebar item backgrounds"],
@@ -25627,7 +25683,7 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   // ============================================================================
   nav: {
     light: { family: "neutral", position: "50" },
-    dark: { family: "neutral", position: "950" },
+    dark: { family: "neutral", position: "900" },
     meaning: "Navigation background",
     contexts: ["navbars", "breadcrumbs", "tabs"],
     do: ["Use for navigation backgrounds"],
@@ -25726,7 +25782,7 @@ var DEFAULT_SEMANTIC_COLOR_MAPPINGS = {
   },
   "table-header": {
     light: { family: "neutral", position: "100" },
-    dark: { family: "neutral", position: "900" },
+    dark: { family: "neutral", position: "800" },
     meaning: "Table header background",
     contexts: ["table-headers"],
     do: ["Use for table header backgrounds"],
@@ -26061,187 +26117,6 @@ function generateDepthTokens(_config, depthDefs) {
   };
 }
 
-// ../design-tokens/src/generators/elevation.ts
-function generateElevationTokens(_config, elevationDefs) {
-  const tokens = [];
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  for (const level of ELEVATION_LEVELS) {
-    const def = elevationDefs[level];
-    if (!def) continue;
-    const scaleIndex = ELEVATION_LEVELS.indexOf(level);
-    tokens.push({
-      name: `elevation-${level}`,
-      value: JSON.stringify({
-        depth: `var(--${def.depth})`,
-        shadow: `var(--${def.shadow})`
-      }),
-      category: "elevation",
-      namespace: "elevation",
-      semanticMeaning: def.meaning,
-      usageContext: def.contexts,
-      scalePosition: scaleIndex,
-      elevationLevel: level,
-      shadowToken: def.shadow,
-      dependsOn: [def.depth, def.shadow],
-      description: `${def.useCase}. Combines ${def.depth} with ${def.shadow}.`,
-      generatedAt: timestamp,
-      containerQueryAware: false,
-      userOverride: null,
-      usagePatterns: {
-        do: [
-          `Use for ${def.contexts.slice(0, 2).join(", ")}`,
-          "Apply both z-index and shadow together"
-        ],
-        never: [
-          "Mix elevation levels within same component",
-          "Use without considering stacking context"
-        ]
-      }
-    });
-    tokens.push({
-      name: `elevation-${level}-z`,
-      value: `var(--${def.depth})`,
-      category: "elevation",
-      namespace: "elevation",
-      semanticMeaning: `Z-index component of ${level} elevation`,
-      dependsOn: [def.depth],
-      description: `Z-index for ${level} elevation level.`,
-      generatedAt: timestamp,
-      containerQueryAware: false,
-      userOverride: null
-    });
-    tokens.push({
-      name: `elevation-${level}-shadow`,
-      value: `var(--${def.shadow})`,
-      category: "elevation",
-      namespace: "elevation",
-      semanticMeaning: `Shadow component of ${level} elevation`,
-      dependsOn: [def.shadow],
-      description: `Shadow for ${level} elevation level.`,
-      generatedAt: timestamp,
-      containerQueryAware: false,
-      userOverride: null
-    });
-  }
-  tokens.push({
-    name: "elevation-scale",
-    value: JSON.stringify({
-      levels: Object.fromEntries(
-        Object.entries(elevationDefs).map(([k, v]) => [k, { depth: v.depth, shadow: v.shadow }])
-      ),
-      note: "Each elevation level pairs z-index with appropriate shadow"
-    }),
-    category: "elevation",
-    namespace: "elevation",
-    semanticMeaning: "Elevation scale reference",
-    description: "Complete elevation scale showing depth/shadow pairings.",
-    generatedAt: timestamp,
-    containerQueryAware: false,
-    userOverride: null
-  });
-  return {
-    namespace: "elevation",
-    tokens
-  };
-}
-
-// ../design-tokens/src/generators/fill.ts
-function validateFillDef(name, def) {
-  if (!def.color && !def.gradient) {
-    return `Fill "${name}" must have either a color or gradient field`;
-  }
-  if (def.gradient) {
-    if (!def.gradient.stops || def.gradient.stops.length < 2) {
-      return `Fill "${name}" gradient must have at least 2 stops`;
-    }
-  }
-  if (def.opacity !== void 0 && (def.opacity < 0 || def.opacity > 1)) {
-    return `Fill "${name}" opacity must be between 0 and 1`;
-  }
-  const validBlurSizes = ["sm", "md", "lg", "xl", "2xl", "3xl"];
-  if (def.backdropBlur && !validBlurSizes.includes(def.backdropBlur)) {
-    return `Fill "${name}" backdropBlur must be one of: ${validBlurSizes.join(", ")}`;
-  }
-  return null;
-}
-function serializeFillValue(def) {
-  const parts = {};
-  if (def.color) parts.color = def.color;
-  if (def.opacity !== void 0) parts.opacity = def.opacity;
-  if (def.foreground) parts.foreground = def.foreground;
-  if (def.backdropBlur) parts.backdropBlur = def.backdropBlur;
-  if (def.gradient) parts.gradient = def.gradient;
-  return JSON.stringify(parts);
-}
-function generateFillTokens(_config, fillDefinitions) {
-  const tokens = [];
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const fillNames = Object.keys(fillDefinitions);
-  for (const [name, def] of Object.entries(fillDefinitions)) {
-    const error47 = validateFillDef(name, def);
-    if (error47) {
-      throw new Error(error47);
-    }
-    const dependsOn = [];
-    if (def.color) {
-      dependsOn.push(def.color);
-    }
-    if (def.foreground) {
-      dependsOn.push(def.foreground);
-    }
-    if (def.gradient) {
-      for (const stop of def.gradient.stops) {
-        dependsOn.push(stop.color);
-      }
-    }
-    tokens.push({
-      name: `fill-${name}`,
-      value: serializeFillValue(def),
-      category: "fill",
-      namespace: "fill",
-      semanticMeaning: def.meaning,
-      usageContext: def.contexts,
-      dependsOn: dependsOn.length > 0 ? dependsOn : void 0,
-      description: buildDescription(name, def),
-      generatedAt: timestamp,
-      containerQueryAware: true,
-      scalePosition: fillNames.indexOf(name),
-      userOverride: null,
-      usagePatterns: {
-        do: [
-          `Use fill="${name}" on surface components (Container, Card) for ${def.meaning.toLowerCase()}`,
-          ...def.gradient ? [`Use color="${name}" on Typography for gradient text effect`] : []
-        ],
-        never: [
-          "Do not use raw bg-* classes when a fill token exists for the purpose",
-          "Do not hardcode opacity values -- use the fill token instead"
-        ]
-      }
-    });
-  }
-  return {
-    namespace: "fill",
-    tokens
-  };
-}
-function buildDescription(name, def) {
-  const parts = [`Fill token "${name}"`];
-  if (def.color && def.opacity !== void 0 && def.opacity < 1) {
-    parts.push(`-- ${def.color} at ${Math.round(def.opacity * 100)}% opacity`);
-  } else if (def.color) {
-    parts.push(`-- solid ${def.color}`);
-  }
-  if (def.backdropBlur) {
-    parts.push(`with backdrop-blur-${def.backdropBlur}`);
-  }
-  if (def.gradient) {
-    const stops = def.gradient.stops.map((s) => s.color).join(" to ");
-    parts.push(`-- gradient ${def.gradient.direction}: ${stops}`);
-  }
-  parts.push(`(${def.meaning})`);
-  return parts.join(" ");
-}
-
 // ../design-tokens/src/generators/focus.ts
 function pxToRem(px) {
   const rem = Math.round(px / 16 * 1e3) / 1e3;
@@ -27297,19 +27172,6 @@ function generateRadiusTokens(config2, radiusDefs) {
 }
 
 // ../design-tokens/src/generators/semantic.ts
-var POSITION_TO_INDEX2 = {
-  "50": 0,
-  "100": 1,
-  "200": 2,
-  "300": 3,
-  "400": 4,
-  "500": 5,
-  "600": 6,
-  "700": 7,
-  "800": 8,
-  "900": 9,
-  "950": 10
-};
 var FOREGROUND_SUFFIXES = ["-foreground", "-text", "-contrast"];
 var STATE_SUFFIXES = ["-hover", "-active", "-focus", "-disabled"];
 function toColorRef(mapping) {
@@ -27339,7 +27201,7 @@ function deriveDerivation(name, lightRef, knownTokens) {
       }
     }
   }
-  const scalePosition = POSITION_TO_INDEX2[lightRef.position];
+  const scalePosition = POSITION_TO_INDEX[lightRef.position];
   if (scalePosition === void 0) {
     throw new Error(
       `semantic generator: token "${name}" has unknown scale position "${lightRef.position}"`
@@ -27376,13 +27238,20 @@ function derivationParent(derivation, suffix = "") {
       return `${derivation.against}${suffix}`;
   }
 }
-function deriveDarkBinding(derivation) {
+function deriveDarkBinding(derivation, parentName, darkRef) {
   switch (derivation.kind) {
-    case "scale":
+    case "scale": {
+      const scalePosition = POSITION_TO_INDEX[darkRef.position];
+      if (scalePosition === void 0) {
+        throw new Error(
+          `semantic generator: invalid designed dark position "${darkRef.position}" for ${parentName}`
+        );
+      }
       return {
-        plugin: "invert",
-        input: { familyName: derivation.family, basePosition: derivation.scalePosition }
+        plugin: "scale",
+        input: { familyName: darkRef.family, scalePosition }
       };
+    }
     case "state":
       return {
         plugin: "state",
@@ -27406,7 +27275,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, darkRef);
     const darkParent = derivationParent(derivation, "--dark");
     const dependsOn = [parent, darkName];
     tokens.push({
@@ -28094,14 +27963,6 @@ function createGeneratorDefs(colorPaletteBases) {
         DEFAULT_DELAY_DEFINITIONS
       )
     },
-    {
-      name: "fill",
-      generate: (_config) => generateFillTokens(_config, DEFAULT_FILL_DEFINITIONS)
-    },
-    {
-      name: "elevation",
-      generate: (config2) => generateElevationTokens(config2, DEFAULT_ELEVATION_DEFINITIONS)
-    },
     {
       name: "focus",
       generate: (config2) => generateFocusTokens(config2, DEFAULT_FOCUS_CONFIGS)
@@ -28202,15 +28063,15 @@ var TokenGraph = class {
       ...extras?.binding ? { binding: extras.binding } : {}
     });
   }
-  bind(name, pluginName, input2) {
+  bind(name, pluginName, input) {
     const plugin = this.requirePlugin(pluginName);
-    plugin.inputSchema.parse(input2);
-    const directDeps = plugin.dependsOn(input2);
+    plugin.inputSchema.parse(input);
+    const directDeps = plugin.dependsOn(input);
     this.assertNoCycle(name, directDeps);
     this.takeSnapshot();
-    const value = plugin.transform(input2, (n2) => this.get(n2));
+    const value = plugin.transform(input, (n2) => this.get(n2));
     plugin.outputSchema.parse(value);
-    this.nodes.set(name, { name, value, binding: { plugin: pluginName, input: input2 } });
+    this.nodes.set(name, { name, value, binding: { plugin: pluginName, input } });
     this.cascadeFrom(name);
   }
   get(name) {
@@ -28755,11 +28616,11 @@ var TokenRegistry = class {
     }
     this.graph.set(name, value, options);
   }
-  bind(name, pluginName, input2) {
+  bind(name, pluginName, input) {
     if (!this.metadata.has(name)) {
       throw new UnknownTokenError(name);
     }
-    this.graph.bind(name, pluginName, input2);
+    this.graph.bind(name, pluginName, input);
   }
   get(name) {
     const node = this.graph.node(name);
@@ -28883,22 +28744,38 @@ 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 {
     name: spec.name,
     inputSchema: spec.inputSchema,
     outputSchema: spec.outputSchema,
-    dependsOn: (input2) => spec.dependsOn(input2),
-    transform: (input2, get3) => spec.transform(input2, get3)
+    dependsOn: (input) => spec.dependsOn(input),
+    transform: (input, get3) => spec.transform(input, get3)
   };
 }
 
@@ -28911,11 +28788,11 @@ var calcPlugin = definePlugin({
   name: "calc",
   inputSchema: CalcInputSchema,
   outputSchema: external_exports.string(),
-  dependsOn: (input2) => input2.tokens,
-  transform: (input2, get3) => {
-    let expression = input2.expression;
+  dependsOn: (input) => input.tokens,
+  transform: (input, get3) => {
+    let expression = input.expression;
     let detectedUnit = "";
-    for (const tokenName of input2.tokens) {
+    for (const tokenName of input.tokens) {
       const tokenValue = get3(tokenName);
       if (typeof tokenValue !== "string") {
         throw new Error(`calc plugin: token "${tokenName}" value is not a string`);
@@ -28944,132 +28821,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})`
-    );
+  dependsOn: (input) => [input.against],
+  transform: (input, get3) => {
+    const { sem, resolved } = requireSemanticParent(input.against, get3, "contrast");
+    const pair = sem.pair({ use: "foreground", from: resolved.ref.position, level: input.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],
-  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 };
+  dependsOn: (input) => [input.fromToken],
+  transform: (input, get3) => {
+    const { sem, resolved } = requireSemanticParent(input.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 };
   }
 });
 
@@ -29082,17 +28859,17 @@ var scalePlugin = definePlugin({
   name: "scale",
   inputSchema: ScaleInputSchema,
   outputSchema: ColorReferenceSchema,
-  dependsOn: (input2) => [input2.familyName],
-  transform: (input2, get3) => {
-    const result = resolveFamily(input2.familyName, get3);
+  dependsOn: (input) => [input.familyName],
+  transform: (input, get3) => {
+    const result = resolveFamily(input.familyName, get3);
     if (!result) {
-      throw new Error(`scale plugin: family "${input2.familyName}" not found in registry`);
+      throw new Error(`scale plugin: family "${input.familyName}" not found in registry`);
     }
-    const position = SCALE_POSITIONS[input2.scalePosition];
+    const position = SCALE_POSITIONS[input.scalePosition];
     if (position === void 0) {
-      throw new Error(`scale plugin: invalid position index ${input2.scalePosition}`);
+      throw new Error(`scale plugin: invalid position index ${input.scalePosition}`);
     }
-    return { family: result.resolvedName, position };
+    return { family: result.familyName, position };
   }
 });
 
@@ -29102,115 +28879,16 @@ 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 };
+  dependsOn: (input) => [input.from],
+  transform: (input, get3) => {
+    const dark = input.from.includes("--dark");
+    const { sem, resolved } = requireSemanticParent(input.from, get3, "state");
+    const pair = sem.pair({ use: input.stateType, from: resolved.ref.position, dark });
+    return { family: pair.to.family, position: pair.to.position };
   }
 });
 
@@ -29221,12 +28899,86 @@ async function backupCss(cssPath) {
   await copyFile(cssPath, backupPath);
   return backupPath;
 }
+function cleanSourceCssBlocks(content) {
+  function parseBlocks(src) {
+    const blocks = [];
+    let depth = 0;
+    const headerStack = [];
+    let segmentStart = 0;
+    for (let i = 0; i < src.length; i++) {
+      const ch = src.charAt(i);
+      if (ch === "{") {
+        headerStack.push(segmentStart);
+        depth++;
+        if (depth >= 1) {
+          blocks.push({
+            headerStart: segmentStart,
+            bodyStart: i + 1,
+            end: -1,
+            header: src.slice(segmentStart, i).trim()
+          });
+        }
+        segmentStart = i + 1;
+      } else if (ch === "}") {
+        depth--;
+        const open = blocks.slice().reverse().find((b2) => b2.end === -1);
+        if (open) open.end = i + 1;
+        headerStack.pop();
+        segmentStart = i + 1;
+      } else if (ch === ";") {
+        segmentStart = i + 1;
+      }
+    }
+    return blocks.filter((b2) => b2.end !== -1);
+  }
+  function isContentEmpty(body) {
+    return body.replace(/\/\*[\s\S]*?\*\//g, "").trim().length === 0;
+  }
+  let out = content;
+  for (let pass = 0; pass < 10; pass++) {
+    const blocks = parseBlocks(out);
+    let edited = false;
+    for (const block of blocks.sort((a2, b2) => b2.headerStart - a2.headerStart)) {
+      const header = block.header;
+      if (/^@theme\s+inline$/.test(header)) {
+        out = out.slice(0, block.headerStart) + out.slice(block.end);
+        edited = true;
+        break;
+      }
+      if (header === ":root" || /(^|,)\s*:root\s*$/.test(header)) {
+        const body = out.slice(block.bodyStart, block.end - 1);
+        const cleanedBody = body.replace(/--[\w-]+\s*:[^;{}]*;?/g, "");
+        if (isContentEmpty(cleanedBody)) {
+          out = out.slice(0, block.headerStart) + out.slice(block.end);
+          edited = true;
+          break;
+        }
+        if (cleanedBody !== body) {
+          out = out.slice(0, block.bodyStart) + cleanedBody + out.slice(block.end - 1);
+          edited = true;
+          break;
+        }
+        continue;
+      }
+      if (header.startsWith("@media") || header.startsWith("@supports")) {
+        const body = out.slice(block.bodyStart, block.end - 1);
+        if (isContentEmpty(body)) {
+          out = out.slice(0, block.headerStart) + out.slice(block.end);
+          edited = true;
+          break;
+        }
+      }
+    }
+    if (!edited) break;
+  }
+  return out.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n");
+}
 async function stripImportedDeclarations(cwd, cssPath, importedNames) {
   if (importedNames.length === 0) return;
   const fullPath = join7(cwd, cssPath);
   const content = await readFile4(fullPath, "utf-8");
   const pattern = new RegExp(importedNames.map((n2) => `^\\s*--${n2}[^;]*;\\s*$`).join("|"), "gm");
-  const cleaned = content.replace(pattern, "");
+  const cleaned = cleanSourceCssBlocks(content.replace(pattern, ""));
   const collapsed = cleaned.replace(/\n{3,}/g, "\n\n");
   await writeFile2(fullPath, collapsed);
 }
@@ -29408,6 +29160,8 @@ async function regenerateFromExisting(cwd, paths, shadcn, isAgentMode2, framewor
     existingConfig.compositesPath = frameworkPaths.composites;
     existingConfig.rulesPath = frameworkPaths.rules;
   }
+  await rm(join7(paths.tokens, "elevation.rafters.json"), { force: true });
+  await rm(join7(paths.tokens, "fill.rafters.json"), { force: true });
   const registry2 = loadRegistryFromDir(paths.tokens, REGISTRY_PLUGINS);
   if (registry2.size() === 0) {
     throw new Error("No tokens found. Cannot regenerate without existing tokens.");
@@ -30728,97 +30482,9 @@ async function mcp(options) {
   await startMcpServer(workspaces, defaultWorkspace);
 }
 
-// src/commands/set.ts
+// src/commands/studio.ts
 import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve5 } from "path";
-import { input } from "@inquirer/prompts";
-var TokenValueSchema = external_exports.union([external_exports.string(), ColorValueSchema, ColorReferenceSchema]);
-async function set3(name, value, options) {
-  setAgentMode(options.agent ?? false);
-  const dir = resolve5(options.raftersDir ?? ".rafters/tokens");
-  if (!existsSync7(dir)) {
-    throw new Error(`tokens directory not found: ${dir}`);
-  }
-  let reason = options.reason;
-  if (!reason) {
-    if (isAgentMode()) {
-      throw new Error("rafters set requires --reason in agent mode");
-    }
-    reason = await input({
-      message: "Reason for this change (recorded with userOverride):",
-      validate: (v) => v.trim().length > 0 ? true : "A reason is required"
-    });
-  }
-  const parsedValue = bakeAccessibility(parseValue(value));
-  const registry2 = loadRegistryFromDir(dir, [
-    scalePlugin,
-    contrastPlugin,
-    invertPlugin,
-    statePlugin
-  ]);
-  if (!registry2.has(name)) {
-    throw new Error(`token "${name}" not found in ${dir}`);
-  }
-  const previous = registry2.get(name)?.value;
-  registry2.set(name, parsedValue, { reason });
-  saveRegistryToDir(dir, registry2);
-  log({
-    event: "token.set",
-    name,
-    previous,
-    next: parsedValue,
-    reason
-  });
-}
-var WHITE3 = { l: 1, c: 0, h: 0, alpha: 1 };
-var BLACK3 = { l: 0, c: 0, h: 0, alpha: 1 };
-var WCAG_AA_NORMAL2 = 4.5;
-var WCAG_AAA_NORMAL2 = 7;
-function bakeAccessibility(value) {
-  if (typeof value !== "object" || value === null) return value;
-  if (!("scale" in value) || !Array.isArray(value.scale)) return value;
-  const colorValue = value;
-  const meta = generateAccessibilityMetadata(colorValue.scale);
-  const reference = colorValue.scale[5] ?? colorValue.scale[0];
-  if (!reference) return value;
-  const onWhiteRatio = calculateWCAGContrast(reference, WHITE3);
-  const onBlackRatio = calculateWCAGContrast(reference, BLACK3);
-  const accessibility = {
-    wcagAA: meta.wcagAA,
-    wcagAAA: meta.wcagAAA,
-    onWhite: {
-      wcagAA: onWhiteRatio >= WCAG_AA_NORMAL2,
-      wcagAAA: onWhiteRatio >= WCAG_AAA_NORMAL2,
-      contrastRatio: onWhiteRatio,
-      aa: meta.onWhite.aa,
-      aaa: meta.onWhite.aaa
-    },
-    onBlack: {
-      wcagAA: onBlackRatio >= WCAG_AA_NORMAL2,
-      wcagAAA: onBlackRatio >= WCAG_AAA_NORMAL2,
-      contrastRatio: onBlackRatio,
-      aa: meta.onBlack.aa,
-      aaa: meta.onBlack.aaa
-    }
-  };
-  return { ...colorValue, accessibility };
-}
-function parseValue(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      const result = TokenValueSchema.safeParse(parsed);
-      if (result.success) return result.data;
-    } catch {
-    }
-  }
-  return raw;
-}
-
-// src/commands/studio.ts
-import { existsSync as existsSync8 } from "fs";
-import { resolve as resolve6 } from "path";
 
 // ../studio/src/api/vite-plugin.ts
 import { writeFile as writeFile3 } from "fs/promises";
@@ -30968,7 +30634,7 @@ function getNamespacePatchSchema(namespace) {
 }
 var MAX_BODY_SIZE = 1024 * 1024;
 function readJsonBody(req) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     let body = "";
     let size = 0;
     req.on("data", (chunk) => {
@@ -30981,7 +30647,7 @@ function readJsonBody(req) {
     });
     req.on("end", () => {
       try {
-        resolve7(body ? JSON.parse(body) : {});
+        resolve6(body ? JSON.parse(body) : {});
       } catch {
         reject(new Error("Invalid JSON body"));
       }
@@ -31108,6 +30774,9 @@ async function handlePostToken(req, res, name, registry2) {
     ...existingToken,
     ...patchResult.data
   };
+  if (mergedToken.value && typeof mergedToken.value === "object" && "scale" in mergedToken.value) {
+    mergedToken.value = rebakeAccessibility(mergedToken.value);
+  }
   const tokenResult = TokenSchema.safeParse(mergedToken);
   if (!tokenResult.success) {
     res.statusCode = 400;
@@ -31446,7 +31115,7 @@ import { createServer } from "vite";
 async function studio() {
   const cwd = process.cwd();
   const paths = getRaftersPaths(cwd);
-  if (!existsSync8(paths.root)) {
+  if (!existsSync7(paths.root)) {
     console.error('No .rafters/ directory found. Run "rafters init" first.');
     process.exit(1);
   }
@@ -31463,7 +31132,7 @@ async function studio() {
     },
     resolve: {
       alias: {
-        "@rafters-output": resolve6(cwd, ".rafters", "output")
+        "@rafters-output": resolve5(cwd, ".rafters", "output")
       }
     }
   });
@@ -31480,10 +31149,6 @@ program.command("init").description("Initialize .rafters/ with default tokens an
 ).option("--agent", "Output JSON for machine consumption").action(withErrorHandler(init));
 program.command("add").description("Add rafters components to the project").argument("[components...]", "Component names to add").option("--list", "List available components").option("--overwrite", "Overwrite existing component files").option("--update", "Re-fetch named components from registry").option("--update-all", "Re-fetch all installed components from registry").option("--registry-url <url>", "Custom registry URL").option("--agent", "Output JSON for machine consumption").action(withErrorHandler(add));
 program.command("mcp").description("Start MCP server for AI agent access (stdio)").option("--project-root <path>", "Explicit project root (skips .rafters/ discovery)").action(mcp);
-program.command("set").description("Set a token value. Records userOverride and cascades to dependents.").argument("<name>", "Token name").argument("<value>", "New value (string, or JSON for ColorValue/ColorReference)").option(
-  "--reason <text>",
-  "Reason for the change (recorded with userOverride; prompted if missing in non-agent mode)"
-).option("--rafters-dir <path>", "Directory of .rafters.json files", ".rafters/tokens").option("--agent", "Output JSON for machine consumption").action(withErrorHandler(set3));
 program.command("studio").description("Open Studio UI for visual token editing").action(studio);
 program.parse();
 /*! Bundled license information: