@motion-proto/live-tokens 0.47.0 → 0.48.0

package/bin/generate-theme.mjs

@@ -0,0 +1,251 @@
+// `live-tokens generate-theme` worker.
+//
+// Reads a seed brief (JSON), builds a full validated colors-and-type layer via
+// the compiled engine (dist-plugin/generateColorsAndType — the CLI never imports
+// TS sources), enforces the AA contrast gate, and saves the result as a theme:
+// <themesDir>/<slug>.json, the document that carries the whole look by value.
+// Unless --no-activate it then opens that theme the way the dev server's apply
+// door does — the embedded copies land in the reserved `_working` buffers and
+// `themes/_active.json` names it. Nothing else moves, so generating a theme
+// cannot change what the site ships.
+//
+// Non-color content (shadows, component aliases, fonts) carries forward from
+// the live state so generation only replaces the color identity. Swatch
+// gradients ride along too when user-tuned; stock ones are rebuilt from the new
+// theme's families by the engine.
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const ENGINE = resolve(pkgRoot, 'dist-plugin/generateColorsAndType/index.js');
+const packageDataDir = join(pkgRoot, 'src/live-tokens/data');
+const THEME_SCHEMA_VERSION = 3;
+
+async function loadEngine() {
+  if (!existsSync(ENGINE)) {
+    throw new Error(
+      `theme engine not found at ${relative(process.cwd(), ENGINE)}. ` +
+        `Build the plugin first (npm run build:plugin).`,
+    );
+  }
+  return import(ENGINE);
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function readJsonIfExists(path) {
+  try {
+    return existsSync(path) ? readJson(path) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Local dir first, then the installed package's shipped copy — the same
+ *  fallback order the dev server's reads use. */
+function readData(localDir, packageSubdir, fileName) {
+  return (
+    readJsonIfExists(join(localDir, `${fileName}.json`)) ??
+    readJsonIfExists(join(packageDataDir, packageSubdir, `${fileName}.json`))
+  );
+}
+
+function componentNames(componentConfigsDir) {
+  if (!existsSync(componentConfigsDir)) return [];
+  return readdirSync(componentConfigsDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+}
+
+/** `_fileName` and `_source` are read-door markers, never part of a document. */
+function stripMarkers(value) {
+  if (!value || typeof value !== 'object') return value;
+  const { _fileName, _source, ...rest } = value;
+  return rest;
+}
+
+/**
+ * The look the new theme carries forward. Without --carry-from that is the LIVE
+ * state — buffer first, then the open theme, then the shipped default — because
+ * what the user sees is what they expect to keep. With it, the named theme,
+ * read by value.
+ */
+function resolveCarrySource({ carryFrom, colorsAndTypeDir, componentConfigsDir, themesDir }) {
+  const comps = componentNames(componentConfigsDir);
+
+  if (carryFrom) {
+    const theme = readData(themesDir, 'themes', carryFrom);
+    if (!theme) throw new Error(`--carry-from theme "${carryFrom}" not found`);
+    const componentConfigs = {};
+    for (const comp of comps) {
+      const cfg = theme.componentConfigs?.[comp];
+      if (cfg) componentConfigs[comp] = stripMarkers(cfg);
+    }
+    return { colorsAndType: stripMarkers(theme.colorsAndType), componentConfigs };
+  }
+
+  const activeSlug = readJsonIfExists(join(themesDir, '_active.json'))?.activeFile ?? 'default';
+  const activeTheme = readData(themesDir, 'themes', activeSlug);
+  const colorsAndType = stripMarkers(
+    readJsonIfExists(join(colorsAndTypeDir, '_working.json')) ??
+      activeTheme?.colorsAndType ??
+      readData(colorsAndTypeDir, 'colors-and-type', 'default'),
+  );
+
+  // Presence is the model's own rule for "off the shipped default": a buffer
+  // exists only where the layer sits off it, and a theme carries only the
+  // components it changes.
+  const componentConfigs = {};
+  for (const comp of comps) {
+    const live =
+      readJsonIfExists(join(componentConfigsDir, comp, '_working.json')) ??
+      activeTheme?.componentConfigs?.[comp];
+    if (live) componentConfigs[comp] = stripMarkers(live);
+  }
+  return { colorsAndType, componentConfigs };
+}
+
+/** `engine` is a test seam; the CLI always runs the compiled bundle. */
+export async function runGenerateTheme({
+  briefPath,
+  activate = true,
+  dryRun = false,
+  carryFrom,
+  root = process.cwd(),
+  colorsAndTypeDir,
+  componentConfigsDir,
+  themesDir,
+  engine,
+} = {}) {
+  const { buildColorsAndTypeFromSeeds, resolveDataDirs } = engine ?? (await loadEngine());
+
+  const briefFull = resolve(root, briefPath);
+  if (!existsSync(briefFull)) {
+    throw new Error(`brief not found at ${relative(root, briefFull)}`);
+  }
+  let brief;
+  try {
+    brief = readJson(briefFull);
+  } catch (err) {
+    throw new Error(`brief is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+
+  const dirs =
+    colorsAndTypeDir && componentConfigsDir && themesDir
+      ? { colorsAndTypeDir, componentConfigsDir, themesDir }
+      : resolveDataDirs();
+
+  const previousActive = readJsonIfExists(join(dirs.themesDir, '_active.json'))?.activeFile ?? 'default';
+  const carry = resolveCarrySource({ carryFrom, ...dirs });
+
+  const { colorsAndType, slug, report } = buildColorsAndTypeFromSeeds(
+    brief,
+    {
+      cssVariables: carry.colorsAndType?.cssVariables,
+      fontSources: carry.colorsAndType?.fontSources,
+      fontStacks: carry.colorsAndType?.fontStacks,
+      gradients: carry.colorsAndType?.gradients,
+    },
+    new Date().toISOString(),
+  );
+
+  const themePath = join(dirs.themesDir, `${slug}.json`);
+  const existing = readJsonIfExists(themePath);
+  const theme = {
+    name: colorsAndType.name,
+    createdAt: existing?.createdAt ?? colorsAndType.createdAt,
+    updatedAt: colorsAndType.updatedAt,
+    schemaVersion: THEME_SCHEMA_VERSION,
+    colorsAndType,
+    componentConfigs: carry.componentConfigs,
+  };
+
+  if (!dryRun) {
+    mkdirSync(dirs.themesDir, { recursive: true });
+    writeFileSync(themePath, JSON.stringify(theme, null, 2) + '\n');
+    if (activate) applyTheme(theme, slug, dirs);
+  }
+
+  return {
+    name: theme.name,
+    slug,
+    themePath,
+    existed: existing !== null,
+    activated: activate && !dryRun,
+    previousActive,
+    carriedFrom: carryFrom ?? null,
+    componentsCarried: Object.keys(carry.componentConfigs).length,
+    dryRun,
+    report,
+  };
+}
+
+/** The apply door's write set, reproduced: the theme's copies fill the reserved
+ *  buffers, every component it does not carry is cleared back to the default,
+ *  and `themes/_active.json` names the open document. Production is untouched. */
+function applyTheme(theme, slug, dirs) {
+  mkdirSync(dirs.colorsAndTypeDir, { recursive: true });
+  writeFileSync(
+    join(dirs.colorsAndTypeDir, '_working.json'),
+    JSON.stringify(theme.colorsAndType, null, 2),
+  );
+
+  for (const comp of componentNames(dirs.componentConfigsDir)) {
+    const workingPath = join(dirs.componentConfigsDir, comp, '_working.json');
+    const embedded = theme.componentConfigs[comp];
+    if (embedded) writeFileSync(workingPath, JSON.stringify({ ...embedded, component: comp }, null, 2));
+    else if (existsSync(workingPath)) rmSync(workingPath);
+  }
+
+  writeFileSync(join(dirs.themesDir, '_active.json'), JSON.stringify({ activeFile: slug }));
+}
+
+export function formatGenerateThemeResult(result) {
+  const root = process.cwd();
+  const lines = [];
+  const wrote = result.dryRun ? 'Would write' : result.existed ? 'Updated' : 'Created';
+  lines.push(`${wrote} theme "${result.name}" → ${relative(root, result.themePath)}`);
+  lines.push(
+    `Carried forward from ${result.carriedFrom ? `theme "${result.carriedFrom}"` : 'the live state'}: ` +
+      `fonts, gradients and ${result.componentsCarried} component config(s).`,
+  );
+
+  lines.push(`\nContrast report (${result.report.scheme} scheme):`);
+  const width = Math.max(...result.report.checks.map((c) => c.textVar.length));
+  for (const c of result.report.checks) {
+    const mark = c.pass ? '✓' : '✗';
+    const fixed = c.corrected ? '  (auto-corrected)' : '';
+    lines.push(
+      `  ${mark} ${c.textVar.padEnd(width)}  ${c.ratio.toFixed(2).padStart(6)}:1  vs ${c.against}  floor ${c.floor}:1${fixed}`,
+    );
+  }
+  if (result.report.failures.length > 0) {
+    lines.push(`\nUnmet floors — adjust the brief's seeds and re-run:`);
+    for (const f of result.report.failures) lines.push(`  ! ${f}`);
+  }
+
+  lines.push(
+    result.report.gradients === 'carried'
+      ? '\nGradients: kept your tuned swatch gradients.'
+      : '\nGradients: swatch tokens rebuilt from the theme families.',
+  );
+  if (result.report.canvasGradient) {
+    lines.push(`Canvas sky: ${result.report.canvasGradient}.`);
+  }
+
+  if (result.activated) {
+    lines.push(
+      `\nOpened "${result.slug}" (previously open: "${result.previousActive}"). ` +
+        `Reload the app to see it; switch back any time from Load in the editor's Theme panel. ` +
+        `Adopt it there to publish it to tokens.generated.css.`,
+    );
+  } else if (!result.dryRun) {
+    lines.push(`\nNot opened (--no-activate). Load "${result.slug}" from the editor's Theme panel to see it.`);
+  }
+  return lines.join('\n');
+}

package/bin/migrate.mjs

@@ -1,17 +1,23 @@
 // `live-tokens migrate` worker.
 //
-// Applies the registered tokens-css migrations to a consumer's developer-authored
-// tokens.css, reconciling Layer-1 drift after a package upgrade. The migration
-// engine itself lives in the built plugin (dist-plugin/tokensCssMigrations) so
-// the CLI and the dev-plugin guardrail share one source of truth; this module
-// only handles path resolution, file IO, and reporting.
+// Two passes, both against a consumer's project. The first applies the
+// registered tokens-css migrations to their developer-authored tokens.css,
+// reconciling Layer-1 drift after a package upgrade. The second heals the data
+// tree: the pre-working-set model left a materialised copy of every applied
+// theme behind and a pointer pair per layer pointing at them, and this is what
+// turns that into one production theme plus one buffer per layer.
+//
+// Both engines live in the built plugin (dist-plugin/) so the CLI and the
+// dev-plugin guardrail share one source of truth; this module handles path
+// resolution, file IO, and reporting.
 
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
+import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const ENGINE = resolve(pkgRoot, 'dist-plugin/tokensCssMigrations/index.js');
+const DATA_ENGINE = resolve(pkgRoot, 'dist-plugin/migrateData/index.js');
 
 // Locations to probe when neither --tokens nor config.tokensCssPath is given.
 const DEFAULT_CANDIDATES = [
@@ -77,6 +83,89 @@ export async function runMigrate({ tokensArg, check = false, root = process.cwd(
   return { status: 'changed', tokensPath, applied, addedLines };
 }
 
+async function loadDataEngine() {
+  if (!existsSync(DATA_ENGINE)) {
+    throw new Error(
+      `data migration engine not found at ${relative(process.cwd(), DATA_ENGINE)}. ` +
+        `Build the plugin first (npm run build:plugin).`,
+    );
+  }
+  return import(DATA_ENGINE);
+}
+
+/** `engine` is a test seam; the CLI always runs the compiled bundle. */
+export async function runMigrateData({ check = false, engine } = {}) {
+  const { migrateData, resolveDataDirs } = engine ?? (await loadDataEngine());
+  const dirs = resolveDataDirs();
+  return migrateData({
+    dataDir: dirs.dataDir,
+    colorsAndTypeDir: dirs.colorsAndTypeDir,
+    componentConfigsDir: dirs.componentConfigsDir,
+    themesDir: dirs.themesDir,
+    legacyManifestsDir: dirs.legacyManifestsDir,
+    packageDataDir: join(pkgRoot, 'src/live-tokens/data'),
+    check,
+  });
+}
+
+const HOW_SAID = {
+  'all-default': 'every retired pointer named the default',
+  matched: 'it matches what the retired pointers resolved to',
+  recovered: 'no saved theme matched what the retired pointers resolved to, so it was captured',
+};
+
+export function formatMigrateDataResult(result) {
+  const root = process.cwd();
+  const rel = (p) => relative(root, p);
+  if (result.status === 'clean') return '';
+
+  const planned = result.status === 'planned';
+  const lines = [planned ? 'Data tree heal (planned):' : 'Data tree healed:'];
+
+  for (const { from, to } of result.renames) {
+    lines.push(`  ${planned ? 'would move' : 'moved'} ${rel(from)} → ${rel(to)} (0.48 layout)`);
+  }
+  for (const p of result.upgradedThemes) {
+    lines.push(`  ${planned ? 'would carry' : 'carried'} ${rel(p)} by value (was a pre-v3 theme naming files)`);
+  }
+  if (result.production) {
+    lines.push(`  production theme → "${result.production.slug}" (${HOW_SAID[result.production.how]})`);
+  }
+  if (result.recoveredThemePath) {
+    lines.push(`  ${planned ? 'would write' : 'wrote'} ${rel(result.recoveredThemePath)}`);
+  }
+  for (const p of result.workingWritten) {
+    lines.push(`  ${planned ? 'would fill' : 'filled'} ${rel(p)} from the live state`);
+  }
+  for (const p of result.workingKept) {
+    lines.push(`  kept ${rel(p)}: the editor already owns that buffer`);
+  }
+  for (const p of result.deletedFiles) {
+    lines.push(`  ${planned ? 'would delete' : 'deleted'} ${rel(p)}: a copy of a saved theme`);
+  }
+  for (const p of result.keptUserFiles) {
+    lines.push(`  kept ${rel(p)}: it matches no theme, so it is yours`);
+  }
+  for (const note of result.droppedRefs) {
+    lines.push(`  ${note}`);
+  }
+  for (const p of result.notThemes) {
+    lines.push(`  left ${rel(p)} alone: it is a colors-and-type file, not a theme`);
+  }
+  for (const p of result.shadowedDefaults) {
+    lines.push(`  kept ${rel(p)}: it shadows the default the package ships, which has moved on`);
+  }
+  lines.push(
+    `  ${planned ? 'would retire' : 'retired'} ${result.deletedPointers.length} per-layer pointer file(s)`,
+  );
+  lines.push(
+    planned
+      ? '\nRun without --check to apply this, then review the diff in git.'
+      : '\nRestart the dev server: it rebuilds tokens.generated.css from the production theme.',
+  );
+  return lines.join('\n');
+}
+
 function diffAddedLines(before, after) {
   const beforeSet = new Set(before.split('\n'));
   return after.split('\n').filter((l) => l.trim() && !beforeSet.has(l));

package/dist-plugin/adjust/index.cjs

@@ -0,0 +1,259 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// vite-plugin/adjust/index.ts
+var adjust_exports = {};
+__export(adjust_exports, {
+  adjustAliases: () => adjustAliases,
+  matchesKind: () => matchesKind,
+  readLiveTokensConfig: () => readLiveTokensConfig,
+  resolveDataDirs: () => resolveDataDirs
+});
+module.exports = __toCommonJS(adjust_exports);
+
+// src/editor/core/components/aliasKinds.ts
+var KIND_PATTERNS = [
+  { kind: "font-family", matches: (v) => v.endsWith("-font-family") },
+  { kind: "font-weight", matches: (v) => v.endsWith("-font-weight") },
+  { kind: "font-size", matches: (v) => v.endsWith("-font-size") || v.endsWith("-icon-size") || v.endsWith("-thumb-size") },
+  { kind: "line-height", matches: (v) => v.endsWith("-line-height") },
+  { kind: "letter-spacing", matches: (v) => v.endsWith("-letter-spacing") },
+  { kind: "text-color", matches: (v) => v.endsWith("-text") || v.startsWith("--text-") },
+  { kind: "radius", matches: (v) => v.endsWith("-radius") || v.startsWith("--radius-") },
+  { kind: "divider-width", matches: (v) => v.endsWith("-divider-width") || v.endsWith("-divider-thickness") },
+  { kind: "divider-height", matches: (v) => v.endsWith("-divider-height") || v.endsWith("-track-height") },
+  { kind: "divider-inset", matches: (v) => v.endsWith("-divider-inset") },
+  { kind: "dot-size", matches: (v) => v.endsWith("-dot-size") },
+  { kind: "blur", matches: (v) => v.endsWith("-blur") || v.startsWith("--blur-") },
+  { kind: "scale", matches: (v) => v.endsWith("-scale") || v.startsWith("--scale-") },
+  { kind: "shadow", matches: (v) => v.endsWith("-shadow") || v.startsWith("--shadow-") },
+  { kind: "padding", matches: (v) => v.endsWith("-padding") || v.endsWith("-margin") },
+  { kind: "gap", matches: (v) => v.endsWith("-gap") },
+  { kind: "duration", matches: (v) => v.endsWith("-duration") || v.startsWith("--duration-") },
+  { kind: "easing", matches: (v) => v.endsWith("-easing") || v.startsWith("--ease-") },
+  { kind: "border-width", matches: (v) => v.endsWith("-border-width") || v.endsWith("-accent-width") || v.endsWith("-hairline-thickness") || v.startsWith("--border-width-") },
+  { kind: "border", matches: (v) => v.endsWith("-border") || v.startsWith("--border-") },
+  { kind: "surface", matches: (v) => v.endsWith("-surface") || v.startsWith("--surface-") }
+];
+var MATCHER_BY_KIND = Object.fromEntries(
+  KIND_PATTERNS.map((p) => [p.kind, p.matches])
+);
+var SIDE_SUFFIXES = ["-top", "-right", "-bottom", "-left"];
+function matchesKind(variable, kind) {
+  const side = SIDE_SUFFIXES.find((s) => variable.endsWith(s));
+  return MATCHER_BY_KIND[kind](side ? variable.slice(0, -side.length) : variable);
+}
+
+// src/editor/core/components/adjustAliases.ts
+var RADIUS_FULL = "--radius-full";
+var RADIUS_RUNGS = [
+  "--radius-none",
+  "--radius-sm",
+  "--radius-md",
+  "--radius-lg",
+  "--radius-xl",
+  "--radius-2xl",
+  "--radius-3xl",
+  "--radius-4xl"
+];
+var SPACE_RUNGS = [
+  "--space-0",
+  "--space-2",
+  "--space-4",
+  "--space-6",
+  "--space-8",
+  "--space-10",
+  "--space-12",
+  "--space-16",
+  "--space-20",
+  "--space-24",
+  "--space-32",
+  "--space-48"
+];
+var SPACE_FAMILY = [...SPACE_RUNGS, "--space-40", "--space-64", "--space-96", "--space-128"];
+var BORDER_WIDTH_RUNGS = [
+  "--border-width-0",
+  "--border-width-1",
+  "--border-width-2",
+  "--border-width-3",
+  "--border-width-4",
+  "--border-width-5",
+  "--border-width-6",
+  "--border-width-8",
+  "--border-width-10",
+  "--border-width-12",
+  "--border-width-16",
+  "--border-width-20",
+  "--border-width-24"
+];
+var LADDERS = {
+  radius: { rungs: RADIUS_RUNGS, family: [...RADIUS_RUNGS, RADIUS_FULL] },
+  padding: { rungs: SPACE_RUNGS, family: SPACE_FAMILY },
+  gap: { rungs: SPACE_RUNGS, family: SPACE_FAMILY },
+  "border-width": { rungs: BORDER_WIDTH_RUNGS, family: BORDER_WIDTH_RUNGS }
+};
+var TOKEN_NAME = /^--[a-z0-9-]+$/;
+function rungsFor(op) {
+  return op.kind === "radius" && op.full ? [...RADIUS_RUNGS, RADIUS_FULL] : LADDERS[op.kind].rungs;
+}
+function spaceStep(token) {
+  return Number(token.slice("--space-".length));
+}
+function nearestSpaceRung(token, rungs) {
+  const step = spaceStep(token);
+  let best = 0;
+  for (let i = 1; i < rungs.length; i++) {
+    if (Math.abs(spaceStep(rungs[i]) - step) <= Math.abs(spaceStep(rungs[best]) - step)) best = i;
+  }
+  return best;
+}
+function resolve(op, value) {
+  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);
+  let index = rungs.indexOf(value);
+  if (index < 0) {
+    if (value === RADIUS_FULL) return { skip: "pill-preserved" };
+    index = nearestSpaceRung(value, rungs);
+  }
+  const wanted = index + op.shift;
+  const landed = Math.min(Math.max(wanted, 0), rungs.length - 1);
+  if (landed !== wanted && rungs[landed] === value) return { skip: "clamped" };
+  return { from: value, to: rungs[landed] };
+}
+function validateOp(op, configs) {
+  const ladder = LADDERS[op.kind];
+  if (!ladder) throw new Error(`Unknown kind "${op.kind}" (expected ${Object.keys(LADDERS).join(", ")})`);
+  if (op.target !== void 0 && !(op.target in configs)) {
+    throw new Error(`Unknown target component "${op.target}"`);
+  }
+  const hasSet = op.set !== void 0;
+  const hasShift = op.shift !== void 0;
+  if (hasSet === hasShift) throw new Error(`A ${op.kind} op needs exactly one of "set" or "shift"`);
+  const settable = op.kind === "radius" ? ladder.family : ladder.rungs;
+  if (hasSet && !settable.includes(op.set)) {
+    throw new Error(`"${op.set}" is not on the ${op.kind} ladder`);
+  }
+  if (hasShift && !Number.isInteger(op.shift)) {
+    throw new Error(`"shift" must be a whole number of steps, got ${op.shift}`);
+  }
+  if (op.full !== void 0 && !(op.kind === "radius" && hasShift)) {
+    throw new Error('"full" applies to radius shifts only');
+  }
+}
+function adjustAliases(configs, ops, now) {
+  for (const op of ops) validateOp(op, configs);
+  const next = { ...configs };
+  const reports = /* @__PURE__ */ new Map();
+  const reportFor = (component) => {
+    let report = reports.get(component);
+    if (!report) {
+      report = { component, changes: [], skips: [] };
+      reports.set(component, report);
+    }
+    return report;
+  };
+  for (const op of ops) {
+    for (const component of op.target ? [op.target] : Object.keys(next)) {
+      const config = next[component];
+      const aliases = { ...config.aliases };
+      let changed = false;
+      for (const [variable, value] of Object.entries(config.aliases)) {
+        if (!matchesKind(variable, op.kind)) continue;
+        const outcome = resolve(op, value);
+        if ("skip" in outcome) {
+          reportFor(component).skips.push({ variable, value, reason: outcome.skip });
+          continue;
+        }
+        if (outcome.to === outcome.from) continue;
+        aliases[variable] = outcome.to;
+        reportFor(component).changes.push({ variable, from: outcome.from, to: outcome.to });
+        changed = true;
+      }
+      if (changed) next[component] = { ...config, aliases, updatedAt: now };
+    }
+  }
+  return { configs: next, report: { components: [...reports.values()] } };
+}
+
+// vite-plugin/files/dataPaths.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var DEFAULT_DATA_DIR = "src/live-tokens/data";
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "dataDir",
+  "colorsAndTypeDir",
+  "componentConfigsDir",
+  "themesDir",
+  "manifestsDir",
+  "tokensCssPath"
+]);
+var cached = null;
+function readLiveTokensConfig() {
+  if (cached) return cached;
+  try {
+    const configPath = import_path.default.resolve("live-tokens.config.json");
+    if (!import_fs.default.existsSync(configPath)) return cached = {};
+    const parsed = JSON.parse(import_fs.default.readFileSync(configPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object") return cached = {};
+    const unknown = Object.keys(parsed).filter(
+      (k) => k !== "$schema" && !KNOWN_CONFIG_KEYS.has(k)
+    );
+    if (unknown.length > 0) {
+      console.warn(
+        `[live-tokens] Unknown key(s) in live-tokens.config.json: ${unknown.join(", ")}. Known keys: ${Array.from(KNOWN_CONFIG_KEYS).join(", ")}.`
+      );
+    }
+    cached = parsed;
+    return cached;
+  } catch {
+    return cached = {};
+  }
+}
+function resolveDataDirs(opts = {}) {
+  const fileConfig = readLiveTokensConfig();
+  const dataDirRaw = opts.dataDir ?? fileConfig.dataDir ?? DEFAULT_DATA_DIR;
+  const dataDir = import_path.default.resolve(dataDirRaw);
+  const sub = (name) => import_path.default.resolve(dataDir, name);
+  return {
+    dataDir,
+    colorsAndTypeDir: opts.colorsAndTypeDir ? import_path.default.resolve(opts.colorsAndTypeDir) : fileConfig.colorsAndTypeDir ? import_path.default.resolve(fileConfig.colorsAndTypeDir) : sub("colors-and-type"),
+    componentConfigsDir: opts.componentConfigsDir ? import_path.default.resolve(opts.componentConfigsDir) : fileConfig.componentConfigsDir ? import_path.default.resolve(fileConfig.componentConfigsDir) : sub("component-configs"),
+    themesDir: opts.themesDir ? import_path.default.resolve(opts.themesDir) : fileConfig.themesDir ? import_path.default.resolve(fileConfig.themesDir) : sub("themes"),
+    legacyManifestsDir: fileConfig.manifestsDir ? import_path.default.resolve(fileConfig.manifestsDir) : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  adjustAliases,
+  matchesKind,
+  readLiveTokensConfig,
+  resolveDataDirs
+});

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

@@ -0,0 +1,45 @@
+import { A as AliasDiskValue, a as ComponentConfig } from '../themeTypes-DMHZOnUn.cjs';
+export { r as readLiveTokensConfig, a as resolveDataDirs } from '../dataPaths-DBN0RPuT.cjs';
+
+type AdjustKind = 'radius' | 'padding' | 'gap' | 'border-width';
+interface AdjustOp {
+    /** Component id; omitted applies the op to every config. */
+    target?: string;
+    kind: AdjustKind;
+    set?: string;
+    shift?: number;
+    /** Radius shifts only: admits `--radius-full` as the ladder's top rung. */
+    full?: boolean;
+}
+type SkipReason = 'raw-value' | 'off-ladder' | 'clamped' | 'pill-preserved';
+interface AliasChange {
+    variable: string;
+    from: string;
+    to: string;
+}
+interface AliasSkip {
+    variable: string;
+    value: AliasDiskValue;
+    reason: SkipReason;
+}
+interface ComponentReport {
+    component: string;
+    changes: AliasChange[];
+    skips: AliasSkip[];
+}
+interface AdjustReport {
+    components: ComponentReport[];
+}
+interface AdjustResult {
+    configs: Record<string, ComponentConfig>;
+    report: AdjustReport;
+}
+declare function adjustAliases(configs: Record<string, ComponentConfig>, ops: readonly AdjustOp[], now: string): AdjustResult;
+
+type TokenKind = 'surface' | 'border' | 'border-width' | 'radius' | 'divider-width' | 'divider-height' | 'divider-inset' | 'dot-size' | 'blur' | 'scale' | 'shadow' | 'font-family' | 'font-weight' | 'font-size' | 'line-height' | 'letter-spacing' | 'padding' | 'gap' | 'duration' | 'easing' | 'text-color';
+/** Side-aware kind test. Per-side paddings (`--card-default-body-padding-top`)
+    are written by UIPaddingSelector and never declared as editor tokens, so
+    `rawKind` never meets one; the CLI does, and they belong with their parent. */
+declare function matchesKind(variable: string, kind: TokenKind): boolean;
+
+export { type AdjustKind, type AdjustOp, type AdjustReport, type AdjustResult, type AliasChange, type AliasSkip, type ComponentReport, type SkipReason, adjustAliases, matchesKind };