@motion-proto/live-tokens 0.53.0 → 0.54.1

package/.claude/skills/live-tokens-adjust-shape-space/SKILL.md

@@ -11,7 +11,7 @@ You translate the request into a small ops file; the CLI resolves each matching
 
 1. Write the ops file to a temp path (not the project tree), e.g. `/tmp/adjust-ops.json`.
 2. Run `npx live-tokens adjust /tmp/adjust-ops.json`. It writes `component-configs/<id>/_working.json` for every component the ops change, which is the buffer the page already runs. `--dry-run` prints the report without writing.
-3. Read the report card: every changed alias old → new, plus skips (raw value, off the ladder, already at the ladder end, pill preserved). Exit 1 means the run was rejected; the message names the offending op or the missing input, so fix it and re-run.
+3. Read the report card: every changed alias old → new, plus skips (raw value, off the ladder, already at the ladder end, pill preserved). Exit 1 means the run was rejected; the message names the offending op or the missing input, so fix it and re-run. Read where the controls landed, not only that the run succeeded: a button, badge, input, or tab padding sitting at `--space-6` is on its floor, and one that also carries `--radius-full` wants a targeted lift.
 4. Tell the user to reload the app and look. Offer the inverse op as the undo, and say the edit is unsaved until they save the open theme.
 
 Each run reads the LIVE config (buffer, else the open theme, else the shipped default), so "a bit more" and "back one" compound naturally.
@@ -40,7 +40,7 @@ Targeted, absolute:
 
 | Request | Ops |
 |---|---|
-| pill, capsule | radius `set: "--radius-full"` |
+| pill, capsule | radius `set: "--radius-full"`, plus the padding the pill needs (see below) |
 | sharp, square corners | radius `set: "--radius-none"`, or `--radius-sm` for "mostly sharp" |
 | rounded (a named component) | radius `shift: 2` |
 | softer, rounder (global) | radius `shift: 1` to `2`, no `full` |
@@ -52,12 +52,30 @@ Targeted, absolute:
 
 Magnitude words: "slightly" or "a bit" is 1 step, unqualified is 1 to 2, "much", "way", or "really" is 2 to 3. Mood words often mean both axes: "softer" is rounder plus airier, "compact" is tighter padding plus smaller gaps.
 
+## Controls squeeze before containers
+
+A global op spends the same number of steps everywhere, but a step costs a control far more than a container. `padding shift: -2` takes a card from a 16px inset to 10px and it is still a card. It takes a button from 8 to 4, doubled to 8px at each end, around an 18px line. The button stops reading as a button.
+
+So a global compaction is `shift: -1`. When the brief wants more, spend the extra steps on the containers by name (`card`, `dialog`, `panel`, `sidenavigation`, `table`, `codesnippet`) and leave the controls alone. Loosening is not symmetric: airier is safe globally, because nothing breaks by growing.
+
+A pill needs the room most. `--radius-full` bends the corner in over the first and last glyph, so a capsule wants more horizontal inset than a square-cornered control, never less. `--space-8` is the floor for a large-text pill, which is where compact Midnight Study sits; the roomier pill presets (Ocean, Sunset, Royal Velvet) run `--space-10` to `--space-12`. Pair the radius op with a padding `set` on the same target, placed after any global compaction so it wins outright:
+
+```json
+{ "ops": [
+  { "kind": "padding", "shift": -1 },
+  { "target": "button", "kind": "radius", "set": "--radius-full" },
+  { "target": "button", "kind": "padding", "set": "--space-10" }
+] }
+```
+
 ## Ladders
 
 Radius runs `none, sm, md, lg, xl, 2xl, 3xl, 4xl`, with `full` as the gated ninth rung. Space (padding and gap) is the editor picker's subset: `0, 2, 4, 6, 8, 10, 12, 16, 20, 24, 32, 48`, so every written value stays re-editable by hand. Border width is the full `--border-width-*` scale. `set` values must be on the ladder (`--space-64` is rejected).
 
 Content insets stop at `--space-4`. Below it the text sits against its own edge, so `--space-0` and `--space-2` are destinations a person picks on purpose, not ones a relative "tighter" hands you. Both stay available through the editor picker and through `set`. An alias already below the floor still moves up, and a shift that would push one under `--space-4` reports as clamped and writes nothing.
 
+Padding that wraps a line of type stops a rung higher, at `--space-6`. The engine spots it in the config itself: a variant that also declares a `-text-font-size` is holding text, and the components that hold text double their padding horizontally, so `--space-4` there is 4px over an 18px line and 8px at each end. No shipped default puts text below `--space-6`.
+
 The floor guards `-padding` only. Outer space is exempt, because a 2px gap between an icon and its label, or a 2px margin under a bar, is ordinary design rather than a mistake. Note that `-margin` rides the `padding` kind, so a padding op moves margins too; it just does not floor them.
 
 An alias sitting off the subset spends its first step reaching the rung the shift points at, so `--space-2` with `shift: 1` lands on `--space-4` rather than jumping past it.
@@ -70,5 +88,6 @@ Every value written is an existing token; nothing new is minted. `tokens.css`, s
 
 - The CLI exits 0 and the report card lists the changes you expected, with no surprising skips.
 - The app (dev server running) shows the new shape on each changed component after a reload.
+- Buttons still read as buttons: the label has room at both ends, and a pill has more of it than a square-cornered control had.
 - `component-configs/<id>/_working.json` exists for every component the report listed. That buffer is the whole change: it stays until the open theme is saved or another theme is loaded.
 - To revert, run the inverse ops, or load a theme in the Theme panel to discard every unsaved edit.

package/.claude/skills/live-tokens-generate-theme/SKILL.md

@@ -130,6 +130,21 @@ A sky needs a committed canvas: when the Canvas seed anchors at the ramp edge
 side and the engine skips the sky, saying so in the report. An atmospheric
 brief that wants one should already be at canvas commitment level 2–3.
 
+## Shadow weight follows the canvas
+
+The engine sets the opacity of the `--shadow-*` scale from the Canvas seed's
+lightness and carries each shadow's geometry and color through untouched. A
+near-black shadow at 0.9 opacity is what a dark ground needs to show any
+shadow at all, and it punches a hole in paper, so opacity holds at 0.9 up to
+canvas L 0.5 and eases to 0.2 by L 0.9. There is nothing to choose: the report
+prints the derived value, and every regeneration re-derives it, so a brief
+iterated from a light canvas to a dark one gets its weight back.
+
+When the user says the shadows read heavy, muddy, or dirty, the canvas is the
+lever. Raise the Canvas seed's lightness and the shadows lighten with it. A
+one-off override lives in the editor's Shadows tab and survives regeneration
+in everything except opacity.
+
 ## Named themes (canonical OKLCH anchors)
 
 Holiday briefs are statement briefs — default to commitment level 2–3 above, not cream. The named colors go on the *ground*, not just the buttons.
@@ -143,7 +158,7 @@ Holiday briefs are statement briefs — default to commitment level 2–3 above,
 
 ## Scope
 
-Fonts are never touched (they carry forward from the live look, as do shadows and component aliases). Swatch gradients (`--gradient-1..4`) carry forward when user-tuned; if they are absent or still stock, the engine rebuilds them from the new theme's families — you never author them. Radius is out of scope for generation. Shipping the theme stays a human action: Adopt, in the editor.
+Fonts are never touched (they carry forward from the live look, as do component aliases and shadow geometry; shadow opacity is derived, see above). Swatch gradients (`--gradient-1..4`) carry forward when user-tuned; if they are absent or still stock, the engine rebuilds them from the new theme's families — you never author them. Radius is out of scope for generation. Shipping the theme stays a human action: Adopt, in the editor.
 
 ## Verify
 

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.54.1 — Palette editing opens on a curve
+
+### Changed
+
+- **The base-color panel opens with the rest of the palette editor.** The panel
+  above the swatch grid appeared and vanished in one frame while the swatch
+  grid and the derived row animated, so opening a base color read as a jump. It
+  now reveals on the same height transition as its neighbours.
+
+- **The floating token pills read as polished chrome.** The gradient was tuned
+  against a dark ground and sat too low in the scale for a light page, where it
+  looked tarnished. The bands keep their spacing and move up the scale, the
+  border becomes a dark hairline, and the strings drop to 0.3 opacity on light
+  pages, where a black stroke at 0.5 reads far heavier than the white stroke it
+  mirrors. The darkest stop stays at `#8f9090`, so the black label keeps AA.
+
+- **The demo hero labels its theme picker.** The trigger showed the open
+  theme's name with nothing saying what it picked. A "Theme" label sits above
+  it, and the actions row bottom-aligns so the picker and the buttons sit on
+  one line.
+
+## 0.54.0 — Shadow weight and text insets follow their context
+
+### Fixed
+
+- **Padding that holds text stops at `--space-6`.** One floor for every inset
+  treated a card and a button alike, but the components that hold text double
+  their padding horizontally, so `--space-4` on a button is 4px over an 18px
+  line and 8px at each end. `adjust` now reads which floor applies off the
+  config itself: a variant that also declares a `-text-font-size` is holding
+  type. Containers keep the `--space-4` floor, `-margin` and `-gap` stay
+  exempt, and both rungs stay reachable by `set` and by the editor picker.
+  Midnight Study shipped with every text inset on the old floor, its pill
+  buttons worst of all; its controls move up, and the six full-size button
+  variants to `--space-8` so the capsule has room for its label.
+
+### Changed
+
+- **Shadow weight follows the canvas.** The `--shadow-*` scale was one fixed
+  near-black at 0.9 opacity in every theme, which is what a dark ground needs
+  and what puts a smudge under every card on a light one. `generate-theme` now
+  derives the opacity from the Canvas seed's lightness: 0.9 holds up to L 0.5
+  and eases to 0.2 by L 0.9. Geometry and color carry forward untouched, so a
+  hand-tuned elevation ramp survives regeneration. The three light presets
+  (Ocean, Spring Meadow, Autumn) ship with the derived values; the dark presets
+  and the default theme are unchanged.
+
 ## 0.53.0 — Themes are complete documents
 
 ### Fixed

package/bin/generate-theme.mjs

@@ -241,6 +241,7 @@ export function formatGenerateThemeResult(result) {
       ? '\nGradients: kept your tuned swatch gradients.'
       : '\nGradients: swatch tokens rebuilt from the theme families.',
   );
+  lines.push(`Shadows: ${result.report.shadows}; carried geometry kept.`);
   if (result.report.canvasGradient) {
     lines.push(`Canvas sky: ${result.report.canvasGradient}.`);
   }

package/dist-plugin/adjust/index.cjs

@@ -102,6 +102,7 @@ var SPACE_SETTABLE = [
 ];
 var SPACE_RUNGS = SPACE_SETTABLE;
 var INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf("--space-4"));
+var TEXT_INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf("--space-6"));
 var SPACE_FAMILY = [...SPACE_SETTABLE, "--space-40", "--space-64", "--space-96", "--space-128"];
 var BORDER_WIDTH_RUNGS = [
   "--border-width-0",
@@ -133,10 +134,13 @@ var LADDERS = {
   }
 };
 var TOKEN_NAME = /^--[a-z0-9-]+$/;
-function rungsFor(op, variable) {
+function rungsFor(op, variable, aliases) {
   if (op.kind === "radius") return op.full ? [...RADIUS_RUNGS, RADIUS_FULL] : RADIUS_RUNGS;
-  if (op.kind === "padding" && stripSide(variable).endsWith("-padding")) return INSET_RUNGS;
-  return LADDERS[op.kind].rungs;
+  if (op.kind !== "padding") return LADDERS[op.kind].rungs;
+  const base = stripSide(variable);
+  if (!base.endsWith("-padding")) return LADDERS.padding.rungs;
+  const variant = base.slice(0, -"-padding".length);
+  return `${variant}-text-font-size` in aliases ? TEXT_INSET_RUNGS : INSET_RUNGS;
 }
 function spaceStep(token) {
   return Number(token.slice("--space-".length));
@@ -149,11 +153,11 @@ function snapRung(token, rungs, direction) {
   }
   return -1;
 }
-function resolve(op, variable, value) {
+function resolve(op, variable, value, aliases) {
   if (typeof value !== "string" || !TOKEN_NAME.test(value)) return { skip: "raw-value" };
   if (!LADDERS[op.kind].family.includes(value)) return { skip: "off-ladder" };
   if (op.set !== void 0) return { from: value, to: op.set };
-  const rungs = rungsFor(op, variable);
+  const rungs = rungsFor(op, variable, aliases);
   let index = rungs.indexOf(value);
   let shift = op.shift;
   if (index < 0) {
@@ -206,7 +210,7 @@ function adjustAliases(configs, ops, now) {
       let changed = false;
       for (const [variable, value] of Object.entries(config.aliases)) {
         if (!matchesKind(variable, op.kind)) continue;
-        const outcome = resolve(op, variable, value);
+        const outcome = resolve(op, variable, value, config.aliases);
         if ("skip" in outcome) {
           reportFor(component).skips.push({ variable, value, reason: outcome.skip });
           continue;

package/dist-plugin/adjust/index.js

@@ -70,6 +70,7 @@ var SPACE_SETTABLE = [
 ];
 var SPACE_RUNGS = SPACE_SETTABLE;
 var INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf("--space-4"));
+var TEXT_INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf("--space-6"));
 var SPACE_FAMILY = [...SPACE_SETTABLE, "--space-40", "--space-64", "--space-96", "--space-128"];
 var BORDER_WIDTH_RUNGS = [
   "--border-width-0",
@@ -101,10 +102,13 @@ var LADDERS = {
   }
 };
 var TOKEN_NAME = /^--[a-z0-9-]+$/;
-function rungsFor(op, variable) {
+function rungsFor(op, variable, aliases) {
   if (op.kind === "radius") return op.full ? [...RADIUS_RUNGS, RADIUS_FULL] : RADIUS_RUNGS;
-  if (op.kind === "padding" && stripSide(variable).endsWith("-padding")) return INSET_RUNGS;
-  return LADDERS[op.kind].rungs;
+  if (op.kind !== "padding") return LADDERS[op.kind].rungs;
+  const base = stripSide(variable);
+  if (!base.endsWith("-padding")) return LADDERS.padding.rungs;
+  const variant = base.slice(0, -"-padding".length);
+  return `${variant}-text-font-size` in aliases ? TEXT_INSET_RUNGS : INSET_RUNGS;
 }
 function spaceStep(token) {
   return Number(token.slice("--space-".length));
@@ -117,11 +121,11 @@ function snapRung(token, rungs, direction) {
   }
   return -1;
 }
-function resolve(op, variable, value) {
+function resolve(op, variable, value, aliases) {
   if (typeof value !== "string" || !TOKEN_NAME.test(value)) return { skip: "raw-value" };
   if (!LADDERS[op.kind].family.includes(value)) return { skip: "off-ladder" };
   if (op.set !== void 0) return { from: value, to: op.set };
-  const rungs = rungsFor(op, variable);
+  const rungs = rungsFor(op, variable, aliases);
   let index = rungs.indexOf(value);
   let shift = op.shift;
   if (index < 0) {
@@ -174,7 +178,7 @@ function adjustAliases(configs, ops, now) {
       let changed = false;
       for (const [variable, value] of Object.entries(config.aliases)) {
         if (!matchesKind(variable, op.kind)) continue;
-        const outcome = resolve(op, variable, value);
+        const outcome = resolve(op, variable, value, config.aliases);
         if ("skip" in outcome) {
           reportFor(component).skips.push({ variable, value, reason: outcome.skip });
           continue;

package/dist-plugin/generateColorsAndType/index.cjs

@@ -691,6 +691,39 @@ function makeDefaultGradients() {
   ];
 }
 
+// src/editor/core/themes/parsers/shadow.ts
+var SHADOW_VAR_NAMES = [
+  "--shadow-sm",
+  "--shadow-md",
+  "--shadow-lg",
+  "--shadow-xl",
+  "--shadow-2xl"
+];
+function computeAngleDistance(x, y) {
+  const distance = Math.round(Math.sqrt(x * x + y * y));
+  if (distance === 0) return { angle: 135, distance: 0 };
+  let angle = Math.atan2(y, -x) * (180 / Math.PI);
+  if (angle < 0) angle += 360;
+  return { angle: Math.round(angle), distance };
+}
+function shadowTokenCss(t) {
+  return `${t.x}px ${t.y}px ${t.blur}px ${t.spread}px hsla(${t.hue}, ${t.saturation}%, ${t.lightness}%, ${t.opacity})`;
+}
+function parseShadowCss(variable, raw) {
+  const m = raw.trim().match(/^(-?\d+)px\s+(-?\d+)px\s+(\d+)px\s+(-?\d+)px\s+hsla\(([\d.]+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)$/);
+  if (!m) return null;
+  const x = parseInt(m[1], 10);
+  const y = parseInt(m[2], 10);
+  const blur = parseInt(m[3], 10);
+  const spread = parseInt(m[4], 10);
+  const hue = Math.round(parseFloat(m[5]));
+  const saturation = Math.round(parseFloat(m[6]));
+  const lightness = Math.round(parseFloat(m[7]));
+  const opacity = parseFloat(m[8]);
+  const { angle, distance } = computeAngleDistance(x, y);
+  return { variable, x, y, blur, spread, opacity, hue, saturation, lightness, angle, distance };
+}
+
 // src/editor/core/palettes/contrast.ts
 var AA_BODY = 4.5;
 var AA_LARGE = 3;
@@ -1760,6 +1793,34 @@ function applyCanvasGradient(canvas, scheme) {
   canvas.gradientSize = "window";
   return `on, ${labels[sky]} \u2192 ${labels[anchor]}`;
 }
+var STOCK_SHADOW_GEOMETRY = {
+  "--shadow-sm": [1, 1, 2],
+  "--shadow-md": [3, 3, 6],
+  "--shadow-lg": [5, 5, 9],
+  "--shadow-xl": [6, 7, 13],
+  "--shadow-2xl": [8, 9, 16]
+};
+var STOCK_SHADOW_COLOR = { spread: 0, hue: 237, saturation: 18, lightness: 3, opacity: 0.9 };
+var SHADOW_OPACITY_DEEP = 0.9;
+var SHADOW_OPACITY_SOFT = 0.2;
+var SHADOW_GROUND_DEEP = 0.5;
+var SHADOW_GROUND_SOFT = 0.9;
+function shadowOpacityForCanvas(canvasL) {
+  const t = (canvasL - SHADOW_GROUND_DEEP) / (SHADOW_GROUND_SOFT - SHADOW_GROUND_DEEP);
+  const ramp = Math.max(0, Math.min(1, t));
+  const opacity = SHADOW_OPACITY_DEEP + ramp * (SHADOW_OPACITY_SOFT - SHADOW_OPACITY_DEEP);
+  return Math.round(opacity * 100) / 100;
+}
+function shadowVars(carried, canvas) {
+  const opacity = shadowOpacityForCanvas(canvas.l);
+  const out = {};
+  for (const variable of SHADOW_VAR_NAMES) {
+    const [x, y, blur] = STOCK_SHADOW_GEOMETRY[variable];
+    const base = parseShadowCss(variable, carried[variable] ?? "") ?? { x, y, blur, ...STOCK_SHADOW_COLOR };
+    out[variable] = shadowTokenCss({ ...base, opacity });
+  }
+  return out;
+}
 function buildColorsAndTypeFromSeeds(brief, carry = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
   const { seeds, slug } = validateBrief(brief);
   const configs = {};
@@ -1784,6 +1845,7 @@ function buildColorsAndTypeFromSeeds(brief, carry = {}, now = (/* @__PURE__ */ n
     Object.entries(carry.cssVariables ?? {}).filter(([k]) => !owned.has(k))
   );
   for (const t of gradients) cssVariables[t.variable] = formatGradientValue(t);
+  Object.assign(cssVariables, shadowVars(carry.cssVariables ?? {}, seeds.Canvas));
   const colorsAndType = {
     name: brief.name.trim(),
     createdAt: now,
@@ -1802,6 +1864,7 @@ function buildColorsAndTypeFromSeeds(brief, carry = {}, now = (/* @__PURE__ */ n
     report: {
       ...report,
       gradients: gradients === carry.gradients ? "carried" : "recipes",
+      shadows: `opacity ${shadowOpacityForCanvas(seeds.Canvas.l)} for a canvas at L ${seeds.Canvas.l.toFixed(2)}`,
       ...canvasGradient ? { canvasGradient } : {}
     }
   };

package/dist-plugin/generateColorsAndType/index.d.cts

@@ -41,7 +41,8 @@ interface ColorsAndTypeBrief {
     canvasGradient?: boolean;
 }
 /** Non-color content carried forward from the currently active colors and type
- *  so gradients, shadows, component aliases, and fonts survive regeneration. */
+ *  so gradients, shadow geometry, component aliases, and fonts survive
+ *  regeneration. Shadow opacity is derived, not carried — see `shadowVars`. */
 interface CarryForward {
     cssVariables?: Record<string, string>;
     fontSources?: FontSource[];
@@ -68,6 +69,8 @@ interface GenerateColorsAndTypeReport {
      *  'on, <sky> → <anchor>' or a 'skipped — …' explanation when the Canvas
      *  anchors at the ramp edge and leaves no room. */
     canvasGradient?: string;
+    /** The derived shadow opacity and the canvas lightness it came from. */
+    shadows: string;
 }
 interface GenerateColorsAndTypeResult {
     colorsAndType: ColorsAndType;

package/dist-plugin/generateColorsAndType/index.d.ts

@@ -41,7 +41,8 @@ interface ColorsAndTypeBrief {
     canvasGradient?: boolean;
 }
 /** Non-color content carried forward from the currently active colors and type
- *  so gradients, shadows, component aliases, and fonts survive regeneration. */
+ *  so gradients, shadow geometry, component aliases, and fonts survive
+ *  regeneration. Shadow opacity is derived, not carried — see `shadowVars`. */
 interface CarryForward {
     cssVariables?: Record<string, string>;
     fontSources?: FontSource[];
@@ -68,6 +69,8 @@ interface GenerateColorsAndTypeReport {
      *  'on, <sky> → <anchor>' or a 'skipped — …' explanation when the Canvas
      *  anchors at the ramp edge and leaves no room. */
     canvasGradient?: string;
+    /** The derived shadow opacity and the canvas lightness it came from. */
+    shadows: string;
 }
 interface GenerateColorsAndTypeResult {
     colorsAndType: ColorsAndType;

package/dist-plugin/generateColorsAndType/index.js

@@ -86,6 +86,39 @@ function makeDefaultGradients() {
   ];
 }
 
+// src/editor/core/themes/parsers/shadow.ts
+var SHADOW_VAR_NAMES = [
+  "--shadow-sm",
+  "--shadow-md",
+  "--shadow-lg",
+  "--shadow-xl",
+  "--shadow-2xl"
+];
+function computeAngleDistance(x, y) {
+  const distance = Math.round(Math.sqrt(x * x + y * y));
+  if (distance === 0) return { angle: 135, distance: 0 };
+  let angle = Math.atan2(y, -x) * (180 / Math.PI);
+  if (angle < 0) angle += 360;
+  return { angle: Math.round(angle), distance };
+}
+function shadowTokenCss(t) {
+  return `${t.x}px ${t.y}px ${t.blur}px ${t.spread}px hsla(${t.hue}, ${t.saturation}%, ${t.lightness}%, ${t.opacity})`;
+}
+function parseShadowCss(variable, raw) {
+  const m = raw.trim().match(/^(-?\d+)px\s+(-?\d+)px\s+(\d+)px\s+(-?\d+)px\s+hsla\(([\d.]+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)$/);
+  if (!m) return null;
+  const x = parseInt(m[1], 10);
+  const y = parseInt(m[2], 10);
+  const blur = parseInt(m[3], 10);
+  const spread = parseInt(m[4], 10);
+  const hue = Math.round(parseFloat(m[5]));
+  const saturation = Math.round(parseFloat(m[6]));
+  const lightness = Math.round(parseFloat(m[7]));
+  const opacity = parseFloat(m[8]);
+  const { angle, distance } = computeAngleDistance(x, y);
+  return { variable, x, y, blur, spread, opacity, hue, saturation, lightness, angle, distance };
+}
+
 // src/editor/core/palettes/contrast.ts
 var AA_BODY = 4.5;
 var AA_LARGE = 3;
@@ -410,6 +443,34 @@ function applyCanvasGradient(canvas, scheme) {
   canvas.gradientSize = "window";
   return `on, ${labels[sky]} \u2192 ${labels[anchor]}`;
 }
+var STOCK_SHADOW_GEOMETRY = {
+  "--shadow-sm": [1, 1, 2],
+  "--shadow-md": [3, 3, 6],
+  "--shadow-lg": [5, 5, 9],
+  "--shadow-xl": [6, 7, 13],
+  "--shadow-2xl": [8, 9, 16]
+};
+var STOCK_SHADOW_COLOR = { spread: 0, hue: 237, saturation: 18, lightness: 3, opacity: 0.9 };
+var SHADOW_OPACITY_DEEP = 0.9;
+var SHADOW_OPACITY_SOFT = 0.2;
+var SHADOW_GROUND_DEEP = 0.5;
+var SHADOW_GROUND_SOFT = 0.9;
+function shadowOpacityForCanvas(canvasL) {
+  const t = (canvasL - SHADOW_GROUND_DEEP) / (SHADOW_GROUND_SOFT - SHADOW_GROUND_DEEP);
+  const ramp = Math.max(0, Math.min(1, t));
+  const opacity = SHADOW_OPACITY_DEEP + ramp * (SHADOW_OPACITY_SOFT - SHADOW_OPACITY_DEEP);
+  return Math.round(opacity * 100) / 100;
+}
+function shadowVars(carried, canvas) {
+  const opacity = shadowOpacityForCanvas(canvas.l);
+  const out = {};
+  for (const variable of SHADOW_VAR_NAMES) {
+    const [x, y, blur] = STOCK_SHADOW_GEOMETRY[variable];
+    const base = parseShadowCss(variable, carried[variable] ?? "") ?? { x, y, blur, ...STOCK_SHADOW_COLOR };
+    out[variable] = shadowTokenCss({ ...base, opacity });
+  }
+  return out;
+}
 function buildColorsAndTypeFromSeeds(brief, carry = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
   const { seeds, slug } = validateBrief(brief);
   const configs = {};
@@ -434,6 +495,7 @@ function buildColorsAndTypeFromSeeds(brief, carry = {}, now = (/* @__PURE__ */ n
     Object.entries(carry.cssVariables ?? {}).filter(([k]) => !owned.has(k))
   );
   for (const t of gradients) cssVariables[t.variable] = formatGradientValue(t);
+  Object.assign(cssVariables, shadowVars(carry.cssVariables ?? {}, seeds.Canvas));
   const colorsAndType = {
     name: brief.name.trim(),
     createdAt: now,
@@ -452,6 +514,7 @@ function buildColorsAndTypeFromSeeds(brief, carry = {}, now = (/* @__PURE__ */ n
     report: {
       ...report,
       gradients: gradients === carry.gradients ? "carried" : "recipes",
+      shadows: `opacity ${shadowOpacityForCanvas(seeds.Canvas.l)} for a canvas at L ${seeds.Canvas.l.toFixed(2)}`,
       ...canvasGradient ? { canvasGradient } : {}
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motion-proto/live-tokens",
-  "version": "0.53.0",
+  "version": "0.54.1",
   "type": "module",
   "description": "Design token editor with live CSS variable editing. Svelte 5 + Vite 8.",
   "keywords": [

package/src/editor/core/components/adjustAliases.ts

@@ -66,6 +66,12 @@ const SPACE_RUNGS = SPACE_SETTABLE;
     rungs stay pickable by hand and settable by name. */
 const INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf('--space-4'));
 
+/** Padding that wraps a line of type stops a rung higher. Those components
+    double it horizontally (`themed-padding($h: 2)`), so `--space-4` is 4px
+    over an 18px line and 8px inside a pill's own corner: squeezed rather than
+    compact. No shipped default puts text below `--space-6`. */
+const TEXT_INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf('--space-6'));
+
 const SPACE_FAMILY = [...SPACE_SETTABLE, '--space-40', '--space-64', '--space-96', '--space-128'];
 
 const BORDER_WIDTH_RUNGS = [
@@ -95,11 +101,16 @@ const TOKEN_NAME = /^--[a-z0-9-]+$/;
 type Outcome = { from: string; to: string } | { skip: SkipReason };
 
 /** `-margin` shares the padding kind, so the inset floor keys off the variable
-    rather than the kind. */
-function rungsFor(op: AdjustOp, variable: string): string[] {
+    rather than the kind. Which floor depends on what the padding surrounds,
+    and the config says so itself: a variant that also declares a
+    `-text-font-size` is holding type. */
+function rungsFor(op: AdjustOp, variable: string, aliases: ComponentConfig['aliases']): string[] {
   if (op.kind === 'radius') return op.full ? [...RADIUS_RUNGS, RADIUS_FULL] : RADIUS_RUNGS;
-  if (op.kind === 'padding' && stripSide(variable).endsWith('-padding')) return INSET_RUNGS;
-  return LADDERS[op.kind].rungs;
+  if (op.kind !== 'padding') return LADDERS[op.kind].rungs;
+  const base = stripSide(variable);
+  if (!base.endsWith('-padding')) return LADDERS.padding.rungs;
+  const variant = base.slice(0, -'-padding'.length);
+  return `${variant}-text-font-size` in aliases ? TEXT_INSET_RUNGS : INSET_RUNGS;
 }
 
 function spaceStep(token: string): number {
@@ -119,12 +130,17 @@ function snapRung(token: string, rungs: string[], direction: number): number {
   return -1;
 }
 
-function resolve(op: AdjustOp, variable: string, value: AliasDiskValue): Outcome {
+function resolve(
+  op: AdjustOp,
+  variable: string,
+  value: AliasDiskValue,
+  aliases: ComponentConfig['aliases'],
+): Outcome {
   if (typeof value !== 'string' || !TOKEN_NAME.test(value)) return { skip: 'raw-value' };
   if (!LADDERS[op.kind].family.includes(value)) return { skip: 'off-ladder' };
   if (op.set !== undefined) return { from: value, to: op.set };
 
-  const rungs = rungsFor(op, variable);
+  const rungs = rungsFor(op, variable, aliases);
   let index = rungs.indexOf(value);
   let shift = op.shift!;
   if (index < 0) {
@@ -188,7 +204,7 @@ export function adjustAliases(
 
       for (const [variable, value] of Object.entries(config.aliases)) {
         if (!matchesKind(variable, op.kind)) continue;
-        const outcome = resolve(op, variable, value);
+        const outcome = resolve(op, variable, value, config.aliases);
         if ('skip' in outcome) {
           reportFor(component).skips.push({ variable, value, reason: outcome.skip });
           continue;

package/src/editor/core/themes/generateColorsAndType.ts

@@ -18,6 +18,7 @@ import {
   setCurveAnchor,
 } from '../palettes/paletteDerivation';
 import { formatGradientValue, makeDefaultGradients } from './slices/gradients';
+import { SHADOW_VAR_NAMES, parseShadowCss, shadowTokenCss } from './parsers/shadow';
 import { AA_BODY, AA_LARGE, contrastRatio, findLForContrast } from '../palettes/contrast';
 import { type HarmonyAxis, type HarmonyMode } from '../palettes/colorHarmony';
 import { defaultPaletteConfig } from '../../ui/palette/paletteMath';
@@ -39,7 +40,8 @@ export interface ColorsAndTypeBrief {
 }
 
 /** Non-color content carried forward from the currently active colors and type
- *  so gradients, shadows, component aliases, and fonts survive regeneration. */
+ *  so gradients, shadow geometry, component aliases, and fonts survive
+ *  regeneration. Shadow opacity is derived, not carried — see `shadowVars`. */
 export interface CarryForward {
   cssVariables?: Record<string, string>;
   fontSources?: FontSource[];
@@ -68,6 +70,8 @@ export interface GenerateColorsAndTypeReport {
    *  'on, <sky> → <anchor>' or a 'skipped — …' explanation when the Canvas
    *  anchors at the ramp edge and leaves no room. */
   canvasGradient?: string;
+  /** The derived shadow opacity and the canvas lightness it came from. */
+  shadows: string;
 }
 
 export interface GenerateColorsAndTypeResult {
@@ -377,6 +381,49 @@ function applyCanvasGradient(canvas: PaletteConfig, scheme: SchemeDirection): st
   return `on, ${labels[sky]} → ${labels[anchor]}`;
 }
 
+/** The tokens.css scale, the starting point when a theme carries no shadows.
+ *  Geometry per step; every step shares one color. */
+const STOCK_SHADOW_GEOMETRY: Record<(typeof SHADOW_VAR_NAMES)[number], readonly [number, number, number]> = {
+  '--shadow-sm': [1, 1, 2],
+  '--shadow-md': [3, 3, 6],
+  '--shadow-lg': [5, 5, 9],
+  '--shadow-xl': [6, 7, 13],
+  '--shadow-2xl': [8, 9, 16],
+};
+const STOCK_SHADOW_COLOR = { spread: 0, hue: 237, saturation: 18, lightness: 3, opacity: 0.9 };
+
+/** A near-black shadow needs 0.9 to read at all against a dark ground, and at
+ *  0.9 it punches a hole in a light one. Opacity therefore rides the canvas:
+ *  full weight up to DEEP, easing to SOFT by the time the page is paper. */
+const SHADOW_OPACITY_DEEP = 0.9;
+const SHADOW_OPACITY_SOFT = 0.2;
+const SHADOW_GROUND_DEEP = 0.5;
+const SHADOW_GROUND_SOFT = 0.9;
+
+export function shadowOpacityForCanvas(canvasL: number): number {
+  const t = (canvasL - SHADOW_GROUND_DEEP) / (SHADOW_GROUND_SOFT - SHADOW_GROUND_DEEP);
+  const ramp = Math.max(0, Math.min(1, t));
+  const opacity = SHADOW_OPACITY_DEEP + ramp * (SHADOW_OPACITY_SOFT - SHADOW_OPACITY_DEEP);
+  return Math.round(opacity * 100) / 100;
+}
+
+/** Recolor the scale for this canvas: carried geometry and color ride through
+ *  (elevation shape belongs to the shape pass), opacity is replaced. Replaced
+ *  rather than kept-when-untouched, because a brief iterated from a light
+ *  canvas to a dark one would otherwise hold a shadow too faint to see. The
+ *  Canvas seed is the page background verbatim, so it is the ground the
+ *  shadow falls on. */
+function shadowVars(carried: Record<string, string>, canvas: Oklch): Record<string, string> {
+  const opacity = shadowOpacityForCanvas(canvas.l);
+  const out: Record<string, string> = {};
+  for (const variable of SHADOW_VAR_NAMES) {
+    const [x, y, blur] = STOCK_SHADOW_GEOMETRY[variable];
+    const base = parseShadowCss(variable, carried[variable] ?? '') ?? { x, y, blur, ...STOCK_SHADOW_COLOR };
+    out[variable] = shadowTokenCss({ ...base, opacity });
+  }
+  return out;
+}
+
 export function buildColorsAndTypeFromSeeds(
   brief: ColorsAndTypeBrief,
   carry: CarryForward = {},
@@ -417,6 +464,7 @@ export function buildColorsAndTypeFromSeeds(
   );
   // Rendered projections of the structured gradients, kept for production CSS.
   for (const t of gradients) cssVariables[t.variable] = formatGradientValue(t);
+  Object.assign(cssVariables, shadowVars(carry.cssVariables ?? {}, seeds.Canvas));
 
   const colorsAndType: ColorsAndType = {
     name: brief.name.trim(),
@@ -437,6 +485,7 @@ export function buildColorsAndTypeFromSeeds(
     report: {
       ...report,
       gradients: gradients === carry.gradients ? 'carried' : 'recipes',
+      shadows: `opacity ${shadowOpacityForCanvas(seeds.Canvas.l)} for a canvas at L ${seeds.Canvas.l.toFixed(2)}`,
       ...(canvasGradient ? { canvasGradient } : {}),
     },
   };