@motion-proto/live-tokens 0.61.0 → 0.62.0

package/src/editor/core/sketch/maskField.ts

@@ -8,9 +8,13 @@
  * narrow band around its own midpoint (about 0.24 to 0.77 for fractal noise,
  * whatever the octaves), so a dial that walks a cut across 0 to 1 spends most
  * of its travel outside the field entirely and the little that lands inside
- * comes out as one flat mid-grey. Generated here, the tile is stretched onto
- * its own measured range before any dial sees it, so Min and Max always have
- * the whole field to work with and always read as levels.
+ * comes out as one flat mid-grey.
+ *
+ * Generated here, the tile is auto-levelled before any dial sees it, and the
+ * dials that follow are a levels control: Steps quantises the field, Output
+ * squeezes it into the density range the mask paints between. Neither ever
+ * clips: the field arrives running black to white and every tone survives to
+ * the other end in the order it started.
  *
  * Everything is integer maths on a Float32Array with no DOM, so what a test
  * asserts is what the browser paints.
@@ -29,7 +33,7 @@ const SAMPLE_PX = 2;
 const RASTER = MASK_TILE / SAMPLE_PX;
 
 /** The stage previews, in the order the field is built. */
-export type MaskStage = 'noise' | 'output' | 'blur';
+export type MaskStage = 'noise' | 'levels' | 'blur';
 
 /* ---------------------------------------------------------------- noise --- */
 
@@ -128,41 +132,55 @@ function rawField(s: SketchSettings, seed: number, raster: number, cells: number
       out[y * raster + x] = sum / weightSum;
     }
   }
-  return normalise(out);
+  return equalise(out);
 }
 
+const BINS = 4096;
+
 /**
- * Stretch the field onto 0..1 by its own 0.5th and 99.5th percentiles.
+ * Auto levels: map the field through its own cumulative distribution, so tone
+ * is spread evenly from black to white whatever the noise underneath.
  *
- * This is the difference between levels that work and a grey wash. Noise of any
- * kind piles up around its middle, and how far it reaches depends on the grain
- * and the octave count, so a fixed range would be wrong for every setting but
- * one. Measured per tile, Min and Max always address a field that runs black to
- * white, and the two dials mean the same thing at every other setting.
+ * A black-and-white-point stretch is not enough on its own. Noise piles up
+ * around its middle and the veined fold piles it up at the bottom — half a
+ * one-layer veined tile sits under 0.29 — so a tile stretched by its extremes
+ * still reads as one dark wash, and every dial downstream cuts the range at
+ * points most of the field is nowhere near. Equalised, the median lands at 0.5
+ * and each fifth of the range holds a fifth of the tile, so a handle at 30
+ * addresses the darkest 30% of the field at every grain and octave count.
  *
- * The percentiles rather than the extremes, so one freak pixel cannot flatten
- * the rest of the tile.
+ * Piecewise-linear through a histogram rather than by rank, so the mapping
+ * stays smooth and cannot band a gradient it is meant to spread.
  */
-function normalise(f: Float32Array): Float32Array {
-  const sorted = Float32Array.from(f).sort();
-  const lo = sorted[Math.floor(0.005 * (sorted.length - 1))];
-  const hi = sorted[Math.ceil(0.995 * (sorted.length - 1))];
+function equalise(f: Float32Array): Float32Array {
+  let lo = Infinity, hi = -Infinity;
+  for (const v of f) { if (v < lo) lo = v; if (v > hi) hi = v; }
   const span = hi - lo;
   if (span <= 1e-6) return f.fill(0.5);
-  for (let i = 0; i < f.length; i++) f[i] = Math.min(1, Math.max(0, (f[i] - lo) / span));
+
+  const count = new Float64Array(BINS);
+  for (const v of f) count[Math.min(BINS - 1, Math.floor(((v - lo) / span) * BINS))]++;
+  const below = new Float64Array(BINS + 1);
+  for (let b = 0; b < BINS; b++) below[b + 1] = below[b] + count[b];
+
+  for (let i = 0; i < f.length; i++) {
+    const t = ((f[i] - lo) / span) * BINS;
+    const b = Math.min(BINS - 1, Math.floor(t));
+    f[i] = (below[b] + (t - b) * count[b]) / f.length;
+  }
   return f;
 }
 
 /* ------------------------------------------------------------- levelling --- */
 
-/** Output levels. The field is stretched into the gap between the handles, so
-    the pair states the range the mask paints: nothing is barer than Min or
-    denser than Max, and the field keeps its own shape in between.
+/** Output levels, the same squeeze Photoshop's output handles apply. The whole
+    field is stretched into the gap between them, so the pair states the range
+    the mask paints: nothing is barer than Min or denser than Max, and every
+    tone in between keeps its place in the order.
 
-    Clamping instead makes Min the value most of the field sits AT rather than
-    its rare floor, because the field arrives centred on its own middle: half of
-    it is below 0.5, so a floor of 0.6 piles that half onto 0.6 and the fill
-    comes out a flat wash at the floor with a thin bright tail above it. */
+    Never a cut. Clipping to the handles instead would make Min the value most
+    of the field sits AT rather than its floor, and the fill would come out a
+    flat wash at the floor with a thin bright tail above it. */
 function applyOutput(f: Float32Array, min: number, max: number): Float32Array {
   const span = max - min;
   for (let i = 0; i < f.length; i++) f[i] = min + f[i] * span;
@@ -178,14 +196,30 @@ function posterise(f: Float32Array, steps: number): Float32Array {
   return f;
 }
 
-/** Three box passes, wrapped at the tile edges so the blur cannot draw a rim
-    where the tile repeats.
+/** Wrapped box blur, so the blur cannot draw a rim where the tile repeats.
 
-    The width is the one the filter spec derives for three boxes to land on a
-    gaussian of a given deviation, so the dial's px are the px it gets. */
+    Three boxes at the width the filter spec derives land on a gaussian of a
+    given deviation, which is what makes the dial's px the px it gets. But a box
+    radius is a whole number of samples and a sample is two page px, so rounding
+    to one put the dial on a 2px ladder with a dead zone at the bottom: every
+    setting under 2.5px came out perfectly sharp, and everything from 2.5 to
+    4.2px came out identical. Mixing the two radii either side of the exact one
+    puts the dial back on a continuous scale, and radius zero is the field
+    itself, so the bottom of the travel eases in instead of switching on. */
 function blur(f: Float32Array, raster: number, std: number): Float32Array {
-  const radius = Math.round((std * 3 * Math.sqrt(2 * Math.PI) / 4 - 1) / 2);
-  if (radius < 1) return f;
+  const exact = (std * 3 * Math.sqrt(2 * Math.PI) / 4 - 1) / 2;
+  if (exact <= 0) return f;
+  const lower = Math.floor(exact);
+  const mix = exact - lower;
+  const low = lower < 1 ? f : boxes(f, raster, lower);
+  if (mix < 1e-6) return low;
+  const high = boxes(f, raster, lower + 1);
+  const out = new Float32Array(f.length);
+  for (let i = 0; i < f.length; i++) out[i] = low[i] + (high[i] - low[i]) * mix;
+  return out;
+}
+
+function boxes(f: Float32Array, raster: number, radius: number): Float32Array {
   let cur = f;
   for (let pass = 0; pass < 3; pass++) cur = boxPass(cur, raster, radius);
   return cur;
@@ -234,8 +268,10 @@ function cachedRaw(s: SketchSettings, seed: number): Float32Array {
 /**
  * The finished field, 0 (bare) to 1 (inked), row-major.
  *
- * Three stages and no fourth: the last one IS the result, so the strip of
- * previews in the tab accounts for the whole of what the dials do.
+ * `through` stops the pipeline early. Nothing in the app asks for a part of it
+ * — the tab shows the finished field and nothing else — but the levels are
+ * three passes over one array, and the seam is where the tests read what each
+ * pass did.
  */
 export function buildMaskField(
   s: SketchSettings, seed = 9, through?: MaskStage,
@@ -246,7 +282,7 @@ export function buildMaskField(
   const levelled = applyOutput(
     posterise(Float32Array.from(raw), s.maskPosterize), s.maskOutputMin, s.maskOutputMax,
   );
-  if (through === 'output') return { field: levelled, raster: RASTER };
+  if (through === 'levels') return { field: levelled, raster: RASTER };
 
   return { field: blur(levelled, RASTER, s.maskSoftness / SAMPLE_PX), raster: RASTER };
 }

package/src/editor/core/sketch/sketchLayer.ts

@@ -84,6 +84,12 @@ interface PartSpec {
       drawn corner radii on the host instead, so the clip at least turns the
       same way the ink does. */
   clips?: boolean;
+  /** Keeps the ink coverage mask off the fill. Coverage wears a fill through in
+      patches, and a part that floats over arbitrary page content shows whatever
+      is behind it through the worn places: it stops reading as a surface the
+      pointer can land on. Set it where the part floats over the page rather
+      than over a scrim of its own. */
+  unmasked?: boolean;
   positioned?: boolean;
   strokeless?: boolean;
 }
@@ -165,7 +171,7 @@ const PART_SPECS: readonly PartSpec[] = [
     clips: true,
   },
   // The arrow is the tooltip's own ::after, so the box takes the fill only.
-  { sel: '.tooltip', stem: 'tooltip', positioned: true, strokeless: true },
+  { sel: '.tooltip', stem: 'tooltip', positioned: true, strokeless: true, unmasked: true },
 
   // Status blocks
   ...STATUS_VARIANTS.map((v) => ({ sel: `.callout-${v}`, stem: `callout-${v}` })),
@@ -189,6 +195,7 @@ const PART_SPECS: readonly PartSpec[] = [
     stroke: 'var(--menuselect-menu-border)',
     radius: 'var(--menuselect-menu-radius, 0px)',
     shadow: 'var(--menuselect-menu-shadow, none)',
+    unmasked: true,
   },
   { sel: '.tab', stem: 'tabbar-default', radius: 'var(--tabbar-default-tab-top-radius, 0px)' },
   { sel: '.tab.active', stem: 'tabbar-active', radius: 'var(--tabbar-active-tab-top-radius, 0px)' },
@@ -316,6 +323,7 @@ const FLOW_PARTS = PART_SPECS.filter((p) => !p.positioned).map((p) => p.sel).joi
 const STROKE_PARTS = PART_SPECS.filter((p) => !p.strokeless).map((p) => p.sel).join(', ');
 const UNCLIPPED = PART_SPECS.filter((p) => !p.clips).map((p) => p.sel).join(', ');
 const CLIPPED = PART_SPECS.filter((p) => p.clips).map((p) => p.sel).join(', ');
+const UNMASKED = PART_SPECS.filter((p) => p.unmasked).map((p) => p.sel).join(', ');
 
 export function buildDefsMarkup(s: SketchSettings): string {
   /**
@@ -853,6 +861,10 @@ export function buildStylesheet(s: SketchSettings): string {
       `pointer-events:none;` +
     `}`;
 
+  /* The parts that float over page content take the fill whole, and everything
+     else the layer does with it. The second `:is` outweighs the rule above. */
+  const solidFills = s.maskOn ? `${el}:is(${UNMASKED})::before{mask-image:none;}` : '';
+
   // The hatch is laid over the fill as a second background LAYER rather than
   // as `background-image` beside a `background-color`, because a part is free
   // to name a gradient as its fill: the Kit's lead block hands the layer the
@@ -1037,7 +1049,7 @@ export function buildStylesheet(s: SketchSettings): string {
   }).join('');
 
   return [
-    registrations, vars, icons, host, fill, fillStyles, retrace, stroke,
+    registrations, vars, icons, host, fill, solidFills, fillStyles, retrace, stroke,
     seedRotation, shape, jitter, perPart, colours, states,
   ].join('\n');
 }
@@ -1075,8 +1087,17 @@ export function applySketchLayer(settings: SketchSettings): void {
   const defs = buildDefsMarkup(settings);
   const css = buildStylesheet(settings);
   for (const doc of getSyncedDocuments()) {
+    const style = styleNode(doc);
+    // Writing markup a document already has is a visible flash, not a no-op:
+    // rewriting defs destroys every filter the page is mid-paint against, and
+    // rewriting the sheet drops the mask image to be decoded again. Both are
+    // built from the same settings, so the sheet answers for the pair. The
+    // comparison is against the DOM rather than a variable because with the
+    // overlay open two instances of this module render into this page, and the
+    // document is the only ground they share.
+    if (style.textContent === css) continue;
     defsNode(doc).innerHTML = defs;
-    styleNode(doc).textContent = css;
+    style.textContent = css;
   }
 }
 

package/src/editor/core/sketch/sketchPresets.ts

@@ -62,11 +62,10 @@ export interface SketchSettings {
   /** Wavelength of the coverage noise, in page px. Small gives speckle, large gives broad patches. */
   maskBlob: number;
   /** Output levels on the coverage field, 0 to 1: the palest the fill gets and
-      the densest. 0 is bare and 1 is whole, so 0.4 to 1 is a fill that is never
-      thinner than 40% ink, and 0 to 0.8 one that never quite fills in. Close
-      together is a flat wash, far apart a strong blotch. The field is stretched
-      onto its own measured range before they apply, so both mean the same thing
-      at every grain and octave count. */
+      the densest. The whole field is squeezed into the gap, never cut at it, so
+      0.4 to 1 is a fill that is never thinner than 40% ink and 0 to 0.8 one
+      that never quite fills in. Close together is a flat wash, far apart a
+      strong blotch. */
   maskOutputMin: number;
   maskOutputMax: number;
   /** Detail layers. 1-2 gives broad blobs, 4+ goes cloudy and stops reading as blotches. */
@@ -140,7 +139,7 @@ export const SKETCH_PRESETS: Record<string, SketchSettings> = {
     blurb: 'Two graphite passes on their own seeds, so the outline disagrees with itself the way a hand coming back round does. Tight grain, little else.',
     fillTravel: 0.75, strokeTravel: 1.25, wobble: 30, roughness: 3, waveform: 1,
     strokeWidth: 1.25, doubleStroke: true, retracePass: 'reseeded', retraceOffset: 1.5, strokeInk: 0.85,
-    maskBlob: 40, maskOutputMin: 0.62, maskOutputMax: 1, maskOctaves: 3, maskPosterize: 1, maskSoftness: 0.6,
+    maskBlob: 40, maskOutputMin: 0.62, maskOutputMax: 1, maskOctaves: 3, maskPosterize: 1, maskSoftness: 0,
     jitterX: 1.5, jitterY: 1.5, jitterRot: 0.35, jitterScale: 0.022,
     cornerSpread: 6, cornerTravel: 4.5,
     pressure: 0.15, pressureMod: 0.3, pooling: 0, iconTravel: 0.75,
@@ -151,7 +150,7 @@ export const SKETCH_PRESETS: Record<string, SketchSettings> = {
     blurb: 'Broad translucent nib gone round twice on the same line, so the overlap darkens and the ink pools where it slows.',
     fillTravel: 2, strokeTravel: 1.5, wobble: 56, waveform: 1.4, borderWavelength: 1.3,
     strokeWidth: 4, doubleStroke: true, retracePass: 'copy', strokeInk: 0.52, retraceOffset: 2.2,
-    maskBlob: 115, maskOutputMin: 0.21, maskOutputMax: 1, maskOctaves: 3, maskPosterize: 4, maskSoftness: 2.5,
+    maskBlob: 115, maskOutputMin: 0.42, maskOutputMax: 1, maskOctaves: 3, maskPosterize: 4, maskSoftness: 4,
     jitterX: 3, jitterY: 3, jitterRot: 0.8, jitterScale: 0.045,
     cornerSpread: 10, cornerTravel: 8,
     pressure: 0.2, pressureMod: 0.25, pooling: 2, iconTravel: 1.25, iconMaskScale: 4,
@@ -162,8 +161,8 @@ export const SKETCH_PRESETS: Record<string, SketchSettings> = {
     blurb: 'The fattest nib on glass. One long smooth undulation, and a veined mask that streaks the fill like a half-wiped board.',
     fillTravel: 2.5, strokeTravel: 2.5, wobble: 90, roughness: 1, waveform: 1, borderWavelength: 1.5,
     strokeWidth: 5.5, doubleStroke: true, retracePass: 'copy', strokeInk: 0.66, retraceOffset: 3,
-    maskGrain: 'turbulence', maskBlob: 180, maskOutputMin: 0.42, maskOutputMax: 0.9,
-    maskOctaves: 1, maskPosterize: 3, maskSoftness: 5,
+    maskGrain: 'turbulence', maskBlob: 180, maskOutputMin: 0.42, maskOutputMax: 1,
+    maskOctaves: 1, maskPosterize: 3, maskSoftness: 8,
     jitterX: 4.5, jitterY: 4.5, jitterRot: 1.2, jitterScale: 0.07,
     cornerSpread: 14, cornerTravel: 11,
     pressure: 0.15, pressureMod: 0.15, pooling: 3.5, iconTravel: 1.75, iconMaskScale: 1.5,
@@ -196,7 +195,7 @@ export const SKETCH_PRESETS: Record<string, SketchSettings> = {
     blurb: 'Ballpoint in a hurry. Everything loose at once: a square wave sends every edge to full travel, and the second pass lands wherever it lands.',
     fillTravel: 3, strokeTravel: 2.25, wobble: 50, roughness: 3, waveform: 2.5,
     strokeWidth: 2.25, doubleStroke: true, retracePass: 'reseeded', retraceOffset: 4, strokeInk: 1,
-    maskBlob: 150, maskOutputMin: 0.43, maskOutputMax: 0.95, maskOctaves: 2, maskPosterize: 2, maskSoftness: 6.7,
+    maskBlob: 150, maskOutputMin: 0.43, maskOutputMax: 0.95, maskOctaves: 2, maskPosterize: 2, maskSoftness: 10,
     jitterX: 6, jitterY: 6, jitterRot: 1.8, jitterScale: 0.1,
     cornerSpread: 20, cornerTravel: 17,
     pressure: 0.45, pressureMod: 0.6, pooling: 2.5, iconTravel: 2.25, iconMaskScale: 3.6,
@@ -207,7 +206,7 @@ export const SKETCH_PRESETS: Record<string, SketchSettings> = {
     blurb: 'Ink that ran out. One scratchy pass that breaks up along its length, over a fill the mask has worn nearly through in patches.',
     fillTravel: 2.25, strokeTravel: 1.75, wobble: 50, waveform: 2, borderWavelength: 0.5,
     strokeWidth: 3.5, doubleStroke: false, strokeInk: 0.4,
-    maskBlob: 150, maskOutputMin: 0.15, maskOutputMax: 0.91,
+    maskBlob: 150, maskOutputMin: 0.24, maskOutputMax: 0.91,
     maskOctaves: 2, maskPosterize: 4, maskSoftness: 1.75,
     jitterX: 5, jitterY: 5, jitterRot: 1.4, jitterScale: 0.08,
     cornerSpread: 16, cornerTravel: 13,

package/src/editor/core/sketch/sketchStore.ts

@@ -159,32 +159,103 @@ function persist(key: string, value: string): void {
   }
 }
 
-if (typeof document !== 'undefined') {
-  let installed = false;
+/** The root the effect paints in this document, or null while this document is
+    showing an editor surface. Registered by LiveTokensRouter: a consumer can
+    relocate the editor routes, so the router is the only thing that knows
+    whether what is on screen is a page or the editor's own chrome. Null until
+    it says so, which is what keeps the editor from flashing the effect over
+    itself between import and first render. */
+let pageRoot: HTMLElement | null = null;
 
-  const render = (enabled: boolean, settings: SketchSettings) => {
-    if (!enabled) {
-      if (installed) removeSketchLayer();
-      installed = false;
-      return;
-    }
-    applySketchLayer(settings);
-    installed = true;
-    // The editor's own chrome must never pick the effect up, so only the host
-    // page's root becomes a scope here. The preview container scopes itself.
-    setSketchScope(hostRoot(), settings);
-  };
+let installed = false;
+
+function render(enabled: boolean, settings: SketchSettings): void {
+  if (typeof document === 'undefined') return;
+  if (!enabled) {
+    if (installed) removeSketchLayer();
+    installed = false;
+    return;
+  }
+  applySketchLayer(settings);
+  installed = true;
+  // The editor's own chrome must never pick the effect up. Two roots qualify:
+  // the host page behind the overlay iframe, and this document while it is
+  // showing a page. The preview container scopes itself.
+  setSketchScope(hostRoot(), settings);
+  setSketchScope(pageRoot, settings);
+}
+
+export function setSketchPageRoot(el: HTMLElement | null): void {
+  if (el === pageRoot) return;
+  setSketchScope(pageRoot, null);
+  pageRoot = el;
+  render(get(sketchEnabled), get(sketchSettings));
+}
+
+/**
+ * What this document last exchanged with the other one, per key: written by
+ * `share`, recorded by `adopt`.
+ *
+ * A document must never write back a value it adopted. Comparing against its
+ * own store is not enough, because the echo is not identical, it is LATE: a
+ * drag sends a value every frame, the far side adopts the first and writes it
+ * back, and by then this side is three frames along. It reads the echo, sees a
+ * value it does not hold, and adopts its own past — the handle jumps back under
+ * the cursor and the drag cannot move.
+ */
+const shared = new Map<string, string>();
 
+function share(key: string, value: string): void {
+  if (shared.get(key) === value) return;
+  shared.set(key, value);
+  persist(key, value);
+}
+
+function adopt(key: string, value: string): void {
+  shared.set(key, value);
+}
+
+if (typeof document !== 'undefined') {
   sketchEnabled.subscribe((enabled) => {
-    persist(ENABLED_KEY, String(enabled));
+    share(ENABLED_KEY, String(enabled));
     render(enabled, get(sketchSettings));
   });
 
   sketchSettings.subscribe((settings) => {
-    persist(SETTINGS_KEY, JSON.stringify(settings));
+    share(SETTINGS_KEY, JSON.stringify(settings));
     render(get(sketchEnabled), settings);
   });
 
-  sketchPreset.subscribe((name) => persist(PRESET_KEY, name));
-  sketchBaseline.subscribe((b) => persist(BASELINE_KEY, b ? JSON.stringify(b) : ''));
+  sketchPreset.subscribe((name) => share(PRESET_KEY, name));
+  sketchBaseline.subscribe((b) => share(BASELINE_KEY, b ? JSON.stringify(b) : ''));
+
+  /* The overlay editor runs in an iframe, so the Sketch tab and a control on
+     the page are separate instances of this module. localStorage is the ground
+     they share: each adopts a value only when it differs from what it holds,
+     and records what it adopted so it never sends that value back. */
+  window.addEventListener('storage', (event) => {
+    if (event.storageArea !== localStorage) return;
+    if (event.key === ENABLED_KEY) {
+      const next = event.newValue === 'true';
+      adopt(ENABLED_KEY, String(next));
+      if (next !== get(sketchEnabled)) sketchEnabled.set(next);
+    } else if (event.key === SETTINGS_KEY) {
+      if (event.newValue && event.newValue !== JSON.stringify(get(sketchSettings))) {
+        const next = readSettings();
+        adopt(SETTINGS_KEY, JSON.stringify(next));
+        sketchSettings.set(next);
+      }
+    } else if (event.key === PRESET_KEY) {
+      const next = readPresetName();
+      adopt(PRESET_KEY, next);
+      if (next !== get(sketchPreset)) sketchPreset.set(next);
+    } else if (event.key === BASELINE_KEY) {
+      const current = get(sketchBaseline);
+      if ((event.newValue || '') !== (current ? JSON.stringify(current) : '')) {
+        const next = readBaseline();
+        adopt(BASELINE_KEY, next ? JSON.stringify(next) : '');
+        sketchBaseline.set(next);
+      }
+    }
+  });
 }

package/src/editor/docs/content/sketch-mode.md

@@ -50,8 +50,13 @@ your own, alongside the shipped seven, as a file under
   few pixels off or runs it through the pen again on its own seed.
 - **Fill.** Solid or hatched, how far the fill's edge travels, and how far each
   instance is offset, rotated and scaled from its neighbours. **Ink coverage**
-  thins the fill with a field of blotches: set their size, how many levels of
-  detail, how pale and how dense they go, and how soft their edges are.
+  thins the fill with a field of blotches: set their size and how many levels of
+  detail, then work the field as a levels control. The field always runs black
+  to white whatever the noise underneath. Steps flattens it into tones, and
+  Output squeezes the whole of it into the range the ink covers, from how pale
+  it gets at its thinnest to how dense at its fullest. Menus and tooltips are
+  drawn solid whatever the coverage dials say: they float over the page, and a
+  fill worn through in patches lets the page show through them.
 - **Shape.** **Corner spread** rounds each corner by its own share of the dial,
   so no two match. **Corner travel** leans the drawn box into a quadrilateral
   with no two sides parallel. This is the dial that stops a component reading as

package/src/editor/docs/content.generated.ts

@@ -7,7 +7,7 @@ export const docContent: Record<string, string> = {
   "editing-tokens": "# Editing tokens\n\nA tour of the editor. The page behind it repaints on every change; saving\nwrites a theme file you can reload later.\n\nThe editor has four views:\n\n- **Tokens**: the design-system primitives (colour, type, spacing, and so on).\n  They apply everywhere your site uses them.\n- **Color Wheel**: the harmony wheel, the palette curves, and the story your colours\n  tell across a page.\n- **Components**: per-component editors. Re-Assign what tokens a component uses\n  without changing the underlying system.\n- **Sketch Style**: an effect layer that redraws the page by hand. See\n  [Sketch mode](sketch-mode.md).\n\nThis page covers **Tokens**. For components, see\n[Creating components](creating-components.md).\n\n## Palettes\n\nMost colour work happens here. Each palette (Brand, Accent, Neutral, Canvas,\nSuccess, Warning, Info, Danger, and a few more) has:\n\n- **Base colour.** Pick a hex; the palette derives an 11-step ramp (100 to 950)\n  from it.\n- **Curves.** Three curves shape the ramp, in stack order: Hue, Saturation,\n  Lightness. Drag the handles to bias it warmer or cooler, more or less\n  saturated, darker or lighter. Hue drifts the ramp's temperature without\n  moving contrast, because OKLCH hue rotation is close to lightness-preserving.\n  It holds ±45 degrees; a bigger shift belongs on the base colour or the\n  harmony axis.\n- **Overrides.** Lock a single step to a hand-picked hex when the curve doesn't\n  land where you want.\n\nEditing a palette base ripples through every colour that depends on it, in real\ntime. Colours use OKLCH, so the ramp stays perceptually even across hues\nwithout muddy mid-tones.\n\n## Type\n\n- **Fonts.** Add sources from Google Fonts, Adobe (Typekit), a CSS URL, or an\n  inline `@font-face`. The font loads in the page as soon as you add it.\n- **Stacks.** Named font cascades you reference by token, such as a display\n  stack and a body stack.\n- **Sizes and weights.** A t-shirt scale (xs, sm, md, lg, xl, 2xl…) for size and\n  a numeric scale (100 to 900) for weight.\n\n## Spacing, radius, shadow\n\nNumeric scales with a slider per step.\n\n- **Spacing**: the padding, gap, and margin scale.\n- **Radius**: none through full.\n- **Shadow**: colour, offset, blur, spread, and opacity per step, with stacked\n  shadows supported.\n\nChange a step and every element using it repaints.\n\n## Overlays and gradients\n\n- **Overlays** are translucent tints layered over surfaces, like the subtle\n  tint a card gets on hover. Set a colour and opacity per state.\n- **Gradients** are reusable gradient tokens with a stop list and direction, for\n  hero panels and accent backgrounds.\n\n## Columns\n\nThe page-grid overlay. Set column count, gutter, and outer margin, and toggle\nthe visual guide with `Cmd/Ctrl+G`. Pages built on the column system reflow\nlive.\n\n## Saving\n\nThe editor saves to your browser continuously, so work survives a reload\nmid-edit. Writing a file is a separate step: the **Theme** panel at the foot of\nthe sidebar has **Save**, **Save As**, and **Load**, and each theme is one JSON\nfile under `src/live-tokens/data/themes/`.\n\nThe header gives you undo/redo (`Cmd/Ctrl+Z`, `Cmd/Ctrl+Shift+Z`). You can keep\nmany themes side by side; one is open at a time, and only **Adopt** publishes\none. See [Themes](themes-workflow.md) for the full lifecycle.\n",
   "getting-started": "# Getting started\n\nScaffold a live token site in a moments. You need Node 20 or later, a\npackage manager (npm, pnpm, or yarn), and a browser. Open claude code in your repo and start building.\n\n## Scaffold a new app\n\n```bash\nnpm create @motion-proto/live-tokens@latest my-app\ncd my-app\nnpm install\nnpm run dev\n```\n\nOpen the URL Vite prints (usually `http://localhost:5173`). You get a\none-page Svelte + Vite app that depends on the published package, with the\neditor wired up and the full component set ready to import.\n\n`npx @motion-proto/live-tokens create my-app` runs the same scaffold without\nthe initialiser package.\n\n### What the scaffold gives you\n\nEvery editable file lives under `src/` and is committed, so `npm install` and\nversion upgrades never touch your styles. The package code stays in\n`node_modules`.\n\n| Path | What it is |\n|------|------------|\n| `src/pages/Home.svelte` | The starter page. Replace it with your own content. |\n| `src/App.svelte` | Your routes. `<LiveTokensRouter>` adds dev-only routes under a reserved `/live-tokens/*` namespace: `/live-tokens/editor`, `/live-tokens/components`, and `/live-tokens/docs`. |\n| `src/system/styles/tokens.css` | Your base token vocabulary, hand-authored. |\n| `src/styles/site.css` | Themed page typography, yours to edit. |\n\n## Your first edit\n\n1. Run `npm run dev` and open the home page.\n2. Click **Open Token Editor**, or visit `/live-tokens/editor`. The editor opens beside\n   the page.\n3. Open **Palettes**, pick **Brand**, and change the base hex. The page\n   repaints as you type.\n4. In the **Theme** panel at the foot of the sidebar, choose **Save As**. Your\n   theme appears as JSON under `src/live-tokens/data/themes/`.\n5. Reload. The editor reopens on your theme, so the page returns as you left\n   it.\n\n## What you just changed\n\nEvery edit sets a CSS custom property on `:root`. Your components read those\nproperties through `var(--...)`. There is no token build step and no\npreprocessor rewriting your code: the page renders against plain CSS variables\nthe editor swaps live.\n\nTo ship, click **Adopt** in the Theme panel. That saves the open theme and bakes\nit into `src/live-tokens/data/tokens.generated.css`, which your build bundles\nalongside `tokens.css`. Adopt is the only action that changes what your site\nships, so try any look you like first. The editor itself never reaches\nproduction.\n\nAlready have a Svelte 5 + Vite app? The\n[README](https://github.com/motionproto/live-tokens#readme) covers installing\ninto an existing project.\n\n## Where to go next\n\n- **[Editing tokens](editing-tokens.md)**: a tour of the editor.\n- **[Themes](themes-workflow.md)**: save, switch, and ship.\n- **[Creating components](creating-components.md)**: make your own component\n  editable.\n",
   "light-and-dark": "# Light and dark\n\nSome things on a page cannot be written as a token. A wordmark drawn in white\ndisappears on a pale theme. Ink that multiplies onto paper vanishes on a dark\none. A photograph behind a headline is dark no matter what the palette says.\n\nEach of those needs the same fact first: which way does the surface behind this\nthing lean? One attribute carries it.\n\n## The attribute\n\n`data-backdrop` is either `light` or `dark`, and it does two things at once: it\nselects, so a rule can key on it, and it sets `color-scheme`, so every\n`light-dark()` under it resolves the half that reads.\n\n```css\n.title {\n  color: light-dark(var(--color-black), var(--color-white));\n}\n```\n\nThat line is right on both sides of the theme, and it is right inside a dark\nband on a pale page, because the nearest `color-scheme` wins.\n\n## Stating it\n\nPut it in the markup when the surface knows its own tone — a hero over a\nphotograph, a plate that stays pale in every theme:\n\n```svelte\n<div class=\"hero-panel\" data-backdrop=\"dark\">\n```\n\nA stated tone beats any measurement, and it inherits, so everything inside the\npanel resolves against it.\n\n## Measuring it\n\nWhere the tone is a property of the theme rather than of the markup, let it be\nmeasured:\n\n```svelte\n<script>\n  import { backdrop } from '@motion-proto/live-tokens/backdrop';\n</script>\n\n<section use:backdrop>\n```\n\nThe action reads whatever actually paints behind the element — the nearest\nancestor with an opaque fill, averaged across its gradient stops, falling back\nto the theme's `--page-bg` — and stamps the answer. It re-reads when the theme\nchanges, which the editor does by rewriting custom properties with no reload,\nso the stamp follows a live edit.\n\nThe page itself is stamped for you: the build bakes the production theme's\npolarity into `tokens.generated.css`, so the first paint is already right, and\n`syncDocumentBackdrop()` keeps `<html>` current as themes switch.\n\n```ts\nimport { syncDocumentBackdrop } from '@motion-proto/live-tokens/backdrop';\n\nsyncDocumentBackdrop();\n```\n\n## Reading it from JavaScript\n\nAnything that paints outside CSS — a canvas, a WebGL uniform, an `<img>` that\ncomes in two versions — asks the same question through the same module:\n\n```ts\nimport { isLightBackdrop, watchBackdrop, cssColorToHex } from '@motion-proto/live-tokens/backdrop';\n\nconst stop = watchBackdrop(logoEl, {\n  stamp: false,\n  onChange: (polarity) => (src = polarity === 'light' ? darkMark : lightMark),\n});\n```\n\n`isLightBackdrop(el)` answers once. `watchBackdrop` keeps answering and returns\na stop function. `cssColorToHex` resolves any CSS colour — including the\n`oklch()` a token holds — to a hex a non-CSS consumer can take.\n\n## What it does not do\n\nPolarity is a property of a surface, not of a component, so nothing is stamped\nfor you below `<html>`: a section that needs an answer either states one or asks\nfor one. And a measurement reads the paint at the moment it runs — an element\nthat scrolls from a pale band onto a dark one keeps the answer it was given.\nState the tone on each band instead.\n",
-  "sketch-mode": "# Sketch mode\n\nSketch mode redraws your whole page as if it had been drawn by hand. Every\ncomponent keeps its own colours, spacing and corners; what changes is the line\nthey are drawn with.\n\nIt is an effect layer, not a set of token values. It reads nothing from your\ntheme and writes nothing back, so it never touches a token, never lands in a\ntheme file, and never reaches the CSS you ship. Turn it off and every trace of\nit goes.\n\nOpen the **Sketch Style** view in the editor and switch **Sketch mode** on. The effect\napplies to the page behind the editor as well as to the preview, so what you see\nin context is what it does.\n\n## What it draws\n\nEach component's fill and outline are repainted from the tokens that component\nalready owns. The real background and border are hidden behind them, then both\nare pushed around one shared field of noise. Because every component samples the\nsame field, the whole page reads as one drawing rather than as a set of\nseparately wobbled boxes.\n\n## The presets\n\nSeven looks ship with the package, and each is a complete set of dials rather\nthan a style name:\n\n- **Pencil.** Two graphite passes on their own seeds, so the outline disagrees\n  with itself the way a hand coming back round does.\n- **Marker.** A broad translucent nib gone round twice on the same line, so the\n  overlap darkens and the ink pools where it slows.\n- **Whiteboard.** The fattest nib on glass, with a mask that streaks the fill\n  like a half-wiped board.\n- **Hatched.** An etching. The fill is angled shading and the outline a single\n  hard-edged scratch.\n- **Dashed.** A drafting outline: one slow drift along the ruler, broken into\n  strokes. The clean pole.\n- **Napkin.** Ballpoint in a hurry. Everything loose at once.\n- **Dry marker.** Ink that ran out. One scratchy pass over a mostly eaten fill.\n\nPick one, then move whatever you like. **Save** keeps your dials under a name of\nyour own, alongside the shipped seven, as a file under\n`src/live-tokens/data/sketch-presets/`.\n\n## The dials\n\n- **Border.** How far the outline travels and how long its wave is, then its\n  width, ink, pressure and pooling. A second pass either copies the first line a\n  few pixels off or runs it through the pen again on its own seed.\n- **Fill.** Solid or hatched, how far the fill's edge travels, and how far each\n  instance is offset, rotated and scaled from its neighbours. **Ink coverage**\n  thins the fill with a field of blotches: set their size, how many levels of\n  detail, how pale and how dense they go, and how soft their edges are.\n- **Shape.** **Corner spread** rounds each corner by its own share of the dial,\n  so no two match. **Corner travel** leans the drawn box into a quadrilateral\n  with no two sides parallel. This is the dial that stops a component reading as\n  a rectangle.\n- **Icons and SVG.** Glyph travel and wavelength on their own scale. A glyph is\n  all curves already, so it needs more travel than a card's long straight edge\n  before the wobble reads at all.\n- **Noise.** The shared field itself: its wavelength, how many layers of detail\n  sit on it, and the shape of its wave. A square wave sends nearly every edge to\n  full travel, which is what makes the effect stronger rather than bigger.\n\n## Where the settings live\n\nThe dials you are moving live in your browser, so the effect follows you across\nreloads and stays off everyone else's screen. **Save** writes a named preset to\n`src/live-tokens/data/sketch-presets/`, which is the only thing that reaches\ndisk.\n\nSketch mode is a tool for looking at the page, not a layer the page can ship.\nNothing is written into a theme, `tokens.generated.css` never sees it, and a\nproduction build has no sketch layer in it at all.\n\n## Drawing your own elements\n\nThe layer draws a fixed set of parts: the shipped components, and four classes\nit reserves for you. Nothing else is touched, so a page element or a\nconsumer-authored component is left crisp until it carries one of them.\n\n| Class               | For                                                       |\n|---------------------|-----------------------------------------------------------|\n| `sketch-surface`    | A box. The default treatment.                              |\n| `sketch-container`  | A large box. Tilts less, so the type inside stays readable. |\n| `sketch-chip`       | A small box. Finer fill mask, more rotation, less travel.   |\n| `sketch-rule`       | A line rather than a box. No rotation, no rounded ends.     |\n\nPick by size, not by kind: a card and a modal both take `sketch-container`, a\nbadge and a pill both take `sketch-chip`.\n\nThe class opts the element in; it names no colours, so the element states its\nown. `--sketch-fill`, `--sketch-stroke`, `--sketch-hatch-color`,\n`--sketch-radius` and `--sketch-shadow` name the fill, the outline, the hatching\nink, the corners and the shadow for one element and everything inside it. The\nlayer blanks the real background and border, so an element whose fill matters\nunder Sketch mode has to name it here as well as paint it.\n\nThe layer also paints on the element's `::before` and `::after`, forces its\n`overflow` visible, and gives it a stacking context of its own. Keep the class\noff anything that owns a pseudo-element, clips its content, or is positioned\nabsolutely, and put it on a wrapper instead.\n\n```css\n.my-callout {\n  background: var(--surface-brand-lowest);\n  border: var(--border-width-1) solid var(--border-brand);\n  border-radius: var(--radius-xl);\n\n  --sketch-fill: var(--surface-brand-lowest);\n  --sketch-stroke: var(--border-brand);\n  --sketch-radius: var(--radius-xl);\n}\n```\n\nA gradient is a valid fill: the shorthand's last layer takes a colour or an\nimage, so `--sketch-fill` accepts either. States work the same way, since\nnothing is competing with you for the value:\n\n```css\n.my-callout:hover { --sketch-stroke: var(--border-brand-strong); }\n```\n\n## Images inside a drawn part\n\nA drawn part's `overflow` is forced visible, because the fill and outline are\npainted on pseudo-elements that travel past the box and would otherwise be cut\noff at its edge. A background that bleeds is the effect working. An image that\nbleeds is not: it keeps its square corners while the card around it turns.\n\nMedia that runs to a part's edge therefore has to carry that part's corners\nitself. `--sketch-radius` is the radius the layer drew, and it inherits, so a\nchild can read it and fall back to its own value when Sketch mode is off:\n\n```css\n.cover {\n  overflow: hidden;\n  border-top-left-radius: var(--sketch-radius, var(--card-default-radius));\n  border-top-right-radius: var(--sketch-radius, var(--card-default-radius));\n}\n```\n\nCorner spread is per-corner and per-instance, so at high spread the crop is the\nmean rather than an exact trace of the drawn edge.\n\nA rule made from a `border` is not a box and cannot be displaced. Make it an\nelement, give it `sketch-rule`, and name its ink:\n\n```html\n<div class=\"rule sketch-rule\"></div>\n```\n```css\n.rule {\n  height: var(--border-width-2);\n  background: var(--border-brand);\n  --sketch-fill: var(--border-brand);\n}\n```\n\nIcons and inline SVG take the wobble directly, since a glyph has no box to\nredraw. Body type is left alone: an icon is a shape and survives a wobble, a\nparagraph is not.\n\n`--sketch-icon-off` names what a subtree's glyphs are drawn with instead. It\ninherits, so one declaration covers everything under it, and it takes the ink\nmask off as well as the wobble:\n\n```css\n/* Crisp. Chrome, a logo, anything that has to stay exact. */\n.app-bar { --sketch-icon-off: none; }\n\n/* Drawn back rather than off, at a third of the travel. Small artwork, and\n   type set as an SVG, which the layer reads as one large glyph. */\n.wordmark { --sketch-icon-off: var(--sketch-icon-soft); }\n```\n\nThe **Blotch size** dial under Icons and SVG is a share of the glyph rather than\na px size, because no px size is right for both a 16px icon and a page-wide\ndrawing. At 100% every glyph gets one period of the field across it whatever its\nsize. Below that the field repeats inside the glyph and the blotches get finer.\nAbove it a glyph reads part of one blotch, so the mask thins the whole glyph\nunevenly instead of breaking it up. The fill's blotches stay in px, since a\ncomponent does have a size to state one against.\n",
+  "sketch-mode": "# Sketch mode\n\nSketch mode redraws your whole page as if it had been drawn by hand. Every\ncomponent keeps its own colours, spacing and corners; what changes is the line\nthey are drawn with.\n\nIt is an effect layer, not a set of token values. It reads nothing from your\ntheme and writes nothing back, so it never touches a token, never lands in a\ntheme file, and never reaches the CSS you ship. Turn it off and every trace of\nit goes.\n\nOpen the **Sketch Style** view in the editor and switch **Sketch mode** on. The effect\napplies to the page behind the editor as well as to the preview, so what you see\nin context is what it does.\n\n## What it draws\n\nEach component's fill and outline are repainted from the tokens that component\nalready owns. The real background and border are hidden behind them, then both\nare pushed around one shared field of noise. Because every component samples the\nsame field, the whole page reads as one drawing rather than as a set of\nseparately wobbled boxes.\n\n## The presets\n\nSeven looks ship with the package, and each is a complete set of dials rather\nthan a style name:\n\n- **Pencil.** Two graphite passes on their own seeds, so the outline disagrees\n  with itself the way a hand coming back round does.\n- **Marker.** A broad translucent nib gone round twice on the same line, so the\n  overlap darkens and the ink pools where it slows.\n- **Whiteboard.** The fattest nib on glass, with a mask that streaks the fill\n  like a half-wiped board.\n- **Hatched.** An etching. The fill is angled shading and the outline a single\n  hard-edged scratch.\n- **Dashed.** A drafting outline: one slow drift along the ruler, broken into\n  strokes. The clean pole.\n- **Napkin.** Ballpoint in a hurry. Everything loose at once.\n- **Dry marker.** Ink that ran out. One scratchy pass over a mostly eaten fill.\n\nPick one, then move whatever you like. **Save** keeps your dials under a name of\nyour own, alongside the shipped seven, as a file under\n`src/live-tokens/data/sketch-presets/`.\n\n## The dials\n\n- **Border.** How far the outline travels and how long its wave is, then its\n  width, ink, pressure and pooling. A second pass either copies the first line a\n  few pixels off or runs it through the pen again on its own seed.\n- **Fill.** Solid or hatched, how far the fill's edge travels, and how far each\n  instance is offset, rotated and scaled from its neighbours. **Ink coverage**\n  thins the fill with a field of blotches: set their size and how many levels of\n  detail, then work the field as a levels control. The field always runs black\n  to white whatever the noise underneath. Steps flattens it into tones, and\n  Output squeezes the whole of it into the range the ink covers, from how pale\n  it gets at its thinnest to how dense at its fullest. Menus and tooltips are\n  drawn solid whatever the coverage dials say: they float over the page, and a\n  fill worn through in patches lets the page show through them.\n- **Shape.** **Corner spread** rounds each corner by its own share of the dial,\n  so no two match. **Corner travel** leans the drawn box into a quadrilateral\n  with no two sides parallel. This is the dial that stops a component reading as\n  a rectangle.\n- **Icons and SVG.** Glyph travel and wavelength on their own scale. A glyph is\n  all curves already, so it needs more travel than a card's long straight edge\n  before the wobble reads at all.\n- **Noise.** The shared field itself: its wavelength, how many layers of detail\n  sit on it, and the shape of its wave. A square wave sends nearly every edge to\n  full travel, which is what makes the effect stronger rather than bigger.\n\n## Where the settings live\n\nThe dials you are moving live in your browser, so the effect follows you across\nreloads and stays off everyone else's screen. **Save** writes a named preset to\n`src/live-tokens/data/sketch-presets/`, which is the only thing that reaches\ndisk.\n\nSketch mode is a tool for looking at the page, not a layer the page can ship.\nNothing is written into a theme, `tokens.generated.css` never sees it, and a\nproduction build has no sketch layer in it at all.\n\n## Drawing your own elements\n\nThe layer draws a fixed set of parts: the shipped components, and four classes\nit reserves for you. Nothing else is touched, so a page element or a\nconsumer-authored component is left crisp until it carries one of them.\n\n| Class               | For                                                       |\n|---------------------|-----------------------------------------------------------|\n| `sketch-surface`    | A box. The default treatment.                              |\n| `sketch-container`  | A large box. Tilts less, so the type inside stays readable. |\n| `sketch-chip`       | A small box. Finer fill mask, more rotation, less travel.   |\n| `sketch-rule`       | A line rather than a box. No rotation, no rounded ends.     |\n\nPick by size, not by kind: a card and a modal both take `sketch-container`, a\nbadge and a pill both take `sketch-chip`.\n\nThe class opts the element in; it names no colours, so the element states its\nown. `--sketch-fill`, `--sketch-stroke`, `--sketch-hatch-color`,\n`--sketch-radius` and `--sketch-shadow` name the fill, the outline, the hatching\nink, the corners and the shadow for one element and everything inside it. The\nlayer blanks the real background and border, so an element whose fill matters\nunder Sketch mode has to name it here as well as paint it.\n\nThe layer also paints on the element's `::before` and `::after`, forces its\n`overflow` visible, and gives it a stacking context of its own. Keep the class\noff anything that owns a pseudo-element, clips its content, or is positioned\nabsolutely, and put it on a wrapper instead.\n\n```css\n.my-callout {\n  background: var(--surface-brand-lowest);\n  border: var(--border-width-1) solid var(--border-brand);\n  border-radius: var(--radius-xl);\n\n  --sketch-fill: var(--surface-brand-lowest);\n  --sketch-stroke: var(--border-brand);\n  --sketch-radius: var(--radius-xl);\n}\n```\n\nA gradient is a valid fill: the shorthand's last layer takes a colour or an\nimage, so `--sketch-fill` accepts either. States work the same way, since\nnothing is competing with you for the value:\n\n```css\n.my-callout:hover { --sketch-stroke: var(--border-brand-strong); }\n```\n\n## Images inside a drawn part\n\nA drawn part's `overflow` is forced visible, because the fill and outline are\npainted on pseudo-elements that travel past the box and would otherwise be cut\noff at its edge. A background that bleeds is the effect working. An image that\nbleeds is not: it keeps its square corners while the card around it turns.\n\nMedia that runs to a part's edge therefore has to carry that part's corners\nitself. `--sketch-radius` is the radius the layer drew, and it inherits, so a\nchild can read it and fall back to its own value when Sketch mode is off:\n\n```css\n.cover {\n  overflow: hidden;\n  border-top-left-radius: var(--sketch-radius, var(--card-default-radius));\n  border-top-right-radius: var(--sketch-radius, var(--card-default-radius));\n}\n```\n\nCorner spread is per-corner and per-instance, so at high spread the crop is the\nmean rather than an exact trace of the drawn edge.\n\nA rule made from a `border` is not a box and cannot be displaced. Make it an\nelement, give it `sketch-rule`, and name its ink:\n\n```html\n<div class=\"rule sketch-rule\"></div>\n```\n```css\n.rule {\n  height: var(--border-width-2);\n  background: var(--border-brand);\n  --sketch-fill: var(--border-brand);\n}\n```\n\nIcons and inline SVG take the wobble directly, since a glyph has no box to\nredraw. Body type is left alone: an icon is a shape and survives a wobble, a\nparagraph is not.\n\n`--sketch-icon-off` names what a subtree's glyphs are drawn with instead. It\ninherits, so one declaration covers everything under it, and it takes the ink\nmask off as well as the wobble:\n\n```css\n/* Crisp. Chrome, a logo, anything that has to stay exact. */\n.app-bar { --sketch-icon-off: none; }\n\n/* Drawn back rather than off, at a third of the travel. Small artwork, and\n   type set as an SVG, which the layer reads as one large glyph. */\n.wordmark { --sketch-icon-off: var(--sketch-icon-soft); }\n```\n\nThe **Blotch size** dial under Icons and SVG is a share of the glyph rather than\na px size, because no px size is right for both a 16px icon and a page-wide\ndrawing. At 100% every glyph gets one period of the field across it whatever its\nsize. Below that the field repeats inside the glyph and the blotches get finer.\nAbove it a glyph reads part of one blotch, so the mask thins the whole glyph\nunevenly instead of breaking it up. The fill's blotches stay in px, since a\ncomponent does have a size to state one against.\n",
   "themes-workflow": "# Themes\n\nSave your work, switch between looks, and ship one to production.\n\n## The Theme panel\n\nThe **Theme** panel at the foot of the editor sidebar holds the whole look:\ncolors, type, and a setting for every component, in one file. It carries the\nname the look ships under, whether production is running it, and **Adopt**.\nTwo parts sit under it, each a read-out rather than a file to manage.\n\n- **Colors & Type** holds the design tokens. Components read those tokens to\n  define their appearance. It names the two faces the page is showing.\n- **Components** counts how many components have an unsaved edit that has not\n  been saved into the theme, and opens the component editors.\n\nA theme holds its own copy of every part, so one theme can never break another.\n\n## How themes work\n\nA theme is a document, and the editor works the way any editor does.\n\n- **A theme** is a named JSON file in `src/live-tokens/data/themes/`. It carries\n  the whole look: the colors and type plus a setting for every component.\n- **The open theme** is the one the editor is working on, named in\n  `themes/_active.json`. One at a time.\n- **Your unsaved edits** are what the page shows right now. The editor keeps\n  them in your browser as you work and writes them to a buffer, `_working.json`,\n  one slot per part of the look. **Save** captures that buffer into the open\n  theme.\n- **The production theme** is the one your site ships, named in\n  `themes/_production.json`. **Adopt** changes it; saving a preset in the Theme\n  Picker performs that Adopt for you.\n\nAbsence is the answer for anything untouched: a buffer exists only where the\nlive look diverges from the active theme, so a newly opened theme has none.\n\n## Fonts\n\nType is part of the look, so it saves, loads and ships with the theme rather\nthan on its own. Four named stacks carry it:\n\n| Stack | Used by |\n|---|---|\n| `--font-display` | headings |\n| `--font-sans` | body text and most UI |\n| `--font-serif` | anywhere you ask for it |\n| `--font-mono` | code |\n\nEach stack is a family followed by its fallbacks, so a page still reads while a\nweb font loads, and still reads if it never does. **Project fonts**, in the\nColors and type editor, is where families come from: type a Google Fonts family\nname and the editor checks it, or paste a fonts URL, an embed tag, or your own\n`@font-face` rules. Removing a family puts the stack back on its fallbacks.\n\nYou can also set both faces at once from the command line:\n\n```bash\nnpx live-tokens set-fonts fonts.json\n```\n\nwith a brief naming the families:\n\n```json\n{ \"display\": \"Fraunces\", \"body\": \"Nunito Sans\" }\n```\n\nIt checks each family against Google Fonts, works out the weights that family\nactually has, and binds it to its stack. Like every other edit, the result lands\nin the buffer, so **Save** keeps it. In Claude Code, asking for a font pairing in\nplain English runs the same command.\n\nA font is only requested by the browser once something on the page uses it, so\ncarrying a family you no longer reference costs nothing at load. Adopting is\nwhat writes the font imports your site ships, into `fonts.css`.\n\n## Saving\n\nIn the Theme panel:\n\n- **Save** captures the look on screen into the open theme. Your colors and type\n  go in as part of it, so there is nothing to save first.\n- **Save As** names a new theme. Use it for your first save and for forking.\n\nComponent editors keep their own unsaved state. If one or more components are\nwaiting when you use **Save**, **Save As**, or **Adopt**, the Theme panel offers\nto save all of them before continuing. You can accept once instead of visiting\neach component, or cancel to review them individually. A component editor's\n**Save As** creates a reusable component preset.\n\nNames are tidied to lowercase with hyphens, so \"My Brand!\" becomes `my-brand`,\nand a leading underscore is dropped: those names are reserved for the buffer.\n**Motion Proto** is the built-in theme and is read-only. You can always return\nto it, and the editor never overwrites it, so start your own with **Save As**.\n\n## Switching\n\n**Load**—or clicking the active theme's name—opens the Theme Picker. Picking a\ntheme shows it on the page as a preview with nothing written to disk, so you can\ntry each look and compare. **Save** in that window opens and adopts the previewed\ntheme in one step: the active pointer changes, the buffers clear, the editor\nworks on it, and production ships it. **Cancel** returns you to where you were.\nPreviewing alone never changes what your site ships.\n\n**Colors and type only. Keep my shapes.** narrows the load to the palette and\nthe fonts: your component settings stay as they are and the theme you have open\nstays open. Saved colors and type files are listed there too, marked *colors &\ntype*, and picking one is always that narrower load.\n\n## Shipping\n\n**Adopt**, in the Theme panel, is the \"ship it\" step, and it ships the whole\nlook. It saves the open theme, then bakes that theme into\n`src/live-tokens/data/tokens.generated.css`, which your build bundles alongside\n`tokens.css`: the colors and type plus every component the theme carries. Fonts\nregenerate to match. The line under the theme name says whether production is\nrunning this theme.\n\nProduction is one saved theme, so nothing else publishes. Trying a look, moving\na token, saving a theme: all of it leaves the generated CSS alone until you\nAdopt. A component editor's Adopt runs the same whole-look step, because a\ncomponent never ships alone. Adopting while Motion Proto is open saves your look\nas a theme of your own first, since the built-in one is read-only.\n\nProduction builds (`npm run build`) ship only that plain CSS and your\ncomponents. No editor, no JSON loading, no runtime indirection.\n\n## Keeping your work safe\n\nEverything under `src/live-tokens/data/` is plain JSON, so commit it. Themes show\nup as readable diffs you can review per branch, and the buffer shows up as the\nwork you have not saved into a theme yet. Nothing is backed up anywhere else:\ngit is your safety net. To experiment freely, **Save As** a new name first, then\nedit.\n\n## Where to go next\n\n- **[Where themes live](where-themes-live.md)**: the files behind all of this,\n  and what writes each one.\n- **[Creating components](creating-components.md)**: make your own components\n  editable in the same editor.\n",
   "where-themes-live": "# Where themes live\n\nEverything the editor writes is plain JSON and CSS inside your project. There\nis no database and no hidden state: the files are the storage, and git is the\nhistory.\n\n## The data tree\n\n```\nsrc/live-tokens/data/\n  themes/\n    _active.json         names the theme the editor has open\n    _production.json     names the theme your site ships\n    default.json         Motion Proto, the built-in look, rewritten at boot\n    my-brand.json        a saved theme: the whole look in one file\n  colors-and-type/\n    _working.json        unsaved colors and type edits\n  component-configs/\n    button/\n      default.json       Button's shipped settings, derived at boot\n      _working.json      unsaved Button edits\n      my-button.json     a preset you saved from the Button editor\n  tokens.generated.css   the baked CSS your production build ships\nsrc/system/styles/\n  tokens.css             your token vocabulary, hand-authored, never written\n  fonts.css              font imports, rewritten when you Adopt\n```\n\nA saved theme carries the whole look by value: the colors and type plus a\nsetting for every component. It depends on no other file, so deleting\nanything else never breaks it.\n\n## What writes when\n\n- **Editing** changes the page through CSS variables. The editor keeps your\n  edits in the browser as you work and writes them to the `_working.json`\n  buffers when you save a component. When the Theme panel finds several dirty\n  components, **Save all** writes those buffers together.\n- **Save** captures the buffers into the open theme's file. That file is the\n  durable copy of your look; matching buffers are then removed.\n- **Load** clears the buffers and points `themes/_active.json` at the theme you\n  picked. Live reads fall through to that file. Nothing else changes, so trying\n  looks is free and ordinary switching changes only the pointer.\n- **Adopt** points `themes/_production.json` at the open theme, bakes it into\n  `tokens.generated.css`, and rewrites `fonts.css` to match. It is the only\n  action that changes what your site ships.\n\nThe `default.json` files are the shipped baseline. The editor derives them at\nboot and refreshes them when the package updates; it never saves your work\nover them.\n\nProjects upgraded from 0.48 may initially contain working files copied from the\nactive theme. On the first dev-server boot, exact copies are removed\nautomatically. Any file that differs is kept as unsaved work, so no migration\ncommand is required.\n\n## What to commit\n\nAll of it. The data tree is designed to live in git: themes diff readably, the\ntwo pointers say what is open and what ships, and a `_working.json` in a diff\nis exactly the work you have not yet saved into a theme. Nothing is backed up\nanywhere else.\n\n## Where to go next\n\n- **[Themes](themes-workflow.md)**: the workflow built on these files: saving,\n  loading, and shipping.\n",
 };

package/src/editor/overlay/LiveTokensRouter.svelte

@@ -71,6 +71,7 @@
   import ColumnsOverlay from './ColumnsOverlay.svelte';
   import { route, navigate } from '../core/routing/router';
   import { DEFAULT_EDITOR_PATH, DEFAULT_COMPONENTS_PATH, DEFAULT_COLORS_PATH, DEFAULT_DOCS_PATH } from '../core/routing/ownedRoutes';
+  import { setSketchPageRoot } from '../core/sketch/sketchStore';
 
   interface Props {
     pages: Record<string, RouteEntry>;
@@ -101,6 +102,13 @@
   let isColors = $derived(isDev && colorsEnabled && $route === colorsPath);
   let isDocs = $derived(isDev && docsEnabled && $route === docsPath);
 
+  // A sketch style paints the page and never the editor's own chrome. Which
+  // routes are chrome is this component's knowledge alone, since a consumer can
+  // relocate them, so it hands the sketch layer the root to paint.
+  $effect(() => {
+    setSketchPageRoot(isEditor || isComponentEditor || isColors || isDocs ? null : document.documentElement);
+  });
+
   // The single entry that renders the current route. Owned routes are handled
   // by the isEditor/isComponentEditor/isColors/isDocs branches, so they resolve
   // to null here; everything else flows through resolveRoute and drives both

package/src/editor/ui/sections/textStyles.ts

@@ -1,5 +1,5 @@
 /**
- * Registry of the eight v1 semantic text styles rendered by TextStylesSection.
+ * Registry of the semantic text styles rendered by TextStylesSection.
  * Each style is a bundle of alias tokens declared in tokens.css; the prefix
  * joins with a kind suffix (`-font-family`, `-font-size`, …) to form each
  * axis variable the editor's pickers target.
@@ -64,6 +64,20 @@ export const TEXT_STYLES: TextStyle[] = [
     defaultElement: 'small',
     preview: 'Captions and secondary text.',
   },
+  {
+    name: 'editorial-md',
+    label: 'Editorial MD',
+    prefix: '--editorial-md',
+    defaultElement: 'editorial-md',
+    preview: 'Long-form reading, set in the editorial face.',
+  },
+  {
+    name: 'editorial-sm',
+    label: 'Editorial SM',
+    prefix: '--editorial-sm',
+    defaultElement: 'editorial-sm',
+    preview: 'Standfirsts, pull quotes, and asides.',
+  },
   {
     name: 'code',
     label: 'Code',