rafters 0.0.77 → 0.0.79

package/dist/index.js

@@ -311,6 +311,32 @@ function toDTCG(tokens, options = {}) {
 
 // ../design-tokens/src/exporters/tailwind.ts
 var SHADOW_PART_SUFFIX = /-(offset-x|offset-y|blur|spread|color)$/;
+var MOTION_NAMESPACE_PROPERTY = {
+  duration: "transition-duration",
+  ease: "transition-timing-function",
+  delay: "transition-delay",
+  // Extents are consumed inside transforms, so the utility publishes the chosen
+  // extent under a fixed name the consuming rule reads. The name comes from toy
+  // 9 (worktree-toy-motion-registry).
+  //
+  // THIS IS THE UTILITY-SIDE CONTRACT, and it is one of TWO (#2017). A CLASS
+  // picks an extent by naming a member (`extent-pop`) and the rule downstream
+  // reads `--rafters-consumed-extent` without knowing which member won.
+  // KEYFRAME BODIES DO NOT USE THIS ALIAS: they are generator-owned emission and
+  // reference the LEAF directly (`var(--rafters-extent-pop)`, see
+  // DEFAULT_KEYFRAME_DEFINITIONS). A shape is not a function of whatever extent
+  // the consuming class last selected. Do not merge the two contracts.
+  extent: "--rafters-consumed-extent",
+  period: "animation-duration"
+};
+var MOTION_NAMESPACE_NAMES = Object.keys(MOTION_NAMESPACE_PROPERTY);
+var REDUCED_MOTION_ZEROED = /* @__PURE__ */ new Set(["duration", "delay"]);
+var MOTION_NAMESPACE_TOKEN = new RegExp(`^rafters-(${MOTION_NAMESPACE_NAMES.join("|")})-(.+)$`);
+function motionNamespaceParts(name) {
+  const match = MOTION_NAMESPACE_TOKEN.exec(name);
+  if (!match?.[1] || !match[2]) return null;
+  return { namespace: match[1], member: match[2] };
+}
 function isShadowDecomposedPart(name) {
   return SHADOW_PART_SUFFIX.test(name);
 }
@@ -507,7 +533,7 @@ function generateThemeBlock(groups) {
       const value = tokenValueToCSS(token);
       if (value === null) continue;
       const key = token.name.replace(/^radius-/, "");
-      const themeValue = value.replaceAll("var(--rafters-radius-base)", "var(--radius-base)").replaceAll("var(--rafters-radius-tl)", "var(--radius-tl)").replaceAll("var(--rafters-radius-tr)", "var(--radius-tr)").replaceAll("var(--rafters-radius-bl)", "var(--radius-bl)").replaceAll("var(--rafters-radius-br)", "var(--radius-br)");
+      const themeValue = value.replaceAll("var(--rafters-spacing-base)", "var(--spacing-base)").replaceAll("var(--rafters-radius-base)", "var(--radius-base)").replaceAll("var(--rafters-radius-tl)", "var(--radius-tl)").replaceAll("var(--rafters-radius-tr)", "var(--radius-tr)").replaceAll("var(--rafters-radius-bl)", "var(--radius-bl)").replaceAll("var(--rafters-radius-br)", "var(--radius-br)");
       lines.push(`  --radius-${key}: ${themeValue};`);
     }
     lines.push("");
@@ -533,32 +559,26 @@ function generateThemeBlock(groups) {
     }
     lines.push("");
   }
+  const motionNamespaceLines = generateMotionNamespaceVars(groups.motion);
+  if (motionNamespaceLines) {
+    lines.push(motionNamespaceLines);
+    lines.push("");
+  }
   if (groups.motion.length > 0) {
     for (const token of groups.motion) {
       if (token.name.startsWith("motion-duration-") && token.name !== "motion-duration-base")
         continue;
       if (token.name.startsWith("motion-easing-")) continue;
+      if (motionNamespaceParts(token.name)) continue;
       const value = tokenValueToCSS(token);
       if (value === null) continue;
       lines.push(`  --${token.name}: ${value};`);
     }
     lines.push("");
   }
-  if (groups.motion.length > 0) {
-    for (const token of groups.motion) {
-      if (token.name.startsWith("motion-duration-") && token.name !== "motion-duration-base") {
-        const key = token.name.replace("motion-duration-", "");
-        const value = tokenValueToCSS(token);
-        if (value === null) continue;
-        lines.push(`  --duration-${key}: ${value};`);
-      }
-      if (token.name.startsWith("motion-easing-")) {
-        const key = token.name.replace("motion-easing-", "");
-        const value = tokenValueToCSS(token);
-        if (value === null) continue;
-        lines.push(`  --ease-${key}: ${value};`);
-      }
-    }
+  const bridgeLines = generateMotionBridgeVars(groups.motion);
+  if (bridgeLines) {
+    lines.push(bridgeLines);
     lines.push("");
   }
   if (groups.breakpoint.length > 0) {
@@ -574,7 +594,8 @@ function generateThemeBlock(groups) {
     for (const token of groups.focus) {
       const value = tokenValueToCSS(token);
       if (value === null) continue;
-      lines.push(`  --${token.name}: ${value};`);
+      const themeValue = value.replaceAll("var(--rafters-spacing-base)", "var(--spacing-base)").replaceAll("var(--rafters-focus-ring-width)", "var(--focus-ring-width)");
+      lines.push(`  --${token.name}: ${themeValue};`);
     }
     lines.push("");
   }
@@ -594,18 +615,18 @@ function generateThemeBlock(groups) {
   return lines.join("\n");
 }
 var ARTICLE_ELEMENT_STYLES = [
-  // Paragraphs
-  ["p", "leading-relaxed mb-4"],
+  // Paragraphs -- composition for metrics, structural for spacing
+  ["p", "text-body-medium ts-body-medium leading-relaxed mb-4"],
   ["p:last-child", "mb-0"],
-  // Headings
-  ["h1", "text-4xl font-bold tracking-tight mb-4 mt-0 text-accent-foreground"],
-  ["h2", "text-3xl font-semibold tracking-tight mb-3 mt-8 text-accent-foreground"],
+  // Headings -- compositions carry size/weight/tracking/leading/family
+  ["h1", "text-display-medium ts-display-medium mb-4 mt-0 text-accent-foreground"],
+  ["h2", "text-title-large ts-title-large mb-3 mt-8 text-accent-foreground"],
   ["h2:first-child", "mt-0"],
-  ["h3", "text-2xl font-semibold mb-2 mt-6 text-accent-foreground"],
-  ["h4", "text-xl font-semibold mb-2 mt-4 text-accent-foreground"],
-  ["h5", "text-lg font-semibold mb-2 mt-4 text-accent-foreground"],
-  ["h6", "text-base font-semibold mb-2 mt-4 text-accent-foreground"],
-  // Lists
+  ["h3", "text-title-medium ts-title-medium mb-2 mt-6 text-accent-foreground"],
+  ["h4", "text-title-small ts-title-small mb-2 mt-4 text-accent-foreground"],
+  ["h5", "text-title-small ts-title-small mb-2 mt-4 text-accent-foreground"],
+  ["h6", "text-title-small ts-title-small mb-2 mt-4 text-accent-foreground"],
+  // Lists -- structural only (type metrics cascade from parent)
   ["ul", "list-disc pl-6 mb-4"],
   ["ol", "list-decimal pl-6 mb-4"],
   ["li", "mb-1"],
@@ -615,11 +636,11 @@ var ARTICLE_ELEMENT_STYLES = [
   ["a:hover", "text-primary/80"],
   // Blockquotes
   ["blockquote", "border-l-4 border-muted pl-4 italic my-4"],
-  // Code
-  ["code", "bg-muted px-1.5 py-0.5 rounded text-sm font-mono"],
-  ["pre", "bg-muted p-4 rounded-lg overflow-x-auto my-4 text-sm font-mono"],
+  // Code -- composition for metrics + family, structural for bg/padding/radius
+  ["code", "text-code-small ts-code-small bg-muted px-1.5 py-0.5 rounded"],
+  ["pre", "text-code-large ts-code-large bg-muted p-4 rounded-lg overflow-x-auto my-4"],
   ["pre code", "bg-transparent p-0 rounded-none text-[inherit]"],
-  ["kbd", "bg-muted border border-border rounded px-1.5 py-0.5 text-sm font-mono"],
+  ["kbd", "text-code-small ts-code-small bg-muted border border-border rounded px-1.5 py-0.5"],
   // Horizontal rules
   ["hr", "border-border my-8"],
   // Media
@@ -627,12 +648,12 @@ var ARTICLE_ELEMENT_STYLES = [
   ["video", "rounded-lg my-4 max-w-full h-auto"],
   // Tables
   ["table", "w-full my-4 border-collapse"],
-  ["caption", "mt-2 text-sm text-muted-foreground text-left"],
+  ["caption", "text-label-small ts-label-small mt-2 text-muted-foreground text-left"],
   ["th", "border border-border px-3 py-2 text-left font-semibold"],
   ["td", "border border-border px-3 py-2"],
   // Figures
   ["figure", "my-4"],
-  ["figcaption", "mt-2 text-sm text-muted-foreground"],
+  ["figcaption", "text-label-small ts-label-small mt-2 text-muted-foreground"],
   // Definition lists
   ["dl", "my-4"],
   ["dt", "font-semibold mt-2"],
@@ -643,7 +664,7 @@ var ARTICLE_ELEMENT_STYLES = [
   // Inline formatting
   ["strong,\n  article b", "font-semibold"],
   ["mark", "bg-accent text-accent-foreground px-1 rounded"],
-  ["small", "text-sm"],
+  ["small", "text-label-small ts-label-small"],
   ["sub", "text-xs align-sub"],
   ["sup", "text-xs align-super"],
   ["abbr[title]", "underline decoration-dotted underline-offset-4 cursor-help"],
@@ -703,12 +724,21 @@ function generateDepthUtilities(depthTokens) {
   }
   return lines.join("\n");
 }
-function generateTypographyCompositeUtilities(compositeTokens) {
-  if (compositeTokens.length === 0) {
-    return "";
-  }
-  const lines = [];
-  const mappings = compositeTokens.map((t) => {
+var NAMED_TRACKING = {
+  tighter: "-0.05em",
+  tight: "-0.025em",
+  normal: "0em",
+  wide: "0.025em",
+  wider: "0.05em",
+  widest: "0.1em"
+};
+function trackingRef(key) {
+  const named = NAMED_TRACKING[key];
+  if (named !== void 0) return named;
+  return `var(--letter-spacing-${key})`;
+}
+function parseComposites(compositeTokens) {
+  return compositeTokens.map((t) => {
     try {
       const parsed = JSON.parse(t.value);
       return { name: t.name, ...parsed };
@@ -716,40 +746,50 @@ function generateTypographyCompositeUtilities(compositeTokens) {
       return null;
     }
   }).filter((m3) => m3 !== null);
-  for (const mapping of mappings) {
-    lines.push(`@utility text-${mapping.name} {`);
-    lines.push(`  font-family: var(--font-${mapping.fontFamily});`);
-    lines.push(`  font-size: var(--font-size-${mapping.fontSize});`);
-    lines.push(`  font-weight: var(--font-weight-${mapping.fontWeight});`);
-    lines.push(`  line-height: var(--line-height-${mapping.lineHeight});`);
-    const namedTrackingValues = {
-      tighter: "-0.05em",
-      tight: "-0.025em",
-      normal: "0em",
-      wide: "0.025em",
-      wider: "0.05em",
-      widest: "0.1em"
-    };
-    if (mapping.letterSpacing in namedTrackingValues) {
-      lines.push(`  letter-spacing: ${namedTrackingValues[mapping.letterSpacing]};`);
-    } else {
-      lines.push(`  letter-spacing: var(--letter-spacing-${mapping.letterSpacing});`);
-    }
-    if (mapping.responsive) {
-      for (const [breakpoint, overrides] of Object.entries(mapping.responsive)) {
+}
+function generateTypographyCompositeThemeInline(compositeTokens) {
+  const mappings = parseComposites(compositeTokens);
+  if (mappings.length === 0) return "";
+  const lines = [];
+  lines.push("@theme inline {");
+  for (const m3 of mappings) {
+    lines.push(`  --text-${m3.name}: var(--font-size-${m3.fontSize});`);
+    lines.push(`  --text-${m3.name}--line-height: var(--font-size-${m3.lineHeight}--line-height);`);
+    lines.push(`  --text-${m3.name}--letter-spacing: ${trackingRef(m3.letterSpacing)};`);
+    lines.push(`  --text-${m3.name}--font-weight: var(--font-weight-${m3.fontWeight});`);
+    lines.push(`  --rafters-ts-${m3.name}: var(--font-${m3.fontFamily});`);
+    if (m3.responsive) {
+      for (const [bp, overrides] of Object.entries(m3.responsive)) {
         if (overrides.fontSize) {
-          const bpWidth = breakpoint === "sm" ? "480px" : breakpoint === "md" ? "640px" : "1024px";
-          lines.push(`  @container (min-width: ${bpWidth}) {`);
-          lines.push(`    font-size: var(--font-size-${overrides.fontSize});`);
-          lines.push(`    line-height: var(--line-height-${overrides.fontSize});`);
-          lines.push("  }");
+          lines.push(`  --rafters-ts-${m3.name}-${bp}: var(--font-size-${overrides.fontSize});`);
+          lines.push(
+            `  --rafters-ts-${m3.name}-${bp}-leading: var(--font-size-${overrides.fontSize}--line-height);`
+          );
         }
       }
     }
-    lines.push("}");
+    lines.push("");
   }
+  lines.push("}");
   return lines.join("\n");
 }
+function generateTypographyCompositeUtility(compositeTokens) {
+  if (compositeTokens.length === 0) return "";
+  return [
+    "@utility ts-* {",
+    "  font-family: --value(--rafters-ts-*);",
+    "  text-transform: --value(--rafters-ts-*-transform);",
+    "  @container (min-width: 640px) {",
+    "    font-size: --value(--rafters-ts-*-md);",
+    "    line-height: --value(--rafters-ts-*-md-leading);",
+    "  }",
+    "  @container (min-width: 1024px) {",
+    "    font-size: --value(--rafters-ts-*-lg);",
+    "    line-height: --value(--rafters-ts-*-lg-leading);",
+    "  }",
+    "}"
+  ].join("\n");
+}
 function generateMotionUtilities(motionTokens) {
   const semanticTokens = motionTokens.filter((t) => t.name.startsWith("motion-semantic-"));
   if (semanticTokens.length === 0) {
@@ -781,6 +821,82 @@ function generateMotionUtilities(motionTokens) {
   }
   return lines.join("\n");
 }
+function generateMotionCellUtilities(motionTokens) {
+  const cellTokens = motionTokens.filter((t) => t.name.startsWith("motion-cell-"));
+  if (cellTokens.length === 0) return "";
+  const lines = [
+    "/* Motion cells -- one utility per animated (component, part, transition) */"
+  ];
+  for (const token of cellTokens) {
+    if (typeof token.value !== "string") continue;
+    let spec = null;
+    try {
+      spec = JSON.parse(token.value);
+    } catch {
+      spec = null;
+    }
+    lines.push(`@utility ${token.name.replace("motion-cell-", "animate-")} {`);
+    if (spec === null) {
+      lines.push(`  animation: ${token.value};`);
+    } else {
+      lines.push(`  animation-name: ${spec.keyframe};`);
+      lines.push(`  animation-duration: var(--rafters-duration-${spec.durationTier});`);
+      lines.push(`  animation-timing-function: var(--rafters-ease-${spec.curve});`);
+    }
+    lines.push("  @media (prefers-reduced-motion: reduce) {");
+    lines.push("    animation-duration: 0s;");
+    lines.push("  }");
+    lines.push("}");
+  }
+  return lines.join("\n");
+}
+function generateMotionNamespaceVars(motionTokens) {
+  const lines = [];
+  for (const token of motionTokens) {
+    if (!motionNamespaceParts(token.name)) continue;
+    const value = tokenValueToCSS(token);
+    if (value === null) continue;
+    lines.push(`  --${token.name}: ${value};`);
+  }
+  if (lines.length === 0) return "";
+  return [
+    "  /* The five motion namespaces -- system leaves, the values live here */",
+    ...lines
+  ].join("\n");
+}
+function generateMotionBridgeVars(motionTokens) {
+  const lines = [];
+  for (const token of motionTokens) {
+    if (token.name.startsWith("motion-duration-") && token.name !== "motion-duration-base") {
+      const key = token.name.replace("motion-duration-", "");
+      lines.push(`  --duration-${key}: var(--rafters-duration-${key});`);
+    }
+    if (token.name.startsWith("motion-easing-")) {
+      const key = token.name.replace("motion-easing-", "");
+      lines.push(`  --ease-${key}: var(--rafters-ease-${key});`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateMotionNamespaceUtilities(motionTokens) {
+  const lines = ["/* The five motion namespaces -- one utility per member */"];
+  let emitted = 0;
+  for (const token of motionTokens) {
+    const parts = motionNamespaceParts(token.name);
+    if (!parts) continue;
+    const property = MOTION_NAMESPACE_PROPERTY[parts.namespace];
+    emitted++;
+    lines.push(`@utility ${parts.namespace}-${parts.member} {`);
+    lines.push(`  ${property}: var(--${token.name});`);
+    if (REDUCED_MOTION_ZEROED.has(parts.namespace)) {
+      lines.push("  @media (prefers-reduced-motion: reduce) {");
+      lines.push(`    ${property}: 0ms;`);
+      lines.push("  }");
+    }
+    lines.push("}");
+  }
+  return emitted === 0 ? "" : lines.join("\n");
+}
 function overridePropertyToUtility(property, value) {
   switch (property) {
     case "fontFamily":
@@ -846,21 +962,38 @@ function tokensToTailwind(tokens, options = {}, typographyOverrides = []) {
   if (keyframes) {
     sections.push(keyframes);
   }
-  const typographyUtilities = generateTypographyCompositeUtilities(groups["typography-composite"]);
-  if (typographyUtilities) {
+  const typographyThemeInline = generateTypographyCompositeThemeInline(
+    groups["typography-composite"]
+  );
+  if (typographyThemeInline) {
+    sections.push("");
+    sections.push(typographyThemeInline);
+  }
+  const typographyTsUtility = generateTypographyCompositeUtility(groups["typography-composite"]);
+  if (typographyTsUtility) {
     sections.push("");
-    sections.push(typographyUtilities);
+    sections.push(typographyTsUtility);
   }
   const depthUtilities = generateDepthUtilities(groups.depth);
   if (depthUtilities) {
     sections.push("");
     sections.push(depthUtilities);
   }
+  const namespaceUtilities = generateMotionNamespaceUtilities(groups.motion);
+  if (namespaceUtilities) {
+    sections.push("");
+    sections.push(namespaceUtilities);
+  }
   const motionUtilities = generateMotionUtilities(groups.motion);
   if (motionUtilities) {
     sections.push("");
     sections.push(motionUtilities);
   }
+  const cellUtilities = generateMotionCellUtilities(groups.motion);
+  if (cellUtilities) {
+    sections.push("");
+    sections.push(cellUtilities);
+  }
   const overrideCSS = generateTypographyOverrideCSS(typographyOverrides);
   if (overrideCSS) {
     sections.push("");
@@ -882,7 +1015,7 @@ async function registryToCompiled(registry2, options = {}) {
 ${sourceDirectives}
 ${themeBody}`;
   const { execFileSync } = await import("child_process");
-  const { mkdtempSync, writeFileSync: writeFileSync2, readFileSync: readFileSync3, rmSync } = await import("fs");
+  const { mkdtempSync, writeFileSync: writeFileSync2, readFileSync: readFileSync4, rmSync } = await import("fs");
   const { join: join15, dirname: dirname4 } = await import("path");
   const { createRequire: createRequire2 } = await import("module");
   const require2 = createRequire2(import.meta.url);
@@ -904,7 +1037,7 @@ ${themeBody}`;
       args.push("--minify");
     }
     execFileSync("node", args, { stdio: "pipe", timeout: 3e4, cwd: pkgDir });
-    return readFileSync3(tempOutput, "utf-8");
+    return readFileSync4(tempOutput, "utf-8");
   } catch (error47) {
     const message = error47 instanceof Error ? error47.message : String(error47);
     throw new Error(`Failed to compile CSS: ${message}`);
@@ -1050,6 +1183,10 @@ function deriveCandidates(themeCSS) {
       candidates.add(name);
     } else if (name.startsWith("animate-")) {
       candidates.add(name);
+    } else if (name.startsWith("text-") && !name.includes("--")) {
+      candidates.add(`text-${name.slice(5)}`);
+    } else if (name.startsWith("rafters-ts-") && !name.endsWith("-transform")) {
+      candidates.add(`ts-${name.slice(11)}`);
     }
   }
   const base = [...candidates];
@@ -1105,8 +1242,8 @@ ${themeBody}`;
     const args = [binPath, "-i", tempInput, "-o", tempOutput];
     if (minify) args.push("--minify");
     execFileSync("node", args, { stdio: "pipe", timeout: 6e4, cwd: pkgDir });
-    const { readFileSync: readFileSync3 } = await import("fs");
-    const raw = readFileSync3(tempOutput, "utf-8");
+    const { readFileSync: readFileSync4 } = await import("fs");
+    const raw = readFileSync4(tempOutput, "utf-8");
     return postProcessDocSheet(raw);
   } catch (error47) {
     const message = error47 instanceof Error ? error47.message : String(error47);
@@ -1306,10 +1443,12 @@ var DEFAULT_SYSTEM_CONFIG = {
   // 1.2 ratio
   fontFamily: "'Noto Sans Variable', sans-serif",
   monoFontFamily: "ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'Liberation Mono', monospace",
-  // Rafters aesthetic overrides (happen to match pure math at baseSpacingUnit=4)
+  // Rafters aesthetic overrides.
+  // baseRadius and focusRingWidth have NO pin here -- they derive from
+  // baseSpacingUnit (×1.5 and ÷2), and at base 4 the derivation already
+  // produces 6 and 2. A pin would hide the derivation, which is the #2031
+  // defect one layer down.
   baseFontSizeOverride: 16,
-  baseRadiusOverride: 6,
-  focusRingWidthOverride: 2,
   baseTransitionDurationOverride: 150
 };
 var COLOR_SCALE_POSITIONS = [
@@ -1325,42 +1464,6 @@ var COLOR_SCALE_POSITIONS = [
   "900",
   "950"
 ];
-var SPACING_SCALE = [
-  "0",
-  "0.5",
-  "1",
-  "1.5",
-  "2",
-  "2.5",
-  "3",
-  "3.5",
-  "4",
-  "5",
-  "6",
-  "7",
-  "8",
-  "9",
-  "10",
-  "11",
-  "12",
-  "14",
-  "16",
-  "20",
-  "24",
-  "28",
-  "32",
-  "36",
-  "40",
-  "44",
-  "48",
-  "52",
-  "56",
-  "60",
-  "64",
-  "72",
-  "80",
-  "96"
-];
 var TYPOGRAPHY_SCALE = [
   "xs",
   "sm",
@@ -4468,7 +4571,7 @@ function range(color1, color2, options = {}) {
     let [r, options2] = [color1, color2];
     return range(...r.rangeArgs.colors, { ...r.rangeArgs.options, ...options2 });
   }
-  let { space, outputSpace, progression: progression2, premultiplied } = options;
+  let { space, outputSpace, progression, premultiplied } = options;
   color1 = getColor(color1);
   color2 = getColor(color2);
   color1 = clone(color1);
@@ -4502,7 +4605,7 @@ function range(color1, color2, options = {}) {
     color2.coords = color2.coords.map((c4) => c4 * color2.alpha);
   }
   return Object.assign((p2) => {
-    p2 = progression2 ? progression2(p2) : p2;
+    p2 = progression ? progression(p2) : p2;
     let coords = color1.coords.map((start, i) => {
       let end = color2.coords[i];
       return interpolate(start, end, p2);
@@ -21891,6 +21994,8 @@ var BindingSchema = external_exports.object({
   plugin: external_exports.string(),
   input: external_exports.unknown()
 });
+var OVERRIDE_KINDS = ["baseline", "preset", "designer"];
+var OverrideKindSchema = external_exports.enum(OVERRIDE_KINDS);
 var TokenSchema = external_exports.object({
   // Core token data
   name: external_exports.string(),
@@ -21929,7 +22034,13 @@ var TokenSchema = external_exports.object({
     // Why was this overridden
     reason: external_exports.string(),
     // Additional context (e.g. "Q1 marketing campaign", "accessibility audit")
-    context: external_exports.string().optional()
+    context: external_exports.string().optional(),
+    // Who attributed the value. The reason string is for humans; kind is what
+    // machines branch on (preset application skips kind === 'designer').
+    // Optional and never defaulted: absent means the provenance is unknown,
+    // which is the honest state of every override written before this field
+    // existed.
+    kind: OverrideKindSchema.optional()
   }).nullable(),
   // Computed value from generation rule (before any override)
   // Stored so agents can see what the system WOULD produce vs what human chose
@@ -22589,42 +22700,48 @@ var DEFAULT_SHADOW_DEFINITIONS = {
 };
 var DEFAULT_DURATION_DEFINITIONS = {
   instant: {
-    ms: 0,
+    range: [0, 0],
+    default: 0,
     band: "",
     meaning: "No perceptible transition. Cursor changes, text selection, badge counts. Below all perception -- there is nothing to track, so nothing is communicated.",
     contexts: ["disabled-motion", "prefers-reduced-motion", "cursor", "badge-count"],
     motionIntent: "transition"
   },
   micro: {
-    ms: 100,
+    range: [50, 120],
+    default: 100,
     band: "at the instantaneous threshold (Nielsen 0.1s)",
     meaning: "Immediate but visible. Focus rings and press feedback. At the instantaneous threshold -- acknowledgment that input landed, not communication of a change.",
     contexts: ["focus", "press", "micro-feedback"],
     motionIntent: "transition"
   },
   fast: {
-    ms: 150,
+    range: [120, 200],
+    default: 150,
     band: "below the communicative window",
     meaning: "Hover states. The cursor is already there, so the response must match its speed. Below the communicative window -- acknowledgment, not communication.",
     contexts: ["hover", "micro-feedback"],
     motionIntent: "transition"
   },
   moderate: {
-    ms: 250,
+    range: [200, 300],
+    default: 250,
     band: "communicative (~200-300ms)",
     meaning: "Dropdowns, tab switches, small reveals. The communicative window: fast enough to feel responsive, slow enough for the eye to track a trajectory and build a spatial model.",
     contexts: ["dropdowns", "tab-switches", "small-reveals"],
     motionIntent: "transition"
   },
   normal: {
-    ms: 350,
+    range: [300, 400],
+    default: 350,
     band: "communicative, larger movement",
     meaning: "The workhorse -- modal entrances, toggles, standard state transitions. The communicative window for larger movement.",
     contexts: ["modals", "toggles", "state-changes"],
     motionIntent: "enter"
   },
   slow: {
-    ms: 500,
+    range: [400, 500],
+    default: 500,
     band: "at the sluggish boundary",
     meaning: "Sheets, page transitions, large spatial movement where the user needs orientation. At the sluggish boundary -- the ceiling for anything but full-screen spatial transitions.",
     contexts: ["sheets", "page-transitions", "large-spatial-movement"],
@@ -22633,10 +22750,10 @@ var DEFAULT_DURATION_DEFINITIONS = {
 };
 var DEFAULT_EASING_DEFINITIONS = {
   standard: {
-    curve: [0.25, 0.1, 0.25, 1],
-    meaning: "Precision -- arrives exactly where it should, engineered rather than thrown. Decelerates into its final position. General-purpose state transitions and hover.",
+    curve: [0.4, 0, 0.2, 1],
+    meaning: "Precision -- a responsive start that decelerates into place, engineered rather than thrown. The general-purpose workhorse for state transitions and hover: the fast start matches a cursor already on target, where a symmetric ease would drag.",
     contexts: ["state-changes", "hover", "general-purpose"],
-    css: "cubic-bezier(0.25, 0.1, 0.25, 1)"
+    css: "cubic-bezier(0.4, 0, 0.2, 1)"
   },
   enter: {
     curve: [0, 0, 0.2, 1],
@@ -22669,10 +22786,307 @@ var DEFAULT_EASING_DEFINITIONS = {
     css: "cubic-bezier(0.2, 0.8, 0.2, 1)"
   }
 };
+var DEFAULT_KEYFRAME_DEFINITIONS = {
+  "fade-in": {
+    css: () => "from { opacity: 0; } to { opacity: 1; }",
+    meaning: "Fade from transparent to opaque",
+    contexts: ["enter", "appear", "show"]
+  },
+  "fade-out": {
+    css: () => "from { opacity: 1; } to { opacity: 0; }",
+    meaning: "Fade from opaque to transparent",
+    contexts: ["exit", "disappear", "hide"]
+  },
+  "slide-in-from-top": {
+    css: () => "from { transform: translateY(-100%); } to { transform: translateY(0); }",
+    meaning: "Slide in from above",
+    contexts: ["dropdown", "notification", "toast"]
+  },
+  "slide-in-from-bottom": {
+    css: () => "from { transform: translateY(100%); } to { transform: translateY(0); }",
+    meaning: "Slide in from below",
+    contexts: ["sheet", "drawer", "mobile-menu"]
+  },
+  "slide-in-from-left": {
+    css: () => "from { transform: translateX(-100%); } to { transform: translateX(0); }",
+    meaning: "Slide in from left",
+    contexts: ["sidebar", "panel", "drawer"]
+  },
+  "slide-in-from-right": {
+    css: () => "from { transform: translateX(100%); } to { transform: translateX(0); }",
+    meaning: "Slide in from right",
+    contexts: ["sidebar", "panel", "drawer"]
+  },
+  "slide-out-to-top": {
+    css: () => "from { transform: translateY(0); } to { transform: translateY(-100%); }",
+    meaning: "Slide out upward",
+    contexts: ["dropdown-exit", "notification-dismiss"]
+  },
+  "slide-out-to-bottom": {
+    css: () => "from { transform: translateY(0); } to { transform: translateY(100%); }",
+    meaning: "Slide out downward",
+    contexts: ["sheet-exit", "drawer-close"]
+  },
+  "slide-out-to-left": {
+    css: () => "from { transform: translateX(0); } to { transform: translateX(-100%); }",
+    meaning: "Slide out to left",
+    contexts: ["sidebar-close", "panel-exit"]
+  },
+  "slide-out-to-right": {
+    css: () => "from { transform: translateX(0); } to { transform: translateX(100%); }",
+    meaning: "Slide out to right",
+    contexts: ["sidebar-close", "panel-exit"]
+  },
+  "scale-in": {
+    css: () => "from { transform: scale(var(--rafters-extent-pop)); opacity: 0; } to { transform: scale(1); opacity: 1; }",
+    meaning: "Scale up while fading in",
+    contexts: ["modal", "popover", "dialog"]
+  },
+  "scale-out": {
+    css: () => "from { transform: scale(1); opacity: 1; } to { transform: scale(var(--rafters-extent-pop)); opacity: 0; }",
+    meaning: "Scale down while fading out",
+    contexts: ["modal-exit", "popover-close"]
+  },
+  spin: {
+    css: () => "from { transform: rotate(0deg); } to { transform: rotate(360deg); }",
+    meaning: "Continuous rotation",
+    contexts: ["loading", "spinner", "refresh"]
+  },
+  ping: {
+    css: (ctx) => `75%, 100% { transform: scale(${ctx.pingScale}); opacity: 0; }`,
+    meaning: "Expanding pulse that fades out",
+    contexts: ["notification-badge", "attention", "pulse"]
+  },
+  pulse: {
+    css: (ctx) => `0%, 100% { opacity: 1; } 50% { opacity: ${ctx.pulseOpacity}; }`,
+    meaning: "Gentle opacity pulse",
+    contexts: ["skeleton", "loading-placeholder"]
+  },
+  bounce: {
+    // Inline beziers retained deliberately -- see the provenance note above.
+    css: (ctx) => `0%, 100% { transform: translateY(-${ctx.bouncePercent}%); animation-timing-function: cubic-bezier(0.8, 0, 1, 1); } 50% { transform: translateY(0); animation-timing-function: cubic-bezier(0, 0, 0.2, 1); }`,
+    meaning: "Bouncing motion",
+    contexts: ["attention", "scroll-indicator"]
+  },
+  "caret-blink": {
+    css: () => "0%, 70%, 100% { opacity: 1; } 20%, 50% { opacity: 0; }",
+    meaning: "Text cursor blinking",
+    contexts: ["input-caret", "text-cursor"]
+  }
+};
+var DEFAULT_ANIMATION_DEFINITIONS = {
+  "fade-in": {
+    keyframe: "fade-in",
+    duration: { tier: "fast" },
+    curve: "enter",
+    meaning: "Fade in animation",
+    contexts: ["enter", "appear"]
+  },
+  "fade-out": {
+    keyframe: "fade-out",
+    duration: { tier: "fast" },
+    curve: "exit",
+    meaning: "Fade out animation",
+    contexts: ["exit", "disappear"]
+  },
+  "slide-in-from-top": {
+    keyframe: "slide-in-from-top",
+    duration: { tier: "normal" },
+    curve: "enter",
+    meaning: "Slide in from top",
+    contexts: ["dropdown", "notification"]
+  },
+  "slide-in-from-bottom": {
+    keyframe: "slide-in-from-bottom",
+    duration: { tier: "normal" },
+    curve: "enter",
+    meaning: "Slide in from bottom",
+    contexts: ["sheet", "drawer"]
+  },
+  "slide-in-from-left": {
+    keyframe: "slide-in-from-left",
+    duration: { tier: "normal" },
+    curve: "enter",
+    meaning: "Slide in from left",
+    contexts: ["sidebar", "panel"]
+  },
+  "slide-in-from-right": {
+    keyframe: "slide-in-from-right",
+    duration: { tier: "normal" },
+    curve: "enter",
+    meaning: "Slide in from right",
+    contexts: ["sidebar", "panel"]
+  },
+  "slide-out-to-top": {
+    keyframe: "slide-out-to-top",
+    duration: { tier: "fast" },
+    curve: "exit",
+    meaning: "Slide out to top",
+    contexts: ["dropdown-exit"]
+  },
+  "slide-out-to-bottom": {
+    keyframe: "slide-out-to-bottom",
+    duration: { tier: "fast" },
+    curve: "exit",
+    meaning: "Slide out to bottom",
+    contexts: ["sheet-exit"]
+  },
+  "slide-out-to-left": {
+    keyframe: "slide-out-to-left",
+    duration: { tier: "fast" },
+    curve: "exit",
+    meaning: "Slide out to left",
+    contexts: ["sidebar-close"]
+  },
+  "slide-out-to-right": {
+    keyframe: "slide-out-to-right",
+    duration: { tier: "fast" },
+    curve: "exit",
+    meaning: "Slide out to right",
+    contexts: ["sidebar-close"]
+  },
+  "scale-in": {
+    keyframe: "scale-in",
+    duration: { tier: "normal" },
+    curve: "spring-snappy",
+    meaning: "Scale in with spring",
+    contexts: ["modal", "popover"]
+  },
+  "scale-out": {
+    keyframe: "scale-out",
+    duration: { tier: "fast" },
+    curve: "exit",
+    meaning: "Scale out",
+    contexts: ["modal-exit"]
+  },
+  spin: {
+    keyframe: "spin",
+    duration: { loopPeriod: "1s" },
+    curve: "linear",
+    iterations: "infinite",
+    meaning: "Continuous spin",
+    contexts: ["loading", "spinner"]
+  },
+  ping: {
+    keyframe: "ping",
+    duration: { loopPeriod: "1s" },
+    curve: "enter",
+    iterations: "infinite",
+    meaning: "Pinging pulse",
+    contexts: ["notification"]
+  },
+  pulse: {
+    keyframe: "pulse",
+    duration: { loopPeriod: "2s" },
+    curve: "standard",
+    iterations: "infinite",
+    meaning: "Gentle pulse",
+    contexts: ["skeleton", "loading"]
+  },
+  bounce: {
+    keyframe: "bounce",
+    duration: { loopPeriod: "1s" },
+    curve: "standard",
+    iterations: "infinite",
+    meaning: "Bouncing",
+    contexts: ["attention"]
+  },
+  "caret-blink": {
+    keyframe: "caret-blink",
+    duration: { loopPeriod: "1.25s" },
+    curve: "enter",
+    iterations: "infinite",
+    meaning: "Caret blinking",
+    contexts: ["input"]
+  }
+};
+var DEFAULT_MOTION_CELL_ANIMATIONS = {
+  "dialog-content-open": {
+    keyframe: "scale-in",
+    tier: "normal",
+    curve: "enter",
+    cell: { component: "dialog", part: "content", transition: "closed -> open" },
+    meaning: "A dialog arriving: fade + zoom from the pop extent, on the arrival curve.",
+    contexts: ["dialog", "modal", "alert-dialog"]
+  },
+  "dialog-content-close": {
+    keyframe: "scale-out",
+    tier: "moderate",
+    curve: "exit",
+    cell: { component: "dialog", part: "content", transition: "open -> closed" },
+    meaning: "A dialog leaving: fade + zoom back to the pop extent, on the departure curve.",
+    contexts: ["dialog", "modal", "alert-dialog"]
+  },
+  "popover-content-open": {
+    keyframe: "scale-in",
+    tier: "moderate",
+    curve: "enter",
+    cell: { component: "popover", part: "content", transition: "closed -> open" },
+    meaning: "A popover arriving: smaller and nearer than a dialog, so one tier quicker.",
+    contexts: ["popover", "anchored-popup"]
+  },
+  "popover-content-close": {
+    keyframe: "scale-out",
+    tier: "fast",
+    curve: "exit",
+    cell: { component: "popover", part: "content", transition: "open -> closed" },
+    meaning: "A popover leaving: the user already chose to dismiss it.",
+    contexts: ["popover", "anchored-popup"]
+  },
+  "dropdown-menu-content-open": {
+    keyframe: "scale-in",
+    tier: "moderate",
+    curve: "enter",
+    cell: { component: "dropdown-menu", part: "content", transition: "closed -> open" },
+    meaning: "A menu arriving: same anchored-popup moment as popover, declared separately.",
+    contexts: ["dropdown-menu", "menu", "anchored-popup"]
+  },
+  "dropdown-menu-content-close": {
+    keyframe: "scale-out",
+    tier: "fast",
+    curve: "exit",
+    cell: { component: "dropdown-menu", part: "content", transition: "open -> closed" },
+    meaning: "A menu leaving, after a choice or a dismissal.",
+    contexts: ["dropdown-menu", "menu", "anchored-popup"]
+  }
+};
+var DEFAULT_MOTION_COMPOSITE_PRESETS = {
+  "motion-fade-in": {
+    durationTier: "fast",
+    curve: "enter",
+    meaning: "Fade in animation preset",
+    contexts: ["fade-in", "appear"]
+  },
+  "motion-fade-out": {
+    durationTier: "fast",
+    curve: "exit",
+    meaning: "Fade out animation preset",
+    contexts: ["fade-out", "disappear"]
+  },
+  "motion-slide-in": {
+    durationTier: "normal",
+    curve: "enter",
+    meaning: "Slide in animation preset",
+    contexts: ["slide-in", "panel-enter", "modal-enter"]
+  },
+  "motion-slide-out": {
+    durationTier: "fast",
+    curve: "exit",
+    meaning: "Slide out animation preset",
+    contexts: ["slide-out", "panel-exit", "modal-exit"]
+  },
+  "motion-scale-in": {
+    durationTier: "normal",
+    curve: "spring-snappy",
+    meaning: "Scale in with spring animation",
+    contexts: ["pop-in", "button-press", "emphasis"]
+  }
+};
 var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   hover: {
     properties: ["color", "background-color", "border-color"],
-    durationTier: "fast",
+    travel: "none",
+    band: "fast",
     curve: "standard",
     reducedMotion: null,
     category: "interaction",
@@ -22682,7 +23096,8 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   focus: {
     properties: ["box-shadow", "outline-color"],
-    durationTier: "micro",
+    travel: "none",
+    band: "micro",
     curve: "linear",
     reducedMotion: null,
     category: "interaction",
@@ -22692,7 +23107,8 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   press: {
     properties: ["transform", "color", "background-color"],
-    durationTier: "micro",
+    travel: "none",
+    band: "micro",
     curve: "spring-snappy",
     reducedMotion: { properties: ["color", "background-color"] },
     category: "interaction",
@@ -22702,18 +23118,25 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   toggle: {
     properties: ["color", "background-color", "transform"],
-    durationTier: "moderate",
-    curve: "spring-snappy",
+    travel: "none",
+    band: "moderate",
+    // `standard`, not `spring-snappy`. The 30-site study found 29 of 30 sites
+    // carry zero overshoot curves, and the one that does is the friendly
+    // exemplar -- spring-snappy belongs to friendly and effectively nowhere
+    // else. Efficient is the shipped default intent and is characterised as
+    // zero-overshoot, so a spring here contradicts the intent it ships under.
+    // Matches the recorded ruling: an efficient toggle is crisp; friendly is
+    // the intent that springs a switch.
+    curve: "standard",
     reducedMotion: { properties: ["color", "background-color"] },
     category: "interaction",
-    sizeReasoning: "A thumb travelling a track is a small, tracked movement -- moderate tier, snappy spring. Reduced motion drops the transform to a colour cross-fade.",
+    sizeReasoning: "A thumb travelling a track is a small, tracked movement -- moderate tier at the standard curve. Reduced motion drops the transform to a colour cross-fade.",
     meaning: "Toggle/switch state change. Shows the new state.",
     contexts: ["switch", "toggle", "checkbox"]
   },
   "dropdown-in": {
     properties: ["opacity", "transform"],
-    durationTier: "moderate",
-    curve: "enter",
+    travel: "short",
     reducedMotion: { properties: ["opacity"], ms: 100 },
     category: "enter",
     sizeReasoning: "A dropdown is small and travels a short distance -- moderate tier, one step below the modal, with the arrival curve.",
@@ -22722,8 +23145,7 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   "dropdown-out": {
     properties: ["opacity", "transform"],
-    durationTier: "fast",
-    curve: "exit",
+    travel: "short",
     reducedMotion: { properties: ["opacity"], ms: 100 },
     category: "exit",
     sizeReasoning: "The exit of a small element -- fast tier (shorter than its moderate entrance) with the departure curve. The user already chose to dismiss it.",
@@ -22732,8 +23154,7 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   "modal-in": {
     properties: ["opacity", "transform"],
-    durationTier: "normal",
-    curve: "enter",
+    travel: "medium",
     reducedMotion: { properties: ["opacity"], ms: 150 },
     category: "enter",
     sizeReasoning: "A modal is larger and travels farther than a dropdown -- normal tier, one step up, with the arrival curve. Size and distance produce the longer duration.",
@@ -22742,8 +23163,7 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   "modal-out": {
     properties: ["opacity", "transform"],
-    durationTier: "moderate",
-    curve: "exit",
+    travel: "medium",
     reducedMotion: { properties: ["opacity"], ms: 150 },
     category: "exit",
     sizeReasoning: "The modal exit -- moderate tier (shorter than its normal entrance) with the departure curve.",
@@ -22752,18 +23172,16 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   "sheet-in": {
     properties: ["transform"],
-    durationTier: "slow",
-    curve: "spring-smooth",
+    travel: "large",
     reducedMotion: { properties: ["opacity"], ms: 250 },
     category: "enter",
-    sizeReasoning: "A sheet is the largest spatial movement -- slow tier with the physical settle of a smooth spring, because the user must track it into place. Reduced motion becomes a cross-fade.",
+    sizeReasoning: "A sheet is a large spatial movement -- normal tier with the physical settle of a smooth spring, because the user must track it into place. Reduced motion becomes a cross-fade.",
     meaning: "Sheet/drawer entrance.",
     contexts: ["sheet", "drawer", "side-panel"]
   },
   "sheet-out": {
     properties: ["transform"],
-    durationTier: "normal",
-    curve: "exit",
+    travel: "large",
     reducedMotion: { properties: ["opacity"], ms: 250 },
     category: "exit",
     sizeReasoning: "The sheet exit -- normal tier (shorter than its slow entrance) with the departure curve.",
@@ -22772,8 +23190,7 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   expand: {
     properties: ["grid-template-rows", "opacity"],
-    durationTier: "normal",
-    curve: "enter",
+    travel: "medium",
     reducedMotion: { properties: ["opacity"] },
     category: "enter",
     sizeReasoning: "Content unfolding to its natural height -- normal tier with the arrival curve. Transitions grid-template-rows (0fr->1fr), the transitionable stand-in for height:auto. Reduced motion snaps the rows and fades opacity.",
@@ -22782,8 +23199,7 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   collapse: {
     properties: ["grid-template-rows", "opacity"],
-    durationTier: "moderate",
-    curve: "exit",
+    travel: "medium",
     reducedMotion: { properties: ["opacity"] },
     category: "exit",
     sizeReasoning: "Content folding away -- moderate tier (shorter than its normal expansion) with the departure curve. Reduced motion snaps the rows.",
@@ -22792,20 +23208,103 @@ var DEFAULT_MOTION_SEMANTIC_MAPPINGS = {
   },
   page: {
     properties: ["opacity", "transform"],
-    durationTier: "slow",
-    curve: "spring-smooth",
+    travel: "large",
     reducedMotion: { properties: ["opacity"], ms: 200 },
     category: "enter",
-    sizeReasoning: "A whole-view transition -- slow tier with the physical settle of a smooth spring, because the user reorients across the largest possible distance.",
+    sizeReasoning: "A whole-view transition -- normal tier with the physical settle of a smooth spring, because the user reorients across a large distance.",
     meaning: "Page/route transition.",
     contexts: ["page-transition", "route-change", "view-switch"]
   }
 };
-var DEFAULT_DELAY_DEFINITIONS = {
-  none: { step: "none" },
-  short: { step: -1 },
-  medium: { step: 0 },
-  long: { step: 1 }
+var DEFAULT_DELAY_NAMESPACE = {
+  "hover-intent": {
+    value: "200ms",
+    provenance: "observed",
+    note: "Observed in navigation-menu, which hardcoded it before #1995 routed both it and tooltip through the runtime accessor. Observed in working code, not tuned.",
+    meaning: "How long a pointer must rest before the system believes the hover was meant. Long enough to survive a pass-through, short enough that a deliberate hover does not feel ignored.",
+    contexts: ["tooltip", "hover-card", "navigation-menu"]
+  },
+  linger: {
+    value: "300ms",
+    provenance: "proposed",
+    note: "PROPOSED. The grace window before a hovered surface closes, so a diagonal cursor path to a submenu does not dismiss it.",
+    meaning: "How long a surface stays after the pointer leaves, so a near-miss is forgiven.",
+    contexts: ["hover-card", "navigation-menu", "submenu"]
+  },
+  "choreo-step": {
+    value: "50ms",
+    provenance: "proposed",
+    note: "PROPOSED. The offset between two parts of ONE surface moving together (panel then its content).",
+    meaning: "The beat between choreographed parts of a single surface.",
+    contexts: ["modal-content", "panel-content", "sequenced-parts"]
+  },
+  "stagger-step": {
+    value: "0ms",
+    provenance: "proposed",
+    note: "PROPOSED, and zero is a value: efficient does not stagger lists. A non-zero stagger is a character choice a designer makes, not a default.",
+    meaning: "The per-item offset when a list animates in.",
+    contexts: ["staggered-lists", "sequential-elements"]
+  },
+  skip: {
+    value: "300ms",
+    provenance: "proposed",
+    note: "PROPOSED. The warm-reopen window: reopen inside it and the entrance delay is skipped, because the user is already oriented.",
+    meaning: "How long a just-closed surface stays warm enough to reopen without ceremony.",
+    contexts: ["tooltip-reopen", "menu-reopen"]
+  }
+};
+var DEFAULT_EXTENT_NAMESPACE = {
+  pop: {
+    value: "0.95",
+    provenance: "proposed",
+    note: "PROPOSED. The scale a surface enters from. Close to 1 so the entrance reads as arrival rather than as a zoom.",
+    meaning: "How far a surface scales up as it arrives.",
+    contexts: ["modal", "popover", "dialog"]
+  },
+  press: {
+    value: "0.97",
+    provenance: "proposed",
+    note: "PROPOSED. Depression under a press. Smaller than `pop` because the finger is the evidence -- the motion only confirms it.",
+    meaning: "How far a control depresses when pressed.",
+    contexts: ["button", "toggle", "press-feedback"]
+  },
+  draw: {
+    value: "1",
+    provenance: "proposed",
+    note: "PROPOSED. The completed fraction of a drawn indicator. 1 is full travel; a value below it is a deliberately incomplete stroke.",
+    meaning: "How far an indicator draws along its track.",
+    contexts: ["tabs-indicator", "underline", "progress-stroke"]
+  }
+};
+var DEFAULT_PERIOD_NAMESPACE = {
+  spin: {
+    value: "1s",
+    provenance: "baseline",
+    note: "The shipped loop period of the spin animation.",
+    meaning: "One full rotation of a working indicator.",
+    contexts: ["loading", "spinner", "refresh"]
+  },
+  pulse: {
+    value: "2s",
+    provenance: "baseline",
+    note: "The shipped loop period of the pulse animation.",
+    meaning: "One breath of a skeleton or placeholder.",
+    contexts: ["skeleton", "loading-placeholder"]
+  },
+  blink: {
+    value: "1.25s",
+    provenance: "baseline",
+    note: "The shipped loop period of the caret-blink animation.",
+    meaning: "One blink of a text caret.",
+    contexts: ["input-caret", "text-cursor"]
+  },
+  shimmer: {
+    value: "2s",
+    provenance: "proposed",
+    note: "PROPOSED. No shimmer animation ships yet; the period is here because the namespace is a vocabulary, not a list of what happens to exist.",
+    meaning: "One sweep of a shimmer across a loading surface.",
+    contexts: ["skeleton", "loading-placeholder"]
+  }
 };
 var DEFAULT_FOCUS_CONFIGS = {
   default: {
@@ -22884,41 +23383,13 @@ var DEFAULT_RADIUS_DEFINITIONS = {
     contexts: ["avatars", "pill-buttons", "circular-elements"]
   }
 };
-var DEFAULT_SPACING_MULTIPLIERS = {
-  "0": 0,
-  "0.5": 0.5,
-  "1": 1,
-  "1.5": 1.5,
-  "2": 2,
-  "2.5": 2.5,
-  "3": 3,
-  "3.5": 3.5,
-  "4": 4,
-  "5": 5,
-  "6": 6,
-  "7": 7,
-  "8": 8,
-  "9": 9,
-  "10": 10,
-  "11": 11,
-  "12": 12,
-  "14": 14,
-  "16": 16,
-  "20": 20,
-  "24": 24,
-  "28": 28,
-  "32": 32,
-  "36": 36,
-  "40": 40,
-  "44": 44,
-  "48": 48,
-  "52": 52,
-  "56": 56,
-  "60": 60,
-  "64": 64,
-  "72": 72,
-  "80": 80,
-  "96": 96
+var DEFAULT_SPACING_BOUNDS = {
+  floor: 1,
+  ceiling: 96
+};
+var DEFAULT_SHADOW_BOUNDS = {
+  floor: 1,
+  ceiling: 96
 };
 var DEFAULT_TYPOGRAPHY_SCALE = {
   xs: { step: -2, lineHeight: 1.5, letterSpacing: "0.025em" },
@@ -25020,25 +25491,23 @@ function generateDepthTokens(_config, depthDefs) {
 }
 
 // ../design-tokens/src/generators/focus.ts
-function pxToRem(px) {
-  const rem = Math.round(px / 16 * 1e3) / 1e3;
-  return `${rem}rem`;
-}
 function generateFocusTokens(config2, focusConfigs) {
   const tokens = [];
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const { focusRingWidth } = config2;
-  const focusRingWidthRem = pxToRem(focusRingWidth);
+  const { focusRingWidth, baseSpacingUnit } = config2;
+  const focusDivisor = focusRingWidth > 0 ? Math.round(baseSpacingUnit / focusRingWidth * 1e3) / 1e3 : 2;
+  const focusWidthValue = `calc(var(--rafters-spacing-base) / ${focusDivisor})`;
   tokens.push({
     name: "focus-ring-width",
-    value: focusRingWidthRem,
+    value: focusWidthValue,
     category: "focus",
     namespace: "focus",
-    semanticMeaning: "Default focus ring width - WCAG 2.2 requires minimum 2px",
+    semanticMeaning: "Default focus ring width - derives from spacing base",
     usageContext: ["focus-indicators", "keyboard-navigation"],
     accessibilityLevel: "AA",
-    focusRingWidth: focusRingWidthRem,
-    description: `Focus ring width ${focusRingWidthRem}. WCAG 2.2 requires minimum 2px for visibility.`,
+    focusRingWidth: focusWidthValue,
+    dependsOn: ["spacing-base"],
+    description: `Focus ring width = spacing-base / ${focusDivisor} (${focusRingWidth}px at base ${baseSpacingUnit}). WCAG 2.2 requires minimum 2px.`,
     generatedAt: timestamp,
     containerQueryAware: false,
     userOverride: null,
@@ -25062,14 +25531,22 @@ function generateFocusTokens(config2, focusConfigs) {
     highContrastMode: "Highlight",
     userOverride: null
   });
+  const focusVar = "var(--rafters-focus-ring-width)";
+  const focusCalc = (px) => {
+    const mult = px / focusRingWidth;
+    if (mult === 0) return "0";
+    if (mult === 1) return focusVar;
+    if (mult === -1) return `calc(${focusVar} * -1)`;
+    return `calc(${focusVar} * ${mult})`;
+  };
   for (const [name, focusConfig] of Object.entries(focusConfigs)) {
-    const widthRem = pxToRem(focusConfig.width);
-    const offsetRem = pxToRem(focusConfig.offset);
+    const widthVal = focusCalc(focusConfig.width);
+    const offsetVal = focusCalc(focusConfig.offset);
     tokens.push({
       name: name === "default" ? "focus-ring" : `focus-ring-${name}`,
       value: JSON.stringify({
-        width: widthRem,
-        offset: offsetRem,
+        width: widthVal,
+        offset: offsetVal,
         style: focusConfig.style,
         color: "var(--ring)"
       }),
@@ -25077,13 +25554,13 @@ function generateFocusTokens(config2, focusConfigs) {
       namespace: "focus",
       semanticMeaning: focusConfig.meaning,
       usageContext: focusConfig.contexts,
-      focusRingWidth: widthRem,
+      focusRingWidth: widthVal,
       focusRingColor: "var(--ring)",
-      focusRingOffset: offsetRem,
+      focusRingOffset: offsetVal,
       focusRingStyle: focusConfig.style,
       dependsOn: ["ring", "focus-ring-width"],
       accessibilityLevel: focusConfig.width >= 2 ? "AA" : void 0,
-      description: `${focusConfig.meaning}. Width: ${widthRem}, Offset: ${offsetRem}.`,
+      description: `${focusConfig.meaning}. Width: ${widthVal}, Offset: ${offsetVal}.`,
       generatedAt: timestamp,
       containerQueryAware: false,
       highContrastMode: "Highlight",
@@ -25096,7 +25573,7 @@ function generateFocusTokens(config2, focusConfigs) {
         ]
       }
     });
-    const outlineValue = `${widthRem} ${focusConfig.style} var(--ring)`;
+    const outlineValue = `${widthVal} ${focusConfig.style} var(--ring)`;
     tokens.push({
       name: name === "default" ? "focus-outline" : `focus-outline-${name}`,
       value: outlineValue,
@@ -25104,20 +25581,21 @@ function generateFocusTokens(config2, focusConfigs) {
       namespace: "focus",
       semanticMeaning: `CSS outline shorthand for ${name} focus ring`,
       usageContext: ["css-outline-property"],
-      dependsOn: ["ring"],
-      description: `CSS outline value: ${outlineValue}. Use with outline-offset: ${offsetRem}.`,
+      dependsOn: ["ring", "focus-ring-width"],
+      description: `CSS outline value: ${outlineValue}. Use with outline-offset: ${offsetVal}.`,
       generatedAt: timestamp,
       containerQueryAware: false,
       userOverride: null
     });
     tokens.push({
       name: name === "default" ? "focus-offset" : `focus-offset-${name}`,
-      value: offsetRem,
+      value: offsetVal,
       category: "focus",
       namespace: "focus",
       semanticMeaning: `Focus ring offset for ${name} style`,
-      focusRingOffset: offsetRem,
-      description: `Focus offset ${offsetRem} for ${name} focus style.`,
+      focusRingOffset: offsetVal,
+      dependsOn: ["focus-ring-width"],
+      description: `Focus offset ${offsetVal} for ${name} focus style.`,
       generatedAt: timestamp,
       containerQueryAware: false,
       userOverride: null
@@ -25126,7 +25604,7 @@ function generateFocusTokens(config2, focusConfigs) {
   tokens.push({
     name: "focus-within-ring",
     value: JSON.stringify({
-      width: focusRingWidthRem,
+      width: focusVar,
       offset: "0",
       style: "solid",
       color: "var(--ring)"
@@ -25135,11 +25613,11 @@ function generateFocusTokens(config2, focusConfigs) {
     namespace: "focus",
     semanticMeaning: "Focus ring for containers with focused descendants",
     usageContext: ["form-groups", "card-actions", "list-containers"],
-    focusRingWidth: focusRingWidthRem,
+    focusRingWidth: focusVar,
     focusRingColor: "var(--ring)",
     focusRingOffset: "0",
     focusRingStyle: "solid",
-    dependsOn: ["ring"],
+    dependsOn: ["ring", "focus-ring-width"],
     description: "Focus indicator for containers using :focus-within pseudo-class.",
     generatedAt: timestamp,
     containerQueryAware: false,
@@ -25149,13 +25627,13 @@ function generateFocusTokens(config2, focusConfigs) {
       never: ["Use as replacement for child focus indicators", "Apply to non-container elements"]
     }
   });
-  const highContrastWidth = focusRingWidth * 1.5;
-  const highContrastOffset = focusRingWidth;
+  const hcWidthVal = `calc(${focusVar} * 1.5)`;
+  const hcOffsetVal = focusVar;
   tokens.push({
     name: "focus-high-contrast",
     value: JSON.stringify({
-      width: pxToRem(highContrastWidth),
-      offset: pxToRem(highContrastOffset),
+      width: hcWidthVal,
+      offset: hcOffsetVal,
       style: "solid",
       color: "Highlight"
     }),
@@ -25163,10 +25641,11 @@ function generateFocusTokens(config2, focusConfigs) {
     namespace: "focus",
     semanticMeaning: "Focus ring for Windows High Contrast Mode",
     usageContext: ["high-contrast-mode", "forced-colors"],
-    focusRingWidth: pxToRem(highContrastWidth),
-    focusRingOffset: pxToRem(highContrastOffset),
+    focusRingWidth: hcWidthVal,
+    focusRingOffset: hcOffsetVal,
     focusRingStyle: "solid",
     highContrastMode: "Highlight",
+    dependsOn: ["focus-ring-width"],
     description: "High contrast focus ring using system Highlight color.",
     generatedAt: timestamp,
     containerQueryAware: false,
@@ -25346,21 +25825,6 @@ function evaluateExpression(expression, options = {}) {
 }
 
 // ../math-utils/src/progressions.ts
-var progression = (r, base, step) => base * ratioValue(r) ** step;
-function generateSequence(r, base, count, options = {}) {
-  const { startStep = 0, includeZero = false } = options;
-  const ratio = ratioValue(r);
-  const result = [];
-  for (let i = 0; i < count; i++) {
-    if (i === 0 && includeZero) {
-      result.push(0);
-    } else {
-      const step = startStep + (includeZero ? i - 1 : i);
-      result.push(base * ratio ** step);
-    }
-  }
-  return result;
-}
 function generateModularScale(r, base, steps2 = 5) {
   const ratio = ratioValue(r);
   const smaller = [];
@@ -25422,45 +25886,142 @@ function tryParseUnit(cssValue, registry2 = DEFAULT_UNITS) {
   }
 }
 
-// ../design-tokens/src/generators/motion.ts
-var LEGACY_EASING_REMAP = {
-  linear: "linear",
-  "ease-out": "enter",
-  "ease-in": "exit",
-  "ease-in-out": "standard",
-  spring: "spring-snappy"
+// ../design-tokens/src/generators/motion-derivation.ts
+var BAND_ORDER = ["instant", "micro", "fast", "moderate", "normal", "slow"];
+var TRAVEL_BAND = {
+  none: "fast",
+  short: "moderate",
+  medium: "normal",
+  large: "slow"
+};
+var LARGE_TRAVEL_DISAGREEMENT = {
+  derived: "slow",
+  shipped: "normal",
+  reason: "b864de01 places the sheet pair at normal deliberately -- the one pair without a shortened exit. Unresolved: either the model needs a term that justifies normal, or these move to slow."
+};
+function applyLargeTravelException(band, travel) {
+  return travel === "large" ? LARGE_TRAVEL_DISAGREEMENT.shipped : band;
+}
+function shortenForExit(band) {
+  const i = BAND_ORDER.indexOf(band);
+  return BAND_ORDER[Math.max(0, i - 1)];
+}
+var INTENT_POSITION = {
+  efficient: null,
+  elegant: 1,
+  friendly: null,
+  technical: null,
+  editorial: null
 };
-function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, semanticMappings) {
+var LANDMARK_BANDS = /* @__PURE__ */ new Set(["instant", "micro", "fast"]);
+function deriveDuration(band, intent, durationDefs) {
+  const def = durationDefs[band];
+  if (def === void 0) {
+    throw new Error(
+      `motion derivation: unknown band "${band}". Known bands: ${BAND_ORDER.join(", ")}.`
+    );
+  }
+  if (LANDMARK_BANDS.has(band)) return def.default;
+  const position = INTENT_POSITION[intent];
+  if (position === null) return def.default;
+  const [min, max2] = def.range;
+  return Math.round(min + (max2 - min) * position);
+}
+function deriveBand(category, travel, declaredBand) {
+  if (category === "interaction") {
+    if (declaredBand === void 0) {
+      throw new Error(
+        "motion derivation: an interaction mapping must declare its band -- it has no travel to derive from."
+      );
+    }
+    return declaredBand;
+  }
+  const base = applyLargeTravelException(TRAVEL_BAND[travel], travel);
+  if (category === "exit" && travel !== "large") return shortenForExit(base);
+  return base;
+}
+function deriveCurve(category, travel, _intent, declaredCurve) {
+  if (category === "exit") return "exit";
+  if (category === "enter") return travel === "large" ? "spring-smooth" : "enter";
+  return declaredCurve ?? "standard";
+}
+
+// ../design-tokens/src/generators/motion.ts
+function requireDef(defs, key, kind, owner) {
+  const def = defs[key];
+  if (def === void 0) {
+    throw new Error(
+      `motion generator: ${owner} references unknown ${kind} "${key}". Known ${kind}s: ${Object.keys(defs).sort().join(", ")}.`
+    );
+  }
+  return def;
+}
+function motionNamespaceTokenName(namespace, member) {
+  return `rafters-${namespace}-${member}`;
+}
+function namespaceLeaf(input) {
+  const { namespaceName, member, value, provenance, note, meaning, contexts, timestamp } = input;
+  return {
+    name: motionNamespaceTokenName(namespaceName, member),
+    value,
+    category: "motion",
+    namespace: "motion",
+    semanticMeaning: meaning,
+    usageContext: contexts,
+    dependsOn: [],
+    description: `${namespaceName}-${member}: ${value} [provenance: ${provenance}] ${note} ${meaning}`,
+    generatedAt: timestamp,
+    containerQueryAware: false,
+    // Mirrors the exporter's REDUCED_MOTION_ZEROED set: only duration and delay
+    // are zeroed under prefers-reduced-motion. ease/extent are shaped BY a
+    // duration, not zeroed themselves; period is exempt by law (loops slow,
+    // never stop).
+    reducedMotionAware: namespaceName === "duration" || namespaceName === "delay",
+    userOverride: null,
+    usagePatterns: {
+      do: [`Use the generated utility \`${namespaceName}-${member}\``],
+      never: [
+        "Hardcode this value in a component",
+        "Add a second name for the same idea -- one fast, everywhere, always"
+      ]
+    }
+  };
+}
+function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, extentDefs, periodDefs, semanticMappings, keyframeDefs, animationDefs, compositePresets, cellAnimations) {
   const tokens = [];
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const { baseTransitionDuration, progressionRatio } = config2;
+  const intent = config2.intent ?? "efficient";
   const ratio = resolveRatio(progressionRatio);
   const ratioVal = ratioValue(ratio);
-  const computeStep = (base, step) => progression(ratio, base, step);
   tokens.push({
     name: "motion-duration-base",
     value: `${baseTransitionDuration}ms`,
     category: "motion",
     namespace: "motion",
-    semanticMeaning: "Legacy base transition duration. The perceptual duration scale (motion-duration-*) no longer derives from this; retained only as a reference value and delay-progression base.",
-    usageContext: ["calculation-reference", "delay-base"],
+    semanticMeaning: "Legacy base transition duration. Nothing derives from this any more: the perceptual duration scale never did, and the ratio-stepped delay tokens that did were removed in #1991. Retained as a reference value only.",
+    usageContext: ["calculation-reference"],
     progressionSystem: progressionRatio,
-    description: `Base duration (${baseTransitionDuration}ms). Delay tokens use ${progressionRatio} progression (ratio ${ratioVal}); duration tiers are perceptually derived literals.`,
+    description: `Base duration (${baseTransitionDuration}ms). A reference value with no dependents: duration tiers are perceptual RANGES a designer sets within, and the delay namespace holds relationships rather than ratio steps.`,
     generatedAt: timestamp,
     containerQueryAware: false,
     reducedMotionAware: true,
     userOverride: null,
     usagePatterns: {
       do: ["Reference as the delay-progression base"],
-      never: ["Assume the perceptual duration tiers derive from this"]
+      never: [
+        "Assume the perceptual duration tiers derive from this -- they are ranges a designer sets within, bounded by perception, not computed from this base"
+      ]
     }
   });
   for (const scale2 of MOTION_DURATION_SCALE) {
     const def = durationDefs[scale2];
     if (!def) continue;
     const scaleIndex = MOTION_DURATION_SCALE.indexOf(scale2);
-    const durationMs = def.ms;
+    const durationMs = deriveDuration(scale2, intent, durationDefs);
+    const [rangeMin, rangeMax] = def.range;
     const bandNote = def.band ? ` Band: ${def.band}.` : "";
+    const rangeNote = rangeMin === rangeMax ? " Fixed." : ` Range: ${rangeMin}-${rangeMax}ms.`;
     tokens.push({
       name: `motion-duration-${scale2}`,
       value: `${durationMs}ms`,
@@ -25471,9 +26032,9 @@ function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, sema
       scalePosition: scaleIndex,
       motionIntent: def.motionIntent,
       motionDuration: durationMs,
-      mathRelationship: def.band ? `${durationMs}ms (perceptual: ${def.band})` : `${durationMs}ms`,
+      mathRelationship: def.band ? `${durationMs}ms within ${rangeMin}-${rangeMax}ms (perceptual: ${def.band})` : `${durationMs}ms (fixed)`,
       dependsOn: [],
-      description: `Duration ${scale2}: ${durationMs}ms.${bandNote} ${def.meaning}`,
+      description: `Duration ${scale2}: ${durationMs}ms.${rangeNote}${bandNote} ${def.meaning}`,
       generatedAt: timestamp,
       containerQueryAware: false,
       reducedMotionAware: true,
@@ -25510,416 +26071,185 @@ function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, sema
       }
     });
   }
-  for (const [name, def] of Object.entries(delayDefs)) {
-    let delayMs;
-    let mathRelationship;
-    if (def.step === "none") {
-      delayMs = 0;
-      mathRelationship = "0";
-    } else {
-      delayMs = Math.round(computeStep(baseTransitionDuration, def.step));
-      mathRelationship = def.step === 0 ? `${baseTransitionDuration}ms (base)` : `${baseTransitionDuration} \xD7 ${ratioVal}^${def.step}`;
+  for (const scale2 of MOTION_DURATION_SCALE) {
+    const def = durationDefs[scale2];
+    if (!def) continue;
+    const durationMs = deriveDuration(scale2, intent, durationDefs);
+    tokens.push(
+      namespaceLeaf({
+        namespaceName: "duration",
+        member: scale2,
+        value: `${durationMs}ms`,
+        provenance: "baseline",
+        note: def.band ? `Efficient baseline. ${durationMs}ms within the ${def.band} band (${def.range[0]}-${def.range[1]}ms).` : `Efficient baseline. Fixed at ${durationMs}ms.`,
+        meaning: def.meaning,
+        contexts: def.contexts,
+        timestamp
+      })
+    );
+  }
+  for (const curve of EASING_CURVES) {
+    const def = easingDefs[curve];
+    if (!def) continue;
+    tokens.push(
+      namespaceLeaf({
+        namespaceName: "ease",
+        member: curve,
+        value: def.css,
+        provenance: "baseline",
+        note: "Efficient baseline curve.",
+        meaning: def.meaning,
+        contexts: def.contexts,
+        timestamp
+      })
+    );
+  }
+  for (const [namespaceName, members] of [
+    ["delay", delayDefs],
+    ["extent", extentDefs],
+    ["period", periodDefs]
+  ]) {
+    for (const [member, def] of Object.entries(members)) {
+      tokens.push(
+        namespaceLeaf({
+          namespaceName,
+          member,
+          value: def.value,
+          provenance: def.provenance,
+          note: def.note,
+          meaning: def.meaning,
+          contexts: def.contexts,
+          timestamp
+        })
+      );
     }
-    tokens.push({
-      name: `motion-delay-${name}`,
-      value: delayMs === 0 ? "0ms" : `${delayMs}ms`,
-      category: "motion",
-      namespace: "motion",
-      semanticMeaning: `${name.charAt(0).toUpperCase() + name.slice(1)} animation delay`,
-      usageContext: name === "none" ? ["immediate-response"] : name === "short" ? ["staggered-lists", "sequential-elements"] : name === "medium" ? ["modal-content", "after-transition"] : ["emphasis", "dramatic-reveals"],
-      delayMs,
-      mathRelationship,
-      dependsOn: def.step === "none" ? [] : ["motion-duration-base"],
-      description: `Delay ${name}: ${delayMs}ms. Based on duration progression.`,
-      generatedAt: timestamp,
-      containerQueryAware: false,
-      reducedMotionAware: true,
-      userOverride: null
-    });
   }
   const ratioValue2 = ratioVal;
-  const scaleStart = Math.round(1 / ratioValue2 ** 0.25 * 100) / 100;
   const pingScale = Math.round(ratioValue2 ** 3 * 10) / 10;
   const pulseOpacity = Math.round(1 / ratioValue2 ** 4 * 100) / 100;
   const bouncePercent = Math.round(100 / ratioValue2 ** 6);
-  const keyframes = [
-    {
-      name: "fade-in",
-      css: "from { opacity: 0; } to { opacity: 1; }",
-      meaning: "Fade from transparent to opaque",
-      contexts: ["enter", "appear", "show"]
-    },
-    {
-      name: "fade-out",
-      css: "from { opacity: 1; } to { opacity: 0; }",
-      meaning: "Fade from opaque to transparent",
-      contexts: ["exit", "disappear", "hide"]
-    },
-    {
-      name: "slide-in-from-top",
-      css: "from { transform: translateY(-100%); } to { transform: translateY(0); }",
-      meaning: "Slide in from above",
-      contexts: ["dropdown", "notification", "toast"]
-    },
-    {
-      name: "slide-in-from-bottom",
-      css: "from { transform: translateY(100%); } to { transform: translateY(0); }",
-      meaning: "Slide in from below",
-      contexts: ["sheet", "drawer", "mobile-menu"]
-    },
-    {
-      name: "slide-in-from-left",
-      css: "from { transform: translateX(-100%); } to { transform: translateX(0); }",
-      meaning: "Slide in from left",
-      contexts: ["sidebar", "panel", "drawer"]
-    },
-    {
-      name: "slide-in-from-right",
-      css: "from { transform: translateX(100%); } to { transform: translateX(0); }",
-      meaning: "Slide in from right",
-      contexts: ["sidebar", "panel", "drawer"]
-    },
-    {
-      name: "slide-out-to-top",
-      css: "from { transform: translateY(0); } to { transform: translateY(-100%); }",
-      meaning: "Slide out upward",
-      contexts: ["dropdown-exit", "notification-dismiss"]
-    },
-    {
-      name: "slide-out-to-bottom",
-      css: "from { transform: translateY(0); } to { transform: translateY(100%); }",
-      meaning: "Slide out downward",
-      contexts: ["sheet-exit", "drawer-close"]
-    },
-    {
-      name: "slide-out-to-left",
-      css: "from { transform: translateX(0); } to { transform: translateX(-100%); }",
-      meaning: "Slide out to left",
-      contexts: ["sidebar-close", "panel-exit"]
-    },
-    {
-      name: "slide-out-to-right",
-      css: "from { transform: translateX(0); } to { transform: translateX(100%); }",
-      meaning: "Slide out to right",
-      contexts: ["sidebar-close", "panel-exit"]
-    },
-    {
-      name: "scale-in",
-      css: `from { transform: scale(${scaleStart}); opacity: 0; } to { transform: scale(1); opacity: 1; }`,
-      meaning: "Scale up while fading in",
-      contexts: ["modal", "popover", "dialog"]
-    },
-    {
-      name: "scale-out",
-      css: `from { transform: scale(1); opacity: 1; } to { transform: scale(${scaleStart}); opacity: 0; }`,
-      meaning: "Scale down while fading out",
-      contexts: ["modal-exit", "popover-close"]
-    },
-    {
-      name: "spin",
-      css: "from { transform: rotate(0deg); } to { transform: rotate(360deg); }",
-      meaning: "Continuous rotation",
-      contexts: ["loading", "spinner", "refresh"]
-    },
-    {
-      name: "ping",
-      css: `75%, 100% { transform: scale(${pingScale}); opacity: 0; }`,
-      meaning: "Expanding pulse that fades out",
-      contexts: ["notification-badge", "attention", "pulse"]
-    },
-    {
-      name: "pulse",
-      css: `0%, 100% { opacity: 1; } 50% { opacity: ${pulseOpacity}; }`,
-      meaning: "Gentle opacity pulse",
-      contexts: ["skeleton", "loading-placeholder"]
-    },
-    {
-      name: "bounce",
-      css: `0%, 100% { transform: translateY(-${bouncePercent}%); animation-timing-function: cubic-bezier(0.8, 0, 1, 1); } 50% { transform: translateY(0); animation-timing-function: cubic-bezier(0, 0, 0.2, 1); }`,
-      meaning: "Bouncing motion",
-      contexts: ["attention", "scroll-indicator"]
-    },
-    {
-      name: "accordion-down",
-      css: "from { height: 0; } to { height: var(--radix-accordion-content-height); }",
-      meaning: "Expand accordion content",
-      contexts: ["accordion", "collapsible", "expand"]
-    },
-    {
-      name: "accordion-up",
-      css: "from { height: var(--radix-accordion-content-height); } to { height: 0; }",
-      meaning: "Collapse accordion content",
-      contexts: ["accordion", "collapsible", "collapse"]
-    },
-    {
-      name: "caret-blink",
-      css: "0%, 70%, 100% { opacity: 1; } 20%, 50% { opacity: 0; }",
-      meaning: "Text cursor blinking",
-      contexts: ["input-caret", "text-cursor"]
-    }
-  ];
-  for (const kf of keyframes) {
+  const keyframeContext = {
+    pingScale,
+    pulseOpacity,
+    bouncePercent
+  };
+  for (const [name, kf] of Object.entries(keyframeDefs)) {
     tokens.push({
-      name: `motion-keyframe-${kf.name}`,
-      value: kf.css,
+      name: `motion-keyframe-${name}`,
+      value: kf.css(keyframeContext),
       category: "motion",
       namespace: "motion",
       semanticMeaning: kf.meaning,
       usageContext: kf.contexts,
-      keyframeName: kf.name,
-      description: `Keyframe ${kf.name}: ${kf.meaning}`,
+      keyframeName: name,
+      description: `Keyframe ${name}: ${kf.meaning}`,
       generatedAt: timestamp,
       containerQueryAware: false,
       reducedMotionAware: true,
       userOverride: null
     });
   }
-  const animations = [
-    {
-      name: "fade-in",
-      keyframe: "fade-in",
-      duration: "fast",
-      easing: "ease-out",
-      meaning: "Fade in animation",
-      contexts: ["enter", "appear"]
-    },
-    {
-      name: "fade-out",
-      keyframe: "fade-out",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Fade out animation",
-      contexts: ["exit", "disappear"]
-    },
-    {
-      name: "slide-in-from-top",
-      keyframe: "slide-in-from-top",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Slide in from top",
-      contexts: ["dropdown", "notification"]
-    },
-    {
-      name: "slide-in-from-bottom",
-      keyframe: "slide-in-from-bottom",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Slide in from bottom",
-      contexts: ["sheet", "drawer"]
-    },
-    {
-      name: "slide-in-from-left",
-      keyframe: "slide-in-from-left",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Slide in from left",
-      contexts: ["sidebar", "panel"]
-    },
-    {
-      name: "slide-in-from-right",
-      keyframe: "slide-in-from-right",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Slide in from right",
-      contexts: ["sidebar", "panel"]
-    },
-    {
-      name: "slide-out-to-top",
-      keyframe: "slide-out-to-top",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Slide out to top",
-      contexts: ["dropdown-exit"]
-    },
-    {
-      name: "slide-out-to-bottom",
-      keyframe: "slide-out-to-bottom",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Slide out to bottom",
-      contexts: ["sheet-exit"]
-    },
-    {
-      name: "slide-out-to-left",
-      keyframe: "slide-out-to-left",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Slide out to left",
-      contexts: ["sidebar-close"]
-    },
-    {
-      name: "slide-out-to-right",
-      keyframe: "slide-out-to-right",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Slide out to right",
-      contexts: ["sidebar-close"]
-    },
-    {
-      name: "scale-in",
-      keyframe: "scale-in",
-      duration: "normal",
-      easing: "spring",
-      meaning: "Scale in with spring",
-      contexts: ["modal", "popover"]
-    },
-    {
-      name: "scale-out",
-      keyframe: "scale-out",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Scale out",
-      contexts: ["modal-exit"]
-    },
-    {
-      name: "spin",
-      keyframe: "spin",
-      duration: "1s",
-      easing: "linear",
-      iterations: "infinite",
-      meaning: "Continuous spin",
-      contexts: ["loading", "spinner"]
-    },
-    {
-      name: "ping",
-      keyframe: "ping",
-      duration: "1s",
-      easing: "ease-out",
-      iterations: "infinite",
-      meaning: "Pinging pulse",
-      contexts: ["notification"]
-    },
-    {
-      name: "pulse",
-      keyframe: "pulse",
-      duration: "2s",
-      easing: "ease-in-out",
-      iterations: "infinite",
-      meaning: "Gentle pulse",
-      contexts: ["skeleton", "loading"]
-    },
-    {
-      name: "bounce",
-      keyframe: "bounce",
-      duration: "1s",
-      easing: "ease-in-out",
-      iterations: "infinite",
-      meaning: "Bouncing",
-      contexts: ["attention"]
-    },
-    {
-      name: "accordion-down",
-      keyframe: "accordion-down",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Accordion expand",
-      contexts: ["accordion", "collapsible"]
-    },
-    {
-      name: "accordion-up",
-      keyframe: "accordion-up",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Accordion collapse",
-      contexts: ["accordion", "collapsible"]
-    },
-    {
-      name: "caret-blink",
-      keyframe: "caret-blink",
-      duration: "1.25s",
-      easing: "ease-out",
-      iterations: "infinite",
-      meaning: "Caret blinking",
-      contexts: ["input"]
-    }
-  ];
-  for (const anim of animations) {
+  for (const [name, anim] of Object.entries(animationDefs)) {
     let durationValue;
     let durationRef;
-    if (anim.duration.endsWith("s") || anim.duration.endsWith("ms")) {
-      durationValue = anim.duration;
-      durationRef = anim.duration;
+    let durationDependency;
+    if ("loopPeriod" in anim.duration) {
+      durationValue = anim.duration.loopPeriod;
+      durationRef = anim.duration.loopPeriod;
+      durationDependency = [];
     } else {
-      const durationDef = durationDefs[anim.duration];
-      if (!durationDef) continue;
-      durationValue = `${durationDef.ms}ms`;
-      durationRef = `var(--motion-duration-${anim.duration})`;
-    }
-    const easingKey = LEGACY_EASING_REMAP[anim.easing] ?? anim.easing;
-    const easingDef = easingDefs[easingKey];
-    if (!easingDef) continue;
-    const easingRef = `var(--motion-easing-${easingKey})`;
+      const durationDef = requireDef(
+        durationDefs,
+        anim.duration.tier,
+        "duration tier",
+        `animation "${name}"`
+      );
+      durationValue = `${durationDef.default}ms`;
+      durationRef = `var(--rafters-duration-${anim.duration.tier})`;
+      durationDependency = [`rafters-duration-${anim.duration.tier}`];
+    }
+    const easingDef = requireDef(easingDefs, anim.curve, "easing curve", `animation "${name}"`);
+    const easingRef = `var(--rafters-ease-${anim.curve})`;
     const iterations = anim.iterations || "";
     const animValue = iterations ? `${anim.keyframe} ${durationRef} ${easingRef} ${iterations}` : `${anim.keyframe} ${durationRef} ${easingRef}`;
     tokens.push({
-      name: `motion-animation-${anim.name}`,
+      name: `motion-animation-${name}`,
       value: animValue,
       category: "motion",
       namespace: "motion",
       semanticMeaning: anim.meaning,
       usageContext: anim.contexts,
-      animationName: anim.name,
+      animationName: name,
       keyframeName: anim.keyframe,
       animationDuration: durationValue,
       animationEasing: easingDef.css,
       animationIterations: anim.iterations || "1",
       dependsOn: [
         `motion-keyframe-${anim.keyframe}`,
-        ...anim.duration.endsWith("s") || anim.duration.endsWith("ms") ? [] : [`motion-duration-${anim.duration}`],
-        `motion-easing-${easingKey}`
+        ...durationDependency,
+        `rafters-ease-${anim.curve}`
       ],
-      description: `Animation ${anim.name}: ${anim.meaning}`,
+      description: `Animation ${name}: ${anim.meaning}`,
       generatedAt: timestamp,
       containerQueryAware: false,
       reducedMotionAware: true,
       userOverride: null
     });
   }
-  const composites2 = [
-    {
-      name: "motion-fade-in",
-      duration: "fast",
-      easing: "ease-out",
-      meaning: "Fade in animation preset",
-      contexts: ["fade-in", "appear"]
-    },
-    {
-      name: "motion-fade-out",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Fade out animation preset",
-      contexts: ["fade-out", "disappear"]
-    },
-    {
-      name: "motion-slide-in",
-      duration: "normal",
-      easing: "ease-out",
-      meaning: "Slide in animation preset",
-      contexts: ["slide-in", "panel-enter", "modal-enter"]
-    },
-    {
-      name: "motion-slide-out",
-      duration: "fast",
-      easing: "ease-in",
-      meaning: "Slide out animation preset",
-      contexts: ["slide-out", "panel-exit", "modal-exit"]
-    },
-    {
-      name: "motion-scale-in",
-      duration: "normal",
-      easing: "spring",
-      meaning: "Scale in with spring animation",
-      contexts: ["pop-in", "button-press", "emphasis"]
-    }
-  ];
-  for (const comp of composites2) {
-    const durationDef = durationDefs[comp.duration];
-    const easingKey = LEGACY_EASING_REMAP[comp.easing] ?? comp.easing;
-    const easingDef = easingDefs[easingKey];
-    if (!durationDef || !easingDef) continue;
-    const durationMs = durationDef.ms;
+  for (const [name, cell] of Object.entries(cellAnimations)) {
+    requireDef(keyframeDefs, cell.keyframe, "keyframe", `motion cell "${name}"`);
+    requireDef(durationDefs, cell.tier, "duration tier", `motion cell "${name}"`);
+    requireDef(easingDefs, cell.curve, "easing curve", `motion cell "${name}"`);
+    const { component, part, transition } = cell.cell;
     tokens.push({
-      name: comp.name,
+      name: `motion-cell-${name}`,
+      value: JSON.stringify({
+        keyframe: cell.keyframe,
+        durationTier: cell.tier,
+        curve: cell.curve
+      }),
+      category: "motion",
+      namespace: "motion",
+      semanticMeaning: cell.meaning,
+      usageContext: cell.contexts,
+      animationName: name,
+      keyframeName: cell.keyframe,
+      generateUtilityClass: true,
+      dependsOn: [
+        `motion-keyframe-${cell.keyframe}`,
+        `rafters-duration-${cell.tier}`,
+        `rafters-ease-${cell.curve}`
+      ],
+      description: `Motion cell ${component} / ${part} / ${transition}: ${cell.keyframe} over ${cell.tier} with ${cell.curve}. ${cell.meaning}`,
+      generatedAt: timestamp,
+      containerQueryAware: false,
+      reducedMotionAware: true,
+      userOverride: null,
+      usagePatterns: {
+        do: [`Apply class animate-${name} on the ${component} ${part} for "${transition}"`],
+        never: [
+          "Reuse this cell on a different component -- assignments come from motion.jsonl, one cell at a time",
+          "Add motion-reduce:animate-none alongside it -- animation:none resets the shorthand and discards the zeroed duration"
+        ]
+      }
+    });
+  }
+  for (const [name, comp] of Object.entries(compositePresets)) {
+    const durationDef = requireDef(
+      durationDefs,
+      comp.durationTier,
+      "duration tier",
+      `composite preset "${name}"`
+    );
+    const easingDef = requireDef(
+      easingDefs,
+      comp.curve,
+      "easing curve",
+      `composite preset "${name}"`
+    );
+    const durationMs = durationDef.default;
+    tokens.push({
+      name,
       value: `${durationMs}ms ${easingDef.css}`,
       category: "motion",
       namespace: "motion",
@@ -25927,9 +26257,9 @@ function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, sema
       usageContext: comp.contexts,
       motionDuration: durationMs,
       easingCurve: easingDef.curve,
-      easingName: easingKey,
-      dependsOn: [`motion-duration-${comp.duration}`, `motion-easing-${easingKey}`],
-      description: `${comp.meaning}. Combines ${comp.duration} duration with ${easingKey} easing.`,
+      easingName: comp.curve,
+      dependsOn: [`motion-duration-${comp.durationTier}`, `motion-easing-${comp.curve}`],
+      description: `${comp.meaning}. Combines ${comp.durationTier} duration with ${comp.curve} easing.`,
       generatedAt: timestamp,
       containerQueryAware: false,
       reducedMotionAware: true,
@@ -25937,12 +26267,16 @@ function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, sema
     });
   }
   for (const [name, mapping] of Object.entries(semanticMappings)) {
+    const durationTier = deriveBand(mapping.category, mapping.travel, mapping.band);
+    const curve = deriveCurve(mapping.category, mapping.travel, intent, mapping.curve);
+    requireDef(durationDefs, durationTier, "duration tier", `semantic motion "${name}"`);
+    requireDef(easingDefs, curve, "easing curve", `semantic motion "${name}"`);
     tokens.push({
       name: `motion-semantic-${name}`,
       value: JSON.stringify({
         properties: mapping.properties,
-        durationTier: mapping.durationTier,
-        curve: mapping.curve,
+        durationTier,
+        curve,
         reducedMotion: mapping.reducedMotion
       }),
       category: "motion",
@@ -25951,8 +26285,8 @@ function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, sema
       usageContext: mapping.contexts,
       motionIntent: mapping.category === "enter" ? "enter" : mapping.category === "exit" ? "exit" : "transition",
       generateUtilityClass: true,
-      dependsOn: [`motion-duration-${mapping.durationTier}`, `motion-easing-${mapping.curve}`],
-      description: `Semantic motion motion-${name}: ${mapping.properties.join(", ")} over ${mapping.durationTier} with ${mapping.curve}. ${mapping.sizeReasoning}`,
+      dependsOn: [`motion-duration-${durationTier}`, `motion-easing-${curve}`],
+      description: `Semantic motion motion-${name}: ${mapping.properties.join(", ")} over ${durationTier} with ${curve}. ${mapping.sizeReasoning}`,
       generatedAt: timestamp,
       containerQueryAware: false,
       reducedMotionAware: true,
@@ -25969,12 +26303,13 @@ function generateMotionTokens(config2, durationDefs, easingDefs, delayDefs, sema
       ratio: progressionRatio,
       ratioValue: ratioVal,
       baseDuration: baseTransitionDuration,
-      note: "Duration tiers are perceptually derived literals (docs/MOTION.md); delay tokens use the workspace progression ratio from the base duration."
+      note: "Duration tiers are perceptually derived literals (docs/MOTION.md) and the five motion namespaces are authored leaves. The ratio reaches exactly one place: the loop keyframes ping, pulse and bounce, whose shapes are computed from it.",
+      ratioDrivenKeyframes: ["ping", "pulse", "bounce"]
     }),
     category: "motion",
     namespace: "motion",
     semanticMeaning: "Metadata about the motion system",
-    description: `Duration tiers are perceptual literals; delays use ${progressionRatio} progression from ${baseTransitionDuration}ms base.`,
+    description: `Duration tiers are perceptual literals; the five motion namespaces (duration, ease, delay, extent, period) are authored leaves. The ${progressionRatio} progression drives the loop keyframes ping, pulse and bounce, and nothing else -- the ${baseTransitionDuration}ms base is recorded for reference and drives no value.`,
     generatedAt: timestamp,
     containerQueryAware: false,
     userOverride: null
@@ -25998,16 +26333,17 @@ function generateRadiusTokens(config2, radiusDefs) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const { baseRadius, progressionRatio } = config2;
   const ratioVal = ratioValue(resolveRatio(progressionRatio));
-  const baseRadiusRem = baseRadius / 16;
+  const radiusMultiplier = Math.round(baseRadius / config2.baseSpacingUnit * 1e3) / 1e3;
   tokens.push({
     name: "radius-base",
-    value: `${baseRadiusRem}rem`,
+    value: `calc(var(--rafters-spacing-base) * ${radiusMultiplier})`,
     category: "radius",
     namespace: "radius",
-    semanticMeaning: "Base border radius - all other radii derive from this value",
+    semanticMeaning: "Base border radius - derives from spacing base",
     usageContext: ["calculation-reference"],
     progressionSystem: progressionRatio,
-    description: `Base radius (${baseRadiusRem}rem / ${baseRadius}px). Scale uses ${progressionRatio} progression (ratio ${ratioVal}).`,
+    dependsOn: ["spacing-base"],
+    description: `Base radius = spacing-base * ${radiusMultiplier} (${baseRadius}px at base ${config2.baseSpacingUnit}). Scale uses ${progressionRatio} progression (ratio ${ratioVal}).`,
     generatedAt: timestamp,
     containerQueryAware: false,
     userOverride: null,
@@ -26045,15 +26381,15 @@ function generateRadiusTokens(config2, radiusDefs) {
       mathRelationship = "infinite (9999px)";
     } else if (def.step === 0) {
       value = "var(--rafters-radius-base)";
-      mathRelationship = `${baseRadiusRem}rem (base)`;
+      mathRelationship = `spacing-base * ${radiusMultiplier} (base)`;
     } else {
       const multiplier = Math.round(ratioVal ** def.step * 1e3) / 1e3;
       value = `calc(var(--rafters-radius-base) * ${multiplier})`;
       mathRelationship = `base \xD7 ${ratioVal}^${def.step} (\xD7${multiplier})`;
     }
-    const scaleName = scale2 === "DEFAULT" ? "radius" : `radius-${scale2}`;
+    const scaleName2 = scale2 === "DEFAULT" ? "radius" : `radius-${scale2}`;
     tokens.push({
-      name: scaleName,
+      name: scaleName2,
       value,
       category: "radius",
       namespace: "radius",
@@ -26242,40 +26578,69 @@ function generateSemanticTokens(_config) {
   };
 }
 
+// ../design-tokens/src/generators/progression.ts
+var NON_ADVANCING = 1;
+function progressionFrom(floor, ratioVal, ceiling) {
+  if (!(ratioVal > NON_ADVANCING) || !(floor > 0) || !(ceiling >= floor)) return [floor];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let n2 = 0; ; n2++) {
+    const value = Math.round(floor * ratioVal ** n2);
+    if (value > ceiling) break;
+    if (!seen.has(value)) {
+      seen.add(value);
+      out.push(value);
+    }
+  }
+  return out;
+}
+function nearestRung(target, scale2) {
+  let best = scale2[0] ?? target;
+  for (const v of scale2) {
+    if (Math.abs(v - target) < Math.abs(best - target)) best = v;
+  }
+  return best;
+}
+
 // ../design-tokens/src/generators/shadow.ts
-function pxToRem2(px) {
+function pxToRem(px) {
   const rem = Math.round(px / 16 * 1e3) / 1e3;
   return `${rem}rem`;
 }
 var SHADOW_PARTS = ["offset-x", "offset-y", "blur", "spread", "color"];
-function scalePx(multiplier, baseSpacing) {
-  return Math.round(multiplier * baseSpacing * 100) / 100;
+function shadowScale(ratioVal, bounds) {
+  return progressionFrom(bounds.floor, ratioVal, bounds.ceiling);
+}
+function scalePx(multiplier, baseSpacing, scale2) {
+  if (multiplier === 0) return 0;
+  return nearestRung(multiplier * baseSpacing, scale2);
 }
-function resolveShadowParts(def, baseSpacing) {
+function resolveShadowParts(def, baseSpacing, scale2) {
   return {
     // Shadows are vertical-only by design (material elevation model)
     "offset-x": "0rem",
-    "offset-y": pxToRem2(scalePx(def.yOffset, baseSpacing)),
-    blur: pxToRem2(scalePx(def.blur, baseSpacing)),
-    spread: pxToRem2(scalePx(def.spread, baseSpacing)),
+    "offset-y": pxToRem(scalePx(def.yOffset, baseSpacing, scale2)),
+    blur: pxToRem(scalePx(def.blur, baseSpacing, scale2)),
+    spread: pxToRem(scalePx(def.spread, baseSpacing, scale2)),
     color: `rgb(0 0 0 / ${def.opacity})`
   };
 }
-function generateInnerShadowValue(inner, baseSpacing) {
-  const y = pxToRem2(scalePx(inner.yOffset, baseSpacing));
-  const blur = pxToRem2(scalePx(inner.blur, baseSpacing));
-  const spread = pxToRem2(scalePx(inner.spread, baseSpacing));
+function generateInnerShadowValue(inner, baseSpacing, scale2) {
+  const y = pxToRem(scalePx(inner.yOffset, baseSpacing, scale2));
+  const blur = pxToRem(scalePx(inner.blur, baseSpacing, scale2));
+  const spread = pxToRem(scalePx(inner.spread, baseSpacing, scale2));
   return `0 ${y} ${blur} ${spread} rgb(0 0 0 / ${inner.opacity})`;
 }
 function buildCompositeFromVars(prefix, innerValue) {
   const primary = SHADOW_PARTS.map((part) => `var(--rafters-${prefix}-${part})`).join(" ");
   return innerValue ? `${primary}, ${innerValue}` : primary;
 }
-function generateShadowTokens(config2, shadowDefs) {
+function generateShadowTokens(config2, shadowDefs, bounds) {
   const tokens = [];
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const { baseSpacingUnit, progressionRatio } = config2;
   const ratioVal = ratioValue(resolveRatio(progressionRatio));
+  const geometry = shadowScale(ratioVal, bounds);
   const baseSpacingRem = baseSpacingUnit / 16;
   tokens.push({
     name: "shadow-base-unit",
@@ -26295,10 +26660,10 @@ function generateShadowTokens(config2, shadowDefs) {
     const def = shadowDefs[scale2];
     if (!def) continue;
     const scaleIndex = SHADOW_SCALE.indexOf(scale2);
-    const scaleName = scale2 === "DEFAULT" ? "shadow" : `shadow-${scale2}`;
+    const scaleName2 = scale2 === "DEFAULT" ? "shadow" : `shadow-${scale2}`;
     if (def.opacity === 0) {
       tokens.push({
-        name: scaleName,
+        name: scaleName2,
         value: "none",
         category: "shadow",
         namespace: "shadow",
@@ -26318,10 +26683,10 @@ function generateShadowTokens(config2, shadowDefs) {
       });
       continue;
     }
-    const parts = resolveShadowParts(def, baseSpacingUnit);
+    const parts = resolveShadowParts(def, baseSpacingUnit, geometry);
     const partDeps = [];
     for (const part of SHADOW_PARTS) {
-      const partName = `${scaleName}-${part}`;
+      const partName = `${scaleName2}-${part}`;
       partDeps.push(partName);
       tokens.push({
         name: partName,
@@ -26338,10 +26703,10 @@ function generateShadowTokens(config2, shadowDefs) {
         userOverride: null
       });
     }
-    const innerValue = def.innerShadow && def.innerShadow.opacity > 0 ? generateInnerShadowValue(def.innerShadow, baseSpacingUnit) : null;
-    const compositeValue = buildCompositeFromVars(scaleName, innerValue);
+    const innerValue = def.innerShadow && def.innerShadow.opacity > 0 ? generateInnerShadowValue(def.innerShadow, baseSpacingUnit, geometry) : null;
+    const compositeValue = buildCompositeFromVars(scaleName2, innerValue);
     tokens.push({
-      name: scaleName,
+      name: scaleName2,
       value: compositeValue,
       category: "shadow",
       namespace: "shadow",
@@ -26350,7 +26715,7 @@ function generateShadowTokens(config2, shadowDefs) {
       scalePosition: scaleIndex,
       progressionSystem: progressionRatio,
       dependsOn: partDeps,
-      description: `Shadow ${scale2}: ${def.meaning}. Composed from var() refs to ${scaleName}-* tokens.`,
+      description: `Shadow ${scale2}: ${def.meaning}. Composed from var() refs to ${scaleName2}-* tokens.`,
       generatedAt: timestamp,
       containerQueryAware: false,
       userOverride: null,
@@ -26423,13 +26788,19 @@ function generateShadowTokens(config2, shadowDefs) {
 }
 
 // ../design-tokens/src/generators/spacing.ts
-function generateSpacingTokens(config2, spacingMultipliers) {
+function spacingMultipliers(ratioVal, bounds) {
+  return progressionFrom(bounds.floor, ratioVal, bounds.ceiling);
+}
+function scaleName(multiplier) {
+  return String(multiplier);
+}
+function generateSpacingTokens(config2, bounds) {
   const tokens = [];
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const { baseSpacingUnit, progressionRatio } = config2;
   const ratio = resolveRatio(progressionRatio);
   const ratioVal = ratioValue(ratio);
-  const progression2 = generateSequence(ratio, baseSpacingUnit, 10, { includeZero: true });
+  const multipliers = spacingMultipliers(ratioVal, bounds);
   const baseRem = baseSpacingUnit / 16;
   tokens.push({
     name: "spacing-base",
@@ -26454,11 +26825,10 @@ function generateSpacingTokens(config2, spacingMultipliers) {
       ]
     }
   });
-  for (const scale2 of SPACING_SCALE) {
-    const multiplier = spacingMultipliers[scale2];
-    if (multiplier === void 0) continue;
+  for (const multiplier of [0, ...multipliers]) {
+    const scale2 = scaleName(multiplier);
     const value = baseSpacingUnit * multiplier;
-    const scaleIndex = SPACING_SCALE.indexOf(scale2);
+    const scaleIndex = multipliers.indexOf(multiplier) + 1;
     let meaning;
     let usageContext;
     if (multiplier === 0) {
@@ -26505,16 +26875,19 @@ function generateSpacingTokens(config2, spacingMultipliers) {
   }
   tokens.push({
     name: "spacing-progression",
+    // The scale that actually shipped. Before #2031 this carried a `sample`
+    // computed straight off the ratio while the tokens came from a table --
+    // metadata describing a scale that did not exist.
     value: JSON.stringify({
       ratio: progressionRatio,
       ratioValue: ratioVal,
       baseUnit: baseSpacingUnit,
-      sample: progression2.map((v) => Math.round(v * 100) / 100)
+      multipliers
     }),
     category: "spacing",
     namespace: "spacing",
     semanticMeaning: "Metadata about the spacing progression system",
-    description: `Spacing uses ${progressionRatio} progression (ratio ${ratioVal}) from base ${baseRem}rem. Sample values: ${progression2.slice(0, 5).map((v) => Math.round(v)).join(", ")}...`,
+    description: `Spacing is ${baseSpacingUnit}px x ${progressionRatio} (${ratioVal})^n from position 0, rounded to whole pixels: ${multipliers.length} rungs, ${baseSpacingUnit}px to ${Math.round(baseSpacingUnit * (multipliers[multipliers.length - 1] ?? 1))}px.`,
     generatedAt: timestamp,
     containerQueryAware: false,
     userOverride: null,
@@ -26851,7 +27224,7 @@ function createGeneratorDefs(colorPaletteBases) {
     },
     {
       name: "spacing",
-      generate: (config2) => generateSpacingTokens(config2, DEFAULT_SPACING_MULTIPLIERS)
+      generate: (config2) => generateSpacingTokens(config2, DEFAULT_SPACING_BOUNDS)
     },
     {
       name: "typography",
@@ -26872,7 +27245,7 @@ function createGeneratorDefs(colorPaletteBases) {
     },
     {
       name: "shadow",
-      generate: (config2) => generateShadowTokens(config2, DEFAULT_SHADOW_DEFINITIONS)
+      generate: (config2) => generateShadowTokens(config2, DEFAULT_SHADOW_DEFINITIONS, DEFAULT_SHADOW_BOUNDS)
     },
     {
       name: "depth",
@@ -26884,8 +27257,14 @@ function createGeneratorDefs(colorPaletteBases) {
         config2,
         DEFAULT_DURATION_DEFINITIONS,
         DEFAULT_EASING_DEFINITIONS,
-        DEFAULT_DELAY_DEFINITIONS,
-        DEFAULT_MOTION_SEMANTIC_MAPPINGS
+        DEFAULT_DELAY_NAMESPACE,
+        DEFAULT_EXTENT_NAMESPACE,
+        DEFAULT_PERIOD_NAMESPACE,
+        DEFAULT_MOTION_SEMANTIC_MAPPINGS,
+        DEFAULT_KEYFRAME_DEFINITIONS,
+        DEFAULT_ANIMATION_DEFINITIONS,
+        DEFAULT_MOTION_COMPOSITE_PRESETS,
+        DEFAULT_MOTION_CELL_ANIMATIONS
       )
     },
     {
@@ -26924,7 +27303,10 @@ function generateBaseSystem(config2 = {}) {
 var UserOverrideSchema = external_exports.object({
   previousValue: external_exports.unknown(),
   reason: external_exports.string(),
-  context: external_exports.string().optional()
+  context: external_exports.string().optional(),
+  // Provenance. Optional by design: absent means unknown, which is what every
+  // override written before this field existed actually is.
+  kind: OverrideKindSchema.optional()
 });
 var BindingSchema2 = external_exports.object({
   plugin: external_exports.string(),
@@ -26969,7 +27351,8 @@ var TokenGraph = class {
       userOverride: {
         previousValue: existing?.value,
         reason: options.reason,
-        ...options.context ? { context: options.context } : {}
+        ...options.context ? { context: options.context } : {},
+        ...options.kind ? { kind: options.kind } : {}
       },
       ...existing?.binding ? { binding: existing.binding } : {}
     };
@@ -27535,7 +27918,7 @@ async function regenerateOutputs(registry2, input, hooks2 = {}) {
     written.push("rafters.standalone.css");
   }
   if (exports.documentation) {
-    const doc = await registryToDocumentation(registry2);
+    const doc = await registryToDocumentation(registry2, { contentSources });
     await writeFile(join2(outputDir2, "rafters.documentation.css"), doc);
     written.push("rafters.documentation.css");
   }
@@ -27565,11 +27948,7 @@ var TokenRegistry = class {
       parsed.push(result.data);
     }
     for (const t of parsed) {
-      const override = t.userOverride ? {
-        previousValue: t.userOverride.previousValue,
-        reason: t.userOverride.reason,
-        ...t.userOverride.context ? { context: t.userOverride.context } : {}
-      } : void 0;
+      const override = toNodeOverride(t.userOverride);
       if (t.binding && !override) continue;
       this.graph.seed(t.name, t.value, {
         ...override ? { userOverride: override } : {},
@@ -27593,11 +27972,7 @@ var TokenRegistry = class {
     }
     const t = result.data;
     this.metadata.set(t.name, t);
-    const override = t.userOverride ? {
-      previousValue: t.userOverride.previousValue,
-      reason: t.userOverride.reason,
-      ...t.userOverride.context ? { context: t.userOverride.context } : {}
-    } : void 0;
+    const override = toNodeOverride(t.userOverride);
     if (t.binding && !override) {
       this.graph.bind(t.name, t.binding.plugin, t.binding.input);
     } else {
@@ -27673,6 +28048,15 @@ var TokenParseError = class extends Error {
     this.name = "TokenParseError";
   }
 };
+function toNodeOverride(field) {
+  if (!field) return void 0;
+  return {
+    previousValue: field.previousValue,
+    reason: field.reason,
+    ...field.context ? { context: field.context } : {},
+    ...field.kind ? { kind: field.kind } : {}
+  };
+}
 function toUserOverrideField(override, baseValue) {
   const previousValue = override.previousValue ?? baseValue;
   const result = {
@@ -27680,6 +28064,7 @@ function toUserOverrideField(override, baseValue) {
     reason: override.reason
   };
   if (override.context) result.context = override.context;
+  if (override.kind) result.kind = override.kind;
   return result;
 }
 
@@ -28520,15 +28905,37 @@ function log(event) {
         console.log(`  ${event.suggestion}`);
       }
       break;
-    case "add:complete":
-      context.spinner?.succeed(
-        `Added ${event.installed} component${event.installed !== 1 ? "s" : ""}`
-      );
-      if (event.skipped > 0) {
-        console.log(`  Skipped: ${event.skipped} (use --overwrite to replace)`);
+    case "add:complete": {
+      const written = event.written;
+      const skippedCount = event.skipped;
+      const untrackedCount = event.untracked;
+      const failedCount = event.failed;
+      const headline = `Wrote ${written} item${written !== 1 ? "s" : ""}`;
+      if (failedCount > 0) {
+        context.spinner?.fail(`${headline}, ${failedCount} failed -- see below`);
+      } else {
+        context.spinner?.succeed(headline);
+      }
+      if (skippedCount > 0) {
+        const names = event.skippedComponents ?? [];
+        console.log(
+          `  Skipped: ${skippedCount} (already present; use --update to re-fetch)${names.length > 0 ? ` -- ${names.join(", ")}` : ""}`
+        );
+      }
+      if (untrackedCount > 0) {
+        const names = event.untrackedComponents ?? [];
+        console.log(`  Untracked on disk, now tracked: ${untrackedCount} -- ${names.join(", ")}`);
+      }
+      if (failedCount > 0) {
+        const names = event.failedComponents ?? [];
+        console.log(`  Failed: ${failedCount} -- ${names.join(", ")}`);
       }
       console.log("");
       break;
+    }
+    case "add:untracked":
+      console.log(`  ${event.message}`);
+      break;
     case "add:hint":
       console.log(`
   ${event.message}`);
@@ -28878,6 +29285,51 @@ function resolveReadSet(field, cwd, fallback) {
   return out;
 }
 
+// src/utils/reconcile.ts
+import { readdirSync as readdirSync2 } from "fs";
+var DISCOVERABLE_KINDS = ["components", "primitives", "composites"];
+var KIND_PATHS = {
+  components: { field: "componentsPath", fallback: "components/ui" },
+  primitives: { field: "primitivesPath", fallback: "lib/primitives" },
+  composites: { field: "compositesPath", fallback: "composites" }
+};
+function hasEntryFor(entries, name) {
+  return entries.some((entry) => entry === name || entry.startsWith(`${name}.`));
+}
+function buildUpdateCandidates(tracked, index, entries) {
+  const trackedSet = new Set(tracked);
+  const untracked = /* @__PURE__ */ new Set();
+  if (index) {
+    for (const kind of DISCOVERABLE_KINDS) {
+      for (const name of index[kind]) {
+        if (trackedSet.has(name)) continue;
+        if (hasEntryFor(entries[kind], name)) untracked.add(name);
+      }
+    }
+  }
+  return { tracked: [...trackedSet].sort(), untracked: [...untracked].sort() };
+}
+function readInstallRoots(cwd, config2) {
+  const entries = { components: [], primitives: [], composites: [] };
+  for (const kind of DISCOVERABLE_KINDS) {
+    const { field, fallback } = KIND_PATHS[kind];
+    const configured = config2?.[field];
+    const pathField = isPathField(configured) ? configured : fallback;
+    const names = /* @__PURE__ */ new Set();
+    for (const dir of resolveReadSet(pathField, cwd, fallback)) {
+      try {
+        for (const entry of readdirSync2(dir)) names.add(entry);
+      } catch {
+      }
+    }
+    entries[kind] = [...names];
+  }
+  return entries;
+}
+function isPathField(value) {
+  return typeof value === "string" || Array.isArray(value);
+}
+
 // src/commands/add.ts
 var REGISTRY_PLUGINS = [scalePlugin, contrastPlugin, statePlugin, invertPlugin];
 async function regenerateAfterInstall(cwd, config2) {
@@ -28938,10 +29390,26 @@ function getInstalledNames(config2) {
   const names = /* @__PURE__ */ new Set([
     ...config2.installed.components,
     ...config2.installed.primitives,
-    ...config2.installed.composites ?? []
+    ...config2.installed.composites ?? [],
+    ...config2.installed.rules ?? [],
+    ...config2.installed.substrate ?? []
   ]);
   return [...names].sort();
 }
+async function discoverUntrackedNames(cwd, config2, client, tracked) {
+  let index = null;
+  try {
+    index = await client.fetchIndex();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log({
+      event: "add:warning",
+      message: `Could not read the registry index to reconcile on-disk components (${message}). Updating tracked components only.`
+    });
+  }
+  const { untracked } = buildUpdateCandidates(tracked, index, readInstallRoots(cwd, config2));
+  return untracked;
+}
 function getComponentTarget(config2) {
   return resolveComponentTarget(config2);
 }
@@ -29187,6 +29655,7 @@ async function add(componentArgs, options) {
   if (options.update) {
     options.overwrite = true;
   }
+  let untrackedNames = [];
   if (options.updateAll) {
     options.overwrite = true;
     if (!config2) {
@@ -29194,13 +29663,22 @@ async function add(componentArgs, options) {
       process.exitCode = 1;
       return;
     }
-    const installedNames = getInstalledNames(config2);
-    if (installedNames.length === 0) {
+    const trackedNames = getInstalledNames(config2);
+    untrackedNames = await discoverUntrackedNames(cwd, config2, client, trackedNames);
+    const candidates = [.../* @__PURE__ */ new Set([...trackedNames, ...untrackedNames])].sort();
+    if (candidates.length === 0) {
       error46("No installed components found. Use 'rafters add <component>' to install first.");
       process.exitCode = 1;
       return;
     }
-    components = installedNames;
+    if (untrackedNames.length > 0) {
+      log({
+        event: "add:untracked",
+        components: untrackedNames,
+        message: `Found ${untrackedNames.length} component(s) on disk the config never tracked: ${untrackedNames.join(", ")}. Refreshing and tracking them.`
+      });
+    }
+    components = candidates;
   }
   if (folder === "composites" && components.length === 0) {
     components = ["composites"];
@@ -29251,8 +29729,9 @@ async function add(componentArgs, options) {
       allItems.filter((item) => item.type === "substrate").map((item) => item.files[0]?.path.split("/")[0]).filter((segment) => Boolean(segment))
     )
   ];
-  const installed = [];
+  const written = [];
   const skipped = [];
+  const failed = [];
   const installedItems = [];
   const filteredItems = [];
   const target = getComponentTarget(config2);
@@ -29276,7 +29755,7 @@ async function add(componentArgs, options) {
     try {
       const result = await installItem(cwd, item, options, config2, substrateKinds);
       if (result.installed) {
-        installed.push(item.name);
+        written.push(item.name);
         installedItems.push(item);
         if (item.type === "ui") {
           const selection = selectFilesForFramework(item.files, target);
@@ -29296,6 +29775,7 @@ async function add(componentArgs, options) {
         installedItems.push(item);
       }
     } catch (err) {
+      failed.push(item.name);
       if (err instanceof Error) {
         log({
           event: "add:warning",
@@ -29353,11 +29833,19 @@ async function add(componentArgs, options) {
   }
   log({
     event: "add:complete",
-    installed: installed.length,
+    written: written.length,
     skipped: skipped.length,
-    components: installed
-  });
-  if (skipped.length > 0 && installed.length === 0) {
+    untracked: untrackedNames.length,
+    failed: failed.length,
+    components: written,
+    skippedComponents: skipped,
+    untrackedComponents: untrackedNames,
+    failedComponents: failed
+  });
+  if (failed.length > 0) {
+    process.exitCode = 1;
+  }
+  if (!options.updateAll && skipped.length > 0 && written.length === 0) {
     log({
       event: "add:hint",
       message: "Some components were skipped. Use --update to re-fetch, or --update-all to refresh everything.",
@@ -30240,6 +30728,24 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
+// src/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+var UNKNOWN_VERSION = "0.0.0-unknown";
+function readVersion() {
+  try {
+    const parsed = JSON.parse(
+      readFileSync2(new URL("../package.json", import.meta.url), "utf-8")
+    );
+    if (parsed !== null && typeof parsed === "object" && "version" in parsed) {
+      const { version: version2 } = parsed;
+      if (typeof version2 === "string" && version2.length > 0) return version2;
+    }
+  } catch {
+  }
+  return UNKNOWN_VERSION;
+}
+var VERSION = readVersion();
+
 // src/mcp/tools.ts
 import { readFile as readFile6 } from "fs/promises";
 import { join as join12 } from "path";
@@ -30455,7 +30961,7 @@ async function discoverFromDirs(...directories) {
 }
 
 // src/utils/workspaces.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { basename, dirname as dirname3, join as join11, resolve as resolve4 } from "path";
 
 // src/utils/discover.ts
@@ -30483,14 +30989,14 @@ function findMonorepoRoot(startDir, boundary) {
   for (; ; ) {
     const pnpmWorkspace = join11(current, "pnpm-workspace.yaml");
     if (existsSync6(pnpmWorkspace)) {
-      const patterns = parsePnpmWorkspaceYaml(readFileSync2(pnpmWorkspace, "utf-8"));
+      const patterns = parsePnpmWorkspaceYaml(readFileSync3(pnpmWorkspace, "utf-8"));
       if (patterns.length > 0) {
         return { root: current, patterns };
       }
     }
     const pkgJson = join11(current, "package.json");
     if (existsSync6(pkgJson)) {
-      const patterns = parsePackageJsonWorkspaces(readFileSync2(pkgJson, "utf-8"));
+      const patterns = parsePackageJsonWorkspaces(readFileSync3(pkgJson, "utf-8"));
       if (patterns.length > 0) {
         return { root: current, patterns };
       }
@@ -30546,7 +31052,7 @@ function expandPattern(monorepoRoot, pattern) {
     const parentRel = trimmed.slice(0, -2);
     const parent = join11(monorepoRoot, parentRel);
     if (!existsSync6(parent)) return [];
-    return readdirSync2(parent).map((entry) => join11(parent, entry)).filter((path) => {
+    return readdirSync3(parent).map((entry) => join11(parent, entry)).filter((path) => {
       try {
         return statSync2(path).isDirectory();
       } catch {
@@ -30935,7 +31441,7 @@ async function startMcpServer(workspaces, defaultWorkspace) {
   const server = new Server(
     {
       name: "rafters",
-      version: "0.0.1"
+      version: VERSION
     },
     {
       capabilities: {
@@ -31731,7 +32237,7 @@ async function studio() {
 
 // src/index.ts
 var program = new Command();
-program.name("rafters").description("Design system CLI - scaffold tokens and serve MCP").version("0.0.1");
+program.name("rafters").description("Design system CLI - scaffold tokens and serve MCP").version(VERSION);
 program.command("init").description("Initialize .rafters/ with default tokens and config").option("-r, --rebuild", "Regenerate output files from existing tokens").option("--reset", "Re-run generators fresh, replacing persisted tokens").option(
   "--framework <name>",
   "Override framework detection (next|vite|remix|react-router|astro|wc|vanilla)"