@motion-proto/live-tokens 0.47.0 → 0.48.0

package/dist-plugin/migrateData/index.cjs

@@ -0,0 +1,728 @@
+"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/migrateData/index.ts
+var migrateData_exports = {};
+__export(migrateData_exports, {
+  migrateData: () => migrateData,
+  readLiveTokensConfig: () => readLiveTokensConfig,
+  resolveDataDirs: () => resolveDataDirs
+});
+module.exports = __toCommonJS(migrateData_exports);
+
+// vite-plugin/migrateData/migrateData.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+
+// vite-plugin/files/versionedFileResourceServer.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+function versionedFileResourceServer(opts) {
+  const dir = opts.dir;
+  const activePath = import_path.default.join(dir, "_active.json");
+  const productionPath = import_path.default.join(dir, "_production.json");
+  const workingPath = import_path.default.join(dir, "_working.json");
+  const defaultName = opts.defaultName ?? "default";
+  const resolvedDir = import_path.default.resolve(dir);
+  const resolvedPackageDir = opts.packageDir ? import_path.default.resolve(opts.packageDir) : null;
+  function ensureDir() {
+    if (!import_fs.default.existsSync(dir)) {
+      import_fs.default.mkdirSync(dir, { recursive: true });
+    }
+  }
+  function ensureMeta() {
+    if (!import_fs.default.existsSync(activePath)) {
+      import_fs.default.writeFileSync(activePath, JSON.stringify({ activeFile: defaultName }));
+    }
+    if (!import_fs.default.existsSync(productionPath)) {
+      import_fs.default.writeFileSync(productionPath, JSON.stringify({ productionFile: defaultName }));
+    }
+  }
+  function filePath(name) {
+    return import_path.default.join(dir, `${name}.json`);
+  }
+  function existingPath(name) {
+    const local = filePath(name);
+    if (import_fs.default.existsSync(local)) return local;
+    if (resolvedPackageDir) {
+      const pkg = import_path.default.join(resolvedPackageDir, `${name}.json`);
+      if (import_fs.default.existsSync(pkg)) return pkg;
+    }
+    return null;
+  }
+  function isPackageFile(name) {
+    if (!resolvedPackageDir) return false;
+    const pkg = import_path.default.join(resolvedPackageDir, `${name}.json`);
+    if (!import_fs.default.existsSync(pkg)) return false;
+    const local = import_path.default.resolve(filePath(name));
+    if (local === pkg) {
+      return opts.packageOwnedNames ? opts.packageOwnedNames.includes(name) : true;
+    }
+    return !import_fs.default.existsSync(local);
+  }
+  function readJson(name) {
+    const resolved = existingPath(name);
+    if (!resolved) return null;
+    return JSON.parse(import_fs.default.readFileSync(resolved, "utf-8"));
+  }
+  function listNames() {
+    const names = [];
+    const seen = /* @__PURE__ */ new Set();
+    const collect = (d) => {
+      if (!d || !import_fs.default.existsSync(d)) return;
+      for (const f of import_fs.default.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(import_fs.default.readFileSync(activePath, "utf-8"));
+      return data.activeFile || defaultName;
+    } catch {
+      return defaultName;
+    }
+  }
+  function getProductionName() {
+    try {
+      const data = JSON.parse(import_fs.default.readFileSync(productionPath, "utf-8"));
+      return data.productionFile || defaultName;
+    } catch {
+      return defaultName;
+    }
+  }
+  function setActiveName(name) {
+    import_fs.default.writeFileSync(activePath, JSON.stringify({ activeFile: name }));
+  }
+  function setProductionName(name) {
+    import_fs.default.writeFileSync(productionPath, JSON.stringify({ productionFile: name }));
+  }
+  function hasWorking() {
+    return import_fs.default.existsSync(workingPath);
+  }
+  function readWorking() {
+    if (!import_fs.default.existsSync(workingPath)) return null;
+    const parsed = JSON.parse(import_fs.default.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();
+    import_fs.default.writeFileSync(workingPath, JSON.stringify(data, null, 2));
+  }
+  function clearWorking() {
+    if (import_fs.default.existsSync(workingPath)) import_fs.default.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
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+function jsonFiles(dir) {
+  if (!import_fs2.default.existsSync(dir)) return [];
+  try {
+    return import_fs2.default.readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => import_path2.default.join(dir, f));
+  } catch {
+    return [];
+  }
+}
+function isDirectory(dir) {
+  try {
+    return import_fs2.default.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseJsonFile(file) {
+  try {
+    return JSON.parse(import_fs2.default.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function holdsATheme(themesDir) {
+  return jsonFiles(themesDir).some((file) => {
+    if (import_path2.default.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 ?? import_path2.default.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 (import_path2.default.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) => import_path2.default.join(input.themesDir, name)).find((p) => import_fs2.default.existsSync(p));
+  if (pointer && !themesHoldAThemeFile && !import_fs2.default.existsSync(input.colorsAndTypeDir)) {
+    return {
+      manifestsDir,
+      evidence: `${pointer} points at colors and type, and there is no ${import_path2.default.basename(input.colorsAndTypeDir)} directory`
+    };
+  }
+  return null;
+}
+function planLegacyRenames(layout, input) {
+  const defaultColorsAndType = import_path2.default.join(input.dataDir, "colors-and-type");
+  const defaultThemes = import_path2.default.join(input.dataDir, "themes");
+  if (input.configuredManifestsDir && import_path2.default.resolve(input.configuredManifestsDir) !== import_path2.default.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 (import_path2.default.resolve(input.colorsAndTypeDir) !== import_path2.default.resolve(defaultColorsAndType) || import_path2.default.resolve(input.themesDir) !== import_path2.default.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 (import_fs2.default.existsSync(input.themesDir)) {
+    renames.push({ from: input.themesDir, to: input.colorsAndTypeDir });
+  }
+  if (import_fs2.default.existsSync(layout.manifestsDir)) {
+    renames.push({ from: layout.manifestsDir, to: input.themesDir });
+  }
+  return renames;
+}
+function applyLegacyRenames(renames) {
+  for (const { from, to } of renames) {
+    if (import_fs2.default.existsSync(to)) {
+      const contents = import_fs2.default.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.`
+        );
+      }
+      import_fs2.default.rmdirSync(to);
+    }
+    import_fs2.default.mkdirSync(import_path2.default.dirname(to), { recursive: true });
+    import_fs2.default.renameSync(from, to);
+  }
+}
+
+// vite-plugin/migrateData/migrateData.ts
+var RECOVERED_SLUG = "recovered-production";
+var RECOVERED_NAME = "Recovered production";
+var MARKER_KEYS = ["_fileName", "_source"];
+var VOLATILE_KEYS = [...MARKER_KEYS, "updatedAt"];
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function sortDeep(value) {
+  if (Array.isArray(value)) return value.map(sortDeep);
+  if (!isObject(value)) return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) out[key] = sortDeep(value[key]);
+  return out;
+}
+function comparable(value) {
+  if (!isObject(value)) return JSON.stringify(sortDeep(value));
+  const stable = {};
+  for (const key of Object.keys(value).sort()) {
+    if (VOLATILE_KEYS.includes(key)) continue;
+    stable[key] = sortDeep(value[key]);
+  }
+  return JSON.stringify(stable);
+}
+function sameContent(a, b) {
+  return comparable(a) === comparable(b);
+}
+function stripMarkers(value) {
+  const out = {};
+  for (const [key, v] of Object.entries(value)) {
+    if (!MARKER_KEYS.includes(key)) out[key] = v;
+  }
+  return out;
+}
+function readPointerName(file, key) {
+  if (!import_fs3.default.existsSync(file)) return null;
+  try {
+    const name = JSON.parse(import_fs3.default.readFileSync(file, "utf-8"))[key];
+    return typeof name === "string" && name ? name : null;
+  } catch {
+    return null;
+  }
+}
+function localNamedFiles(dir) {
+  if (!import_fs3.default.existsSync(dir)) return [];
+  return import_fs3.default.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith("_")).map((f) => f.slice(0, -".json".length)).filter((name) => name !== "default");
+}
+function componentNames(componentConfigsDir) {
+  if (!import_fs3.default.existsSync(componentConfigsDir)) return [];
+  return import_fs3.default.readdirSync(componentConfigsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+}
+function shippedNames(packageDataDir, subdir) {
+  try {
+    const pkgRoot = import_path3.default.resolve(packageDataDir, "..", "..", "..");
+    const pkg = JSON.parse(import_fs3.default.readFileSync(import_path3.default.join(pkgRoot, "package.json"), "utf-8"));
+    const files = Array.isArray(pkg.files) ? pkg.files : [];
+    const prefix = `src/live-tokens/data/${subdir}/`;
+    return files.filter((f) => f.startsWith(prefix) && /^[^/]+\.json$/.test(f.slice(prefix.length))).map((f) => import_path3.default.basename(f, ".json"));
+  } catch {
+    return [];
+  }
+}
+function migrateData(opts) {
+  const { componentConfigsDir, check = false } = opts;
+  const packageDataDir = opts.packageDataDir;
+  const layoutInput = {
+    dataDir: opts.dataDir,
+    colorsAndTypeDir: opts.colorsAndTypeDir,
+    themesDir: opts.themesDir,
+    configuredManifestsDir: opts.legacyManifestsDir
+  };
+  const legacyLayout = detectLegacyLayout(layoutInput);
+  const renames = legacyLayout ? planLegacyRenames(legacyLayout, layoutInput) : [];
+  if (legacyLayout && !check) applyLegacyRenames(renames);
+  const planningLegacy = legacyLayout !== null && check;
+  const colorsAndTypeDir = planningLegacy ? opts.themesDir : opts.colorsAndTypeDir;
+  const themesDir = planningLegacy ? legacyLayout.manifestsDir : opts.themesDir;
+  const reported = (p) => {
+    if (!planningLegacy) return p;
+    for (const { from, to } of renames) {
+      if (p.startsWith(from + import_path3.default.sep)) return import_path3.default.join(to, p.slice(from.length + 1));
+    }
+    return p;
+  };
+  const colorsRes = versionedFileResourceServer({
+    dir: colorsAndTypeDir,
+    packageDir: packageDataDir ? import_path3.default.join(packageDataDir, "colors-and-type") : void 0,
+    packageOwnedNames: packageDataDir ? shippedNames(packageDataDir, "colors-and-type") : void 0
+  });
+  const themesRes = versionedFileResourceServer({
+    dir: themesDir,
+    packageDir: packageDataDir ? import_path3.default.join(packageDataDir, "themes") : void 0
+  });
+  const componentResources = /* @__PURE__ */ new Map();
+  const compRes = (comp) => {
+    let r = componentResources.get(comp);
+    if (!r) {
+      r = versionedFileResourceServer({
+        dir: import_path3.default.join(componentConfigsDir, comp),
+        packageDir: packageDataDir ? import_path3.default.join(packageDataDir, "component-configs", comp) : void 0,
+        packageOwnedNames: packageDataDir ? shippedNames(packageDataDir, `component-configs/${comp}`) : void 0
+      });
+      componentResources.set(comp, r);
+    }
+    return r;
+  };
+  const comps = componentNames(componentConfigsDir);
+  const legacyPointers = [];
+  for (const dir of [colorsAndTypeDir, ...comps.map((c) => import_path3.default.join(componentConfigsDir, c))]) {
+    for (const name of ["_active.json", "_production.json"]) {
+      const p = import_path3.default.join(dir, name);
+      if (import_fs3.default.existsSync(p)) legacyPointers.push(p);
+    }
+  }
+  const empty = {
+    status: "clean",
+    renames,
+    production: null,
+    recoveredThemePath: null,
+    workingWritten: [],
+    workingKept: [],
+    deletedFiles: [],
+    deletedPointers: [],
+    keptUserFiles: [],
+    notThemes: [],
+    droppedRefs: [],
+    shadowedDefaults: [],
+    upgradedThemes: []
+  };
+  if (legacyPointers.length === 0) {
+    if (!legacyLayout) return empty;
+    return { ...empty, status: check ? "planned" : "healed" };
+  }
+  const resolvers = {
+    readColorsAndType: (name) => colorsRes.readJson(name),
+    readComponentConfig: (comp, name) => compRes(comp).readJson(name),
+    normalizeColorsAndType: (colorsAndType) => colorsAndType
+  };
+  const upgradedThemes = [];
+  const notThemes = [];
+  const droppedRefs = [];
+  const themes = [];
+  for (const slug of themesRes.listNames()) {
+    let raw;
+    try {
+      raw = themesRes.readJson(slug);
+    } catch {
+      continue;
+    }
+    if (!raw) continue;
+    if (isColorsAndTypeShaped(raw)) {
+      notThemes.push(themesRes.filePath(slug));
+      continue;
+    }
+    const { theme, migrated, dropped } = normalizeTheme(raw, resolvers);
+    themes.push({ slug, theme });
+    for (const ref of dropped) {
+      droppedRefs.push(
+        `theme "${slug}": the reference ${ref} resolved to nothing, so it carries the shipped default instead`
+      );
+    }
+    if (migrated && import_fs3.default.existsSync(themesRes.filePath(slug))) {
+      upgradedThemes.push(themesRes.filePath(slug));
+      if (!check) import_fs3.default.writeFileSync(themesRes.filePath(slug), JSON.stringify(theme, null, 2));
+    }
+  }
+  const themeBySlug = new Map(themes.map((t) => [t.slug, t.theme]));
+  const resolveName = (res, dir, file, key) => {
+    const name = readPointerName(import_path3.default.join(dir, file), key);
+    if (!name || res.existingPath(name) === null) return "default";
+    return name;
+  };
+  const readPointed = (res, name) => {
+    try {
+      return res.readJson(name);
+    } catch (err) {
+      const file = res.existingPath(name) ?? res.filePath(name);
+      throw new Error(
+        `${file} will not parse (${err instanceof Error ? err.message : String(err)}), and a retired pointer names it. Fix or delete the file, then run the migration again.`
+      );
+    }
+  };
+  const defaultConfig = (comp) => compRes(comp).readJson("default");
+  const themeConfigFor = (theme, comp) => {
+    const embedded = theme.componentConfigs[comp];
+    return embedded ? { ...embedded, component: comp } : defaultConfig(comp);
+  };
+  const prodColorsName = resolveName(colorsRes, colorsAndTypeDir, "_production.json", "productionFile");
+  const prodConfigNames = new Map(
+    comps.map((comp) => [
+      comp,
+      resolveName(compRes(comp), import_path3.default.join(componentConfigsDir, comp), "_production.json", "productionFile")
+    ])
+  );
+  const prodColors = readPointed(colorsRes, prodColorsName);
+  const prodConfigs = new Map(
+    comps.map((comp) => [comp, readPointed(compRes(comp), prodConfigNames.get(comp))])
+  );
+  const allDefault = prodColorsName === "default" && [...prodConfigNames.values()].every((n) => n === "default");
+  const matchesPointedProduction = (theme) => sameContent(theme.colorsAndType, prodColors) && comps.every((comp) => sameContent(themeConfigFor(theme, comp), prodConfigs.get(comp)));
+  let production;
+  let recoveredTheme = null;
+  let recoveredThemePath = null;
+  if (allDefault) {
+    production = { slug: "default", how: "all-default" };
+  } else {
+    const match = themes.find((t) => matchesPointedProduction(t.theme));
+    if (match) {
+      production = { slug: match.slug, how: "matched" };
+    } else {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const componentConfigs = {};
+      for (const comp of comps) {
+        const pointed = prodConfigs.get(comp);
+        if (!isObject(pointed)) continue;
+        if (sameContent(pointed, defaultConfig(comp))) continue;
+        componentConfigs[comp] = stripMarkers(pointed);
+      }
+      recoveredTheme = {
+        name: RECOVERED_NAME,
+        createdAt: now,
+        updatedAt: now,
+        schemaVersion: THEME_SCHEMA_VERSION,
+        colorsAndType: isObject(prodColors) ? stripMarkers(prodColors) : null,
+        componentConfigs
+      };
+      const slug = nextAvailableName((n) => themesRes.existingPath(n) !== null, RECOVERED_SLUG);
+      recoveredThemePath = themesRes.filePath(slug);
+      production = { slug, how: "recovered" };
+    }
+  }
+  const activeThemeSlug = themesRes.getActiveName();
+  const activeTheme = themeBySlug.get(activeThemeSlug) ?? null;
+  const workingWritten = [];
+  const workingKept = [];
+  const planWorking = (res, live, saved) => {
+    if (!isObject(live) || sameContent(live, saved)) return;
+    if (res.hasWorking()) {
+      workingKept.push(res.workingPath);
+      return;
+    }
+    workingWritten.push(res.workingPath);
+    if (!check) res.writeWorking(stripMarkers(live));
+  };
+  const activeColorsName = resolveName(colorsRes, colorsAndTypeDir, "_active.json", "activeFile");
+  planWorking(
+    colorsRes,
+    readPointed(colorsRes, activeColorsName),
+    activeTheme?.colorsAndType ?? colorsRes.readJson("default")
+  );
+  for (const comp of comps) {
+    const activeName = resolveName(
+      compRes(comp),
+      import_path3.default.join(componentConfigsDir, comp),
+      "_active.json",
+      "activeFile"
+    );
+    planWorking(
+      compRes(comp),
+      readPointed(compRes(comp), activeName),
+      activeTheme ? themeConfigFor(activeTheme, comp) : defaultConfig(comp)
+    );
+  }
+  const deletedFiles = [];
+  const keptUserFiles = [];
+  const sweep = (res, dir, savedCopies) => {
+    for (const name of localNamedFiles(dir)) {
+      if (res.isPackageFile(name)) continue;
+      let content;
+      try {
+        content = res.readJson(name);
+      } catch {
+        keptUserFiles.push(res.filePath(name));
+        continue;
+      }
+      const matched = themes.some((t) => sameContent(savedCopies(t.theme), content));
+      if (!matched) {
+        keptUserFiles.push(res.filePath(name));
+        continue;
+      }
+      deletedFiles.push(res.filePath(name));
+      if (!check) import_fs3.default.unlinkSync(res.filePath(name));
+    }
+  };
+  sweep(colorsRes, colorsAndTypeDir, (theme) => theme.colorsAndType);
+  for (const comp of comps) {
+    sweep(compRes(comp), import_path3.default.join(componentConfigsDir, comp), (theme) => themeConfigFor(theme, comp));
+  }
+  const shadowedDefaults = [];
+  const localDefault = import_path3.default.join(colorsAndTypeDir, "default.json");
+  const packageDefault = packageDataDir ? import_path3.default.join(packageDataDir, "colors-and-type", "default.json") : null;
+  if (packageDefault && import_fs3.default.existsSync(localDefault) && import_fs3.default.existsSync(packageDefault) && import_path3.default.resolve(localDefault) !== import_path3.default.resolve(packageDefault)) {
+    try {
+      const local = JSON.parse(import_fs3.default.readFileSync(localDefault, "utf-8"));
+      const shipped = JSON.parse(import_fs3.default.readFileSync(packageDefault, "utf-8"));
+      if (!sameContent(local, shipped)) shadowedDefaults.push(localDefault);
+    } catch {
+    }
+  }
+  if (!check) {
+    for (const p of legacyPointers) import_fs3.default.unlinkSync(p);
+  }
+  if (!check) {
+    if (recoveredTheme && recoveredThemePath) {
+      themesRes.ensureDir();
+      import_fs3.default.writeFileSync(recoveredThemePath, JSON.stringify(recoveredTheme, null, 2));
+    }
+    themesRes.ensureDir();
+    themesRes.setProductionName(production.slug);
+  }
+  return {
+    status: check ? "planned" : "healed",
+    renames,
+    production,
+    recoveredThemePath: recoveredThemePath && reported(recoveredThemePath),
+    workingWritten: workingWritten.map(reported),
+    workingKept: workingKept.map(reported),
+    deletedFiles: deletedFiles.map(reported),
+    deletedPointers: legacyPointers.map(reported),
+    keptUserFiles: keptUserFiles.map(reported),
+    notThemes: notThemes.map(reported),
+    droppedRefs,
+    shadowedDefaults: shadowedDefaults.map(reported),
+    upgradedThemes: upgradedThemes.map(reported)
+  };
+}
+
+// vite-plugin/files/dataPaths.ts
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path4 = __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_path4.default.resolve("live-tokens.config.json");
+    if (!import_fs4.default.existsSync(configPath)) return cached = {};
+    const parsed = JSON.parse(import_fs4.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_path4.default.resolve(dataDirRaw);
+  const sub = (name) => import_path4.default.resolve(dataDir, name);
+  return {
+    dataDir,
+    colorsAndTypeDir: opts.colorsAndTypeDir ? import_path4.default.resolve(opts.colorsAndTypeDir) : fileConfig.colorsAndTypeDir ? import_path4.default.resolve(fileConfig.colorsAndTypeDir) : sub("colors-and-type"),
+    componentConfigsDir: opts.componentConfigsDir ? import_path4.default.resolve(opts.componentConfigsDir) : fileConfig.componentConfigsDir ? import_path4.default.resolve(fileConfig.componentConfigsDir) : sub("component-configs"),
+    themesDir: opts.themesDir ? import_path4.default.resolve(opts.themesDir) : fileConfig.themesDir ? import_path4.default.resolve(fileConfig.themesDir) : sub("themes"),
+    legacyManifestsDir: fileConfig.manifestsDir ? import_path4.default.resolve(fileConfig.manifestsDir) : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  migrateData,
+  readLiveTokensConfig,
+  resolveDataDirs
+});