@motion-proto/live-tokens 0.47.1 → 0.48.0

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

@@ -0,0 +1,45 @@
+import { A as AliasDiskValue, a as ComponentConfig } from '../themeTypes-DMHZOnUn.js';
+export { r as readLiveTokensConfig, a as resolveDataDirs } from '../dataPaths-DBN0RPuT.js';
+
+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 };

package/dist-plugin/adjust/index.js

@@ -0,0 +1,176 @@
+import {
+  readLiveTokensConfig,
+  resolveDataDirs
+} from "../chunk-D3ZVKOR4.js";
+
+// 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()] } };
+}
+export {
+  adjustAliases,
+  matchesKind,
+  readLiveTokensConfig,
+  resolveDataDirs
+};

package/dist-plugin/{chunk-H4TRUINI.js → chunk-44RSTAII.js}

@@ -350,52 +350,6 @@ var tokensCssMigration_2026_07_20_semanticTextStyles = {
   }
 };
 
-// vite-plugin/files/dataPaths.ts
-import fs from "fs";
-import path from "path";
-var DEFAULT_DATA_DIR = "src/live-tokens/data";
-var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "dataDir",
-  "themesDir",
-  "componentConfigsDir",
-  "manifestsDir",
-  "tokensCssPath"
-]);
-var cached = null;
-function readLiveTokensConfig() {
-  if (cached) return cached;
-  try {
-    const configPath = path.resolve("live-tokens.config.json");
-    if (!fs.existsSync(configPath)) return cached = {};
-    const parsed = JSON.parse(fs.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 = path.resolve(dataDirRaw);
-  const sub = (name) => path.resolve(dataDir, name);
-  return {
-    dataDir,
-    themesDir: opts.themesDir ? path.resolve(opts.themesDir) : fileConfig.themesDir ? path.resolve(fileConfig.themesDir) : sub("themes"),
-    componentConfigsDir: opts.componentConfigsDir ? path.resolve(opts.componentConfigsDir) : fileConfig.componentConfigsDir ? path.resolve(fileConfig.componentConfigsDir) : sub("component-configs"),
-    manifestsDir: opts.manifestsDir ? path.resolve(opts.manifestsDir) : fileConfig.manifestsDir ? path.resolve(fileConfig.manifestsDir) : sub("manifests")
-  };
-}
-
 // vite-plugin/tokensCssMigrations/index.ts
 var TOKENS_CSS_MIGRATIONS = [
   tokensCssMigration_2026_05_29_typographyScaleAdditions,
@@ -491,8 +445,6 @@ function validateTokensCss(input) {
 
 export {
   extractGlobalRootBody,
-  readLiveTokensConfig,
-  resolveDataDirs,
   collectDefinedTokens,
   collectReferencedTokens,
   ensureScale,

package/dist-plugin/chunk-6OZFXIQI.js

@@ -0,0 +1,316 @@
+// vite-plugin/files/versionedFileResourceServer.ts
+import fs from "fs";
+import path from "path";
+function versionedFileResourceServer(opts) {
+  const dir = opts.dir;
+  const activePath = path.join(dir, "_active.json");
+  const productionPath = path.join(dir, "_production.json");
+  const workingPath = path.join(dir, "_working.json");
+  const defaultName = opts.defaultName ?? "default";
+  const resolvedDir = path.resolve(dir);
+  const resolvedPackageDir = opts.packageDir ? path.resolve(opts.packageDir) : null;
+  function ensureDir() {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  function ensureMeta() {
+    if (!fs.existsSync(activePath)) {
+      fs.writeFileSync(activePath, JSON.stringify({ activeFile: defaultName }));
+    }
+    if (!fs.existsSync(productionPath)) {
+      fs.writeFileSync(productionPath, JSON.stringify({ productionFile: defaultName }));
+    }
+  }
+  function filePath(name) {
+    return path.join(dir, `${name}.json`);
+  }
+  function existingPath(name) {
+    const local = filePath(name);
+    if (fs.existsSync(local)) return local;
+    if (resolvedPackageDir) {
+      const pkg = path.join(resolvedPackageDir, `${name}.json`);
+      if (fs.existsSync(pkg)) return pkg;
+    }
+    return null;
+  }
+  function isPackageFile(name) {
+    if (!resolvedPackageDir) return false;
+    const pkg = path.join(resolvedPackageDir, `${name}.json`);
+    if (!fs.existsSync(pkg)) return false;
+    const local = path.resolve(filePath(name));
+    if (local === pkg) {
+      return opts.packageOwnedNames ? opts.packageOwnedNames.includes(name) : true;
+    }
+    return !fs.existsSync(local);
+  }
+  function readJson(name) {
+    const resolved = existingPath(name);
+    if (!resolved) return null;
+    return JSON.parse(fs.readFileSync(resolved, "utf-8"));
+  }
+  function listNames() {
+    const names = [];
+    const seen = /* @__PURE__ */ new Set();
+    const collect = (d) => {
+      if (!d || !fs.existsSync(d)) return;
+      for (const f of fs.readdirSync(d)) {
+        if (!f.endsWith(".json") || f.startsWith("_")) continue;
+        const name = f.slice(0, -".json".length);
+        if (seen.has(name)) continue;
+        seen.add(name);
+        names.push(name);
+      }
+    };
+    collect(resolvedDir);
+    if (resolvedPackageDir && resolvedPackageDir !== resolvedDir) collect(resolvedPackageDir);
+    return names;
+  }
+  function getActiveName() {
+    try {
+      const data = JSON.parse(fs.readFileSync(activePath, "utf-8"));
+      return data.activeFile || defaultName;
+    } catch {
+      return defaultName;
+    }
+  }
+  function getProductionName() {
+    try {
+      const data = JSON.parse(fs.readFileSync(productionPath, "utf-8"));
+      return data.productionFile || defaultName;
+    } catch {
+      return defaultName;
+    }
+  }
+  function setActiveName(name) {
+    fs.writeFileSync(activePath, JSON.stringify({ activeFile: name }));
+  }
+  function setProductionName(name) {
+    fs.writeFileSync(productionPath, JSON.stringify({ productionFile: name }));
+  }
+  function hasWorking() {
+    return fs.existsSync(workingPath);
+  }
+  function readWorking() {
+    if (!fs.existsSync(workingPath)) return null;
+    const parsed = JSON.parse(fs.readFileSync(workingPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`${workingPath} does not hold a JSON object`);
+    }
+    return parsed;
+  }
+  function writeWorking(data) {
+    ensureDir();
+    fs.writeFileSync(workingPath, JSON.stringify(data, null, 2));
+  }
+  function clearWorking() {
+    if (fs.existsSync(workingPath)) fs.unlinkSync(workingPath);
+  }
+  return {
+    dir,
+    activePath,
+    productionPath,
+    workingPath,
+    ensureDir,
+    ensureMeta,
+    filePath,
+    existingPath,
+    isPackageFile,
+    readJson,
+    listNames,
+    getActiveName,
+    getProductionName,
+    setActiveName,
+    setProductionName,
+    hasWorking,
+    readWorking,
+    writeWorking,
+    clearWorking
+  };
+}
+
+// vite-plugin/themes/normalizeTheme.ts
+var THEME_SCHEMA_VERSION = 3;
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function isColorsAndTypeShaped(raw) {
+  const obj = asObject(raw);
+  if (!obj) return false;
+  if ("theme" in obj || "colorsAndType" in obj) return false;
+  return "cssVariables" in obj || "editorConfigs" in obj;
+}
+function stripFileMarker(value) {
+  if (!("_fileName" in value)) return value;
+  const { _fileName, ...rest } = value;
+  return rest;
+}
+function asString(value, fallback) {
+  return typeof value === "string" && value ? value : fallback;
+}
+function migrateEmbeddedKey(src) {
+  const { theme, ...rest } = src;
+  return { ...rest, colorsAndType: theme };
+}
+function normalizeTheme(raw, resolvers) {
+  const input = asObject(raw) ?? {};
+  const migrated = input.schemaVersion !== THEME_SCHEMA_VERSION;
+  const src = migrated ? migrateEmbeddedKey(input) : input;
+  const dropped = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const embeddedColorsAndType = asObject(src.colorsAndType);
+  let colorsAndType = null;
+  if (embeddedColorsAndType) {
+    colorsAndType = stripFileMarker(embeddedColorsAndType);
+  } else {
+    const colorsAndTypeName = asString(src.colorsAndType, "default");
+    colorsAndType = asObject(resolvers.readColorsAndType(colorsAndTypeName));
+    if (!colorsAndType) {
+      dropped.push(`colors-and-type:${colorsAndTypeName}`);
+      if (colorsAndTypeName !== "default") colorsAndType = asObject(resolvers.readColorsAndType("default"));
+    }
+    if (colorsAndType) colorsAndType = resolvers.normalizeColorsAndType(stripFileMarker(colorsAndType));
+  }
+  const componentConfigs = {};
+  for (const [comp, value] of Object.entries(asObject(src.componentConfigs) ?? {})) {
+    const embedded = asObject(value);
+    if (embedded) {
+      componentConfigs[comp] = stripFileMarker(embedded);
+      continue;
+    }
+    const configName = asString(value, "default");
+    if (configName === "default") continue;
+    const resolved = asObject(resolvers.readComponentConfig(comp, configName));
+    if (!resolved) {
+      dropped.push(`${comp}/${configName}`);
+      continue;
+    }
+    componentConfigs[comp] = stripFileMarker(resolved);
+  }
+  return {
+    theme: {
+      name: asString(src.name, "Untitled"),
+      createdAt: asString(src.createdAt, now),
+      updatedAt: asString(src.updatedAt, now),
+      schemaVersion: THEME_SCHEMA_VERSION,
+      colorsAndType,
+      componentConfigs
+    },
+    dropped,
+    migrated
+  };
+}
+
+// vite-plugin/files/nameAllocator.ts
+function nextAvailableName(exists, baseName, maxAttempts = 1e3) {
+  if (!exists(baseName)) return baseName;
+  for (let i = 2; i < maxAttempts; i++) {
+    const candidate = `${baseName}-${i}`;
+    if (!exists(candidate)) return candidate;
+  }
+  throw new Error(`Could not allocate a non-colliding name for "${baseName}"`);
+}
+
+// vite-plugin/files/legacyLayout.ts
+import fs2 from "fs";
+import path2 from "path";
+function jsonFiles(dir) {
+  if (!fs2.existsSync(dir)) return [];
+  try {
+    return fs2.readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => path2.join(dir, f));
+  } catch {
+    return [];
+  }
+}
+function isDirectory(dir) {
+  try {
+    return fs2.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseJsonFile(file) {
+  try {
+    return JSON.parse(fs2.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function holdsATheme(themesDir) {
+  return jsonFiles(themesDir).some((file) => {
+    if (path2.basename(file).startsWith("_")) return false;
+    const raw = parseJsonFile(file);
+    if (!raw || typeof raw !== "object") return false;
+    return "colorsAndType" in raw || "theme" in raw;
+  });
+}
+function detectLegacyLayout(input) {
+  const manifestsDir = input.configuredManifestsDir ?? path2.join(input.dataDir, "manifests");
+  const themesHoldAThemeFile = holdsATheme(input.themesDir);
+  if (isDirectory(manifestsDir) && !themesHoldAThemeFile) {
+    return { manifestsDir, evidence: `${manifestsDir} is the pre-0.48 whole-look directory` };
+  }
+  if (jsonFiles(input.colorsAndTypeDir).length > 0) return null;
+  for (const file of jsonFiles(input.themesDir)) {
+    if (path2.basename(file).startsWith("_")) continue;
+    if (isColorsAndTypeShaped(parseJsonFile(file))) {
+      return { manifestsDir, evidence: `${file} is a colors-and-type file, not a theme` };
+    }
+  }
+  const pointer = ["_active.json", "_production.json"].map((name) => path2.join(input.themesDir, name)).find((p) => fs2.existsSync(p));
+  if (pointer && !themesHoldAThemeFile && !fs2.existsSync(input.colorsAndTypeDir)) {
+    return {
+      manifestsDir,
+      evidence: `${pointer} points at colors and type, and there is no ${path2.basename(input.colorsAndTypeDir)} directory`
+    };
+  }
+  return null;
+}
+function planLegacyRenames(layout, input) {
+  const defaultColorsAndType = path2.join(input.dataDir, "colors-and-type");
+  const defaultThemes = path2.join(input.dataDir, "themes");
+  if (input.configuredManifestsDir && path2.resolve(input.configuredManifestsDir) !== path2.join(input.dataDir, "manifests")) {
+    throw new Error(
+      `This project uses the pre-0.48 data layout (${layout.evidence}), and live-tokens.config.json sets the retired "manifestsDir" key to ${input.configuredManifestsDir}. That directory holds the whole looks, which now belong in ${input.themesDir}. Move it there by hand, drop the "manifestsDir" key, then run the migration again.`
+    );
+  }
+  if (path2.resolve(input.colorsAndTypeDir) !== path2.resolve(defaultColorsAndType) || path2.resolve(input.themesDir) !== path2.resolve(defaultThemes)) {
+    throw new Error(
+      `This project uses the pre-0.48 data layout (${layout.evidence}), and its data directories are configured to custom paths (colorsAndTypeDir=${input.colorsAndTypeDir}, themesDir=${input.themesDir}). The migration cannot tell which directory holds what. Move the old colors-and-type directory to ${input.colorsAndTypeDir} and the old whole-look directory to ${input.themesDir} by hand, then run the migration again.`
+    );
+  }
+  const renames = [];
+  if (fs2.existsSync(input.themesDir)) {
+    renames.push({ from: input.themesDir, to: input.colorsAndTypeDir });
+  }
+  if (fs2.existsSync(layout.manifestsDir)) {
+    renames.push({ from: layout.manifestsDir, to: input.themesDir });
+  }
+  return renames;
+}
+function applyLegacyRenames(renames) {
+  for (const { from, to } of renames) {
+    if (fs2.existsSync(to)) {
+      const contents = fs2.readdirSync(to);
+      if (contents.length > 0) {
+        throw new Error(
+          `Cannot move ${from} to ${to}: ${to} already exists and holds ${contents.length} file(s). Move or delete it, then run the migration again.`
+        );
+      }
+      fs2.rmdirSync(to);
+    }
+    fs2.mkdirSync(path2.dirname(to), { recursive: true });
+    fs2.renameSync(from, to);
+  }
+}
+
+export {
+  versionedFileResourceServer,
+  THEME_SCHEMA_VERSION,
+  isColorsAndTypeShaped,
+  normalizeTheme,
+  nextAvailableName,
+  detectLegacyLayout,
+  planLegacyRenames,
+  applyLegacyRenames
+};