@teamix-evo/registry 0.2.0 → 0.5.0

package/dist/index.cjs

@@ -40,8 +40,14 @@ __export(index_exports, {
   SkillEntrySchema: () => SkillEntrySchema,
   SkillIdeSchema: () => SkillIdeSchema,
   SkillScopeSchema: () => SkillScopeSchema,
+  SkillsLockEntrySchema: () => SkillsLockEntrySchema,
+  SkillsLockSchema: () => SkillsLockSchema,
   SkillsPackageManifestSchema: () => SkillsPackageManifestSchema,
   TailwindVersionSchema: () => TailwindVersionSchema,
+  TokensPackLinkedSchema: () => TokensPackLinkedSchema,
+  TokensPackLockSchema: () => TokensPackLockSchema,
+  TokensPackageManifestSchema: () => TokensPackageManifestSchema,
+  TokensVariantEntrySchema: () => TokensVariantEntrySchema,
   UiAliasSchema: () => UiAliasSchema,
   UiAliasesSchema: () => UiAliasesSchema,
   UiEntryFileSchema: () => UiEntryFileSchema,
@@ -50,11 +56,18 @@ __export(index_exports, {
   UiPackageManifestSchema: () => UiPackageManifestSchema,
   UpdateStrategySchema: () => UpdateStrategySchema,
   VariantManifestSchema: () => VariantManifestSchema,
+  VariantUiPackageCatalogSchema: () => VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema: () => VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema: () => VariantUiPackageNameSchema,
   getUpdateAction: () => getUpdateAction,
+  getVariantEntry: () => getVariantEntry,
   hasManagedRegion: () => hasManagedRegion,
   loadSkillsPackageManifest: () => loadSkillsPackageManifest,
+  loadTokensPackageManifest: () => loadTokensPackageManifest,
   loadUiPackageManifest: () => loadUiPackageManifest,
   loadVariantManifest: () => loadVariantManifest,
+  loadVariantUiPackageCatalog: () => loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest: () => loadVariantUiPackageManifest,
   parseManagedRegions: () => parseManagedRegions,
   replaceManagedRegion: () => replaceManagedRegion,
   resolveUiEntryOrder: () => resolveUiEntryOrder,
@@ -62,6 +75,7 @@ __export(index_exports, {
   validateConfig: () => validateConfig,
   validateInstalled: () => validateInstalled,
   validateManifest: () => validateManifest,
+  validateSkillsLock: () => validateSkillsLock,
   validateSkillsPackage: () => validateSkillsPackage,
   validateUiDependencyGraph: () => validateUiDependencyGraph,
   validateUiPackage: () => validateUiPackage
@@ -152,7 +166,20 @@ var SkillEntrySchema = import_zod.z.object({
   /** Managed region IDs to maintain on update */
   managedRegions: import_zod.z.array(import_zod.z.string()).optional(),
   /** Whether the source is a Handlebars template */
-  template: import_zod.z.boolean().optional()
+  template: import_zod.z.boolean().optional(),
+  /**
+   * Variant identifier when this skill is bound to a specific design variant
+   * (e.g. `"opentrek"`, `"uni-manager"`). Optional — neutral skills (manage,
+   * coding-conventions, baseline design-rules) leave it unset.
+   *
+   * When present, the CLI installs this skill ONLY if the consumer's
+   * `.teamix-evo/tokens-lock.json` records the same variant. MUST equal
+   * the variant directory name in `@teamix-evo/tokens/variants/<name>/`.
+   *
+   * Mirrors `UiEntrySchema.variant` semantics in @teamix-evo/biz-ui &
+   * @teamix-evo/templates per ADR 0014.
+   */
+  variant: import_zod.z.string().optional()
 });
 var SkillsPackageManifestSchema = import_zod.z.object({
   $schema: import_zod.z.string().optional(),
@@ -172,9 +199,17 @@ var UiEntryTypeSchema = import_zod.z.enum([
   "component",
   "hook",
   "util",
-  "block"
+  "block",
+  "template"
+]);
+var UiAliasSchema = import_zod.z.enum([
+  "components",
+  "hooks",
+  "utils",
+  "lib",
+  "business",
+  "templates"
 ]);
-var UiAliasSchema = import_zod.z.enum(["components", "hooks", "utils", "lib"]);
 var UiEntryStatusSchema = import_zod.z.enum([
   "stable",
   "experimental",
@@ -204,8 +239,8 @@ var UiEntrySchema = import_zod.z.object({
   files: import_zod.z.array(UiEntryFileSchema).min(1),
   /**
    * Optional path to an AI-readable meta document (frontmatter + Markdown).
-   * When set, CLI install drops it at `.teamix-evo/design/components/<id>.meta.md`
-   * for design's ai-rules to consume.
+   * Read directly from `@teamix-evo/ui` by MCP at runtime — no consumer-side
+   * copy is written (per ADR 0020 §3).
    */
   meta: import_zod.z.string().optional(),
   /** Other UI entries this one depends on (e.g. "button" depends on "cn") */
@@ -237,7 +272,14 @@ var UiEntrySchema = import_zod.z.object({
    * If this entry is `deprecated`, the id of the entry that supersedes it.
    * Consumers (and AI) should migrate to `replacedBy` rather than this entry.
    */
-  replacedBy: import_zod.z.string().optional()
+  replacedBy: import_zod.z.string().optional(),
+  /**
+   * Variant identifier when this entry is shipped from a variant-aware
+   * package (`@teamix-evo/biz-ui` or `@teamix-evo/templates` per ADR 0014).
+   * Optional — entries from `@teamix-evo/ui` (variant-agnostic) leave it unset.
+   * MUST equal the variant directory name when present.
+   */
+  variant: import_zod.z.string().optional()
 });
 var UiPackageManifestSchema = import_zod.z.object({
   $schema: import_zod.z.string().optional(),
@@ -250,28 +292,160 @@ var UiPackageManifestSchema = import_zod.z.object({
   engines: import_zod.z.object({
     "teamix-evo": import_zod.z.string().min(1)
   }),
-  /** Flat list of entries shipped by this package */
-  entries: import_zod.z.array(UiEntrySchema)
+  /** Active list of entries shipped (and exposed) by this package. */
+  entries: import_zod.z.array(UiEntrySchema),
+  /**
+   * Archived entries that are kept in source for Storybook documentation only
+   * and are NOT exposed through the active distribution chain. Per ADR 0028:
+   *   - `teamix-evo ui add <id>` rejects ids found here unless `--include-deprecated` is passed
+   *   - MCP `list_components` / `find_components` exclude these by default
+   *   - Storybook keeps the story under `废弃 · Deprecated/` with a banner
+   * Optional for backwards compatibility — older manifests without this field
+   * still validate.
+   */
+  deprecatedEntries: import_zod.z.array(UiEntrySchema).optional()
 });
 
-// src/schema/config.ts
+// src/schema/tokens-pack.ts
 var import_zod2 = require("zod");
-var TailwindVersionSchema = import_zod2.z.enum(["v3", "v4"]);
-var UiAliasesSchema = import_zod2.z.object({
-  components: import_zod2.z.string().min(1),
-  hooks: import_zod2.z.string().min(1),
-  utils: import_zod2.z.string().min(1),
-  lib: import_zod2.z.string().min(1)
+var VARIANT_NAME_RE = /^[a-z][a-z0-9-]*$/;
+var SEMVER_RE = /^\d+\.\d+\.\d+/;
+var TokensPackLinkedSchema = import_zod2.z.object({
+  "biz-ui": import_zod2.z.string().optional(),
+  templates: import_zod2.z.string().optional()
+});
+var TokensVariantEntrySchema = import_zod2.z.object({
+  /** Variant id — lowercase kebab-case. */
+  name: import_zod2.z.string().min(1).regex(
+    VARIANT_NAME_RE,
+    "Variant name must be lowercase letters/digits/hyphens (no leading hyphen)."
+  ),
+  /** Human-readable display name (e.g. "OpenTrek" for variant id "opentrek"). */
+  displayName: import_zod2.z.string().min(1),
+  /** Variant version — semver. May trail the package version when only a subset of variants change. */
+  version: import_zod2.z.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Optional one-liner description; surfaced in `tokens list-variants` output. */
+  description: import_zod2.z.string().optional(),
+  /**
+   * Files this variant advertises, paths relative to the tokens package root
+   * (e.g. `variants/opentrek/theme.css`). The validator walks these to
+   * confirm presence; the CLI consumes them at install time.
+   */
+  files: import_zod2.z.array(import_zod2.z.string().min(1)).min(1),
+  /** Soft cross-package links (biz-ui / templates with the same variant name). */
+  linked: TokensPackLinkedSchema.optional()
+});
+var TokensPackageManifestSchema = import_zod2.z.object({
+  $schema: import_zod2.z.string().optional(),
+  schemaVersion: import_zod2.z.literal(1),
+  /** Always `"tokens"` — disambiguates from other teamix-evo package manifests. */
+  package: import_zod2.z.literal("tokens"),
+  /** Semver of the entire tokens package. */
+  version: import_zod2.z.string().regex(SEMVER_RE, "Invalid semver version"),
+  /** Engine compatibility. */
+  engines: import_zod2.z.object({ "teamix-evo": import_zod2.z.string().min(1) }),
+  /** Optional package-level description. */
+  description: import_zod2.z.string().optional(),
+  /** All shipped variants (excluding scaffold dirs that begin with `_`). */
+  variants: import_zod2.z.array(TokensVariantEntrySchema),
+  /**
+   * Reserved for future shared assets that span variants (e.g. browser
+   * quirks resets co-shipped at the package root). Empty array today.
+   */
+  shared: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var TokensPackLockSchema = import_zod2.z.object({
+  $schema: import_zod2.z.string().optional(),
+  schemaVersion: import_zod2.z.literal(1),
+  variant: import_zod2.z.object({
+    name: import_zod2.z.string().min(1),
+    displayName: import_zod2.z.string().min(1),
+    version: import_zod2.z.string().regex(SEMVER_RE),
+    from: import_zod2.z.string().min(1)
+    // e.g. "@teamix-evo/tokens"
+  }),
+  /** Tokens package version — useful when variant version trails the package. */
+  packageVersion: import_zod2.z.string().regex(SEMVER_RE),
+  linked: TokensPackLinkedSchema.optional(),
+  installedAt: import_zod2.z.string().datetime()
+});
+
+// src/schema/variant-ui-pack.ts
+var import_zod3 = require("zod");
+var SEMVER_RE2 = /^\d+\.\d+\.\d+/;
+var VARIANT_NAME_RE2 = /^[a-z][a-z0-9-]*$/;
+var VariantUiPackageNameSchema = import_zod3.z.enum(["biz-ui", "templates"]);
+var VariantUiPackageManifestSchema = import_zod3.z.object({
+  $schema: import_zod3.z.string().optional(),
+  schemaVersion: import_zod3.z.literal(1),
+  /** Discriminator. */
+  package: VariantUiPackageNameSchema,
+  /**
+   * Variant identifier — lowercase kebab-case, MUST match the parent
+   * directory name (e.g. `opentrek` for `variants/opentrek/manifest.json`).
+   * `_template` is also accepted for the variant scaffold.
+   */
+  variant: import_zod3.z.string().min(1).regex(
+    VARIANT_NAME_RE2,
+    'Variant id must be lowercase letters/digits/hyphens (no leading hyphen). Special: "_template" allowed.'
+  ).or(import_zod3.z.literal("_template")),
+  /** Semver of this variant. */
+  version: import_zod3.z.string().regex(SEMVER_RE2, "Invalid semver version"),
+  /** Engine compatibility. */
+  engines: import_zod3.z.object({ "teamix-evo": import_zod3.z.string().min(1) }),
+  /** Flat list of entries shipped by this variant. */
+  entries: import_zod3.z.array(UiEntrySchema)
+}).superRefine((data, ctx) => {
+  for (const [i, entry] of data.entries.entries()) {
+    if (entry.variant !== void 0 && entry.variant !== data.variant) {
+      ctx.addIssue({
+        code: import_zod3.z.ZodIssueCode.custom,
+        path: ["entries", i, "variant"],
+        message: `Entry "${entry.id}" declares variant "${entry.variant}" but lives in manifest of variant "${data.variant}".`
+      });
+    }
+  }
 });
-var PackageEntrySchema = import_zod2.z.object({
+var VariantUiPackageCatalogSchema = import_zod3.z.object({
+  $schema: import_zod3.z.string().optional(),
+  schemaVersion: import_zod3.z.literal(1),
+  package: VariantUiPackageNameSchema,
+  /** Semver of the entire package. */
+  version: import_zod3.z.string().regex(SEMVER_RE2, "Invalid semver version"),
+  engines: import_zod3.z.object({ "teamix-evo": import_zod3.z.string().min(1) }),
+  /** Variants this package ships (excluding `_template`). */
+  variants: import_zod3.z.array(
+    import_zod3.z.object({
+      name: import_zod3.z.string().min(1).regex(VARIANT_NAME_RE2),
+      displayName: import_zod3.z.string().min(1),
+      version: import_zod3.z.string().regex(SEMVER_RE2),
+      description: import_zod3.z.string().optional()
+    })
+  )
+});
+
+// src/schema/config.ts
+var import_zod4 = require("zod");
+var TailwindVersionSchema = import_zod4.z.literal("v4");
+var UiAliasesSchema = import_zod4.z.object({
+  components: import_zod4.z.string().min(1),
+  hooks: import_zod4.z.string().min(1),
+  utils: import_zod4.z.string().min(1),
+  lib: import_zod4.z.string().min(1),
+  /** Biz-ui components (variant-bound). Defaults to `src/components/business/`. */
+  business: import_zod4.z.string().min(1).default("src/components/business"),
+  /** Page templates (variant-bound). Defaults to `src/templates/`. */
+  templates: import_zod4.z.string().min(1).default("src/templates")
+});
+var PackageEntrySchema = import_zod4.z.object({
   /** Variant identifier (e.g. "opentrek"; use "_flat" for skills/ui) */
-  variant: import_zod2.z.string().min(1),
+  variant: import_zod4.z.string().min(1),
   /** Semver version string */
-  version: import_zod2.z.string().min(1),
+  version: import_zod4.z.string().min(1),
   /** Tailwind CSS version this project uses (only meaningful for design package). */
   tailwind: TailwindVersionSchema.optional(),
   /** IDEs this package was installed for (only meaningful for skills package). */
-  ides: import_zod2.z.array(SkillIdeSchema).optional(),
+  ides: import_zod4.z.array(SkillIdeSchema).optional(),
   /** Install scope (only meaningful for skills package). */
   scope: SkillScopeSchema.optional(),
   /** Path aliases for ui entry installation (only meaningful for ui package). */
@@ -280,53 +454,79 @@ var PackageEntrySchema = import_zod2.z.object({
    * Default icon library declared by the project (only meaningful for ui).
    * Declarative only — does NOT trigger code rewrites; ui entries hardcode imports.
    */
-  iconLibrary: import_zod2.z.string().min(1).optional(),
+  iconLibrary: import_zod4.z.string().min(1).optional(),
   /** Whether the project uses TSX (true) or JSX (false). ui-specific. */
-  tsx: import_zod2.z.boolean().optional(),
+  tsx: import_zod4.z.boolean().optional(),
   /** Whether to emit React Server Components markers (`"use client"`). ui-specific. */
-  rsc: import_zod2.z.boolean().optional()
+  rsc: import_zod4.z.boolean().optional()
 });
-var ProjectConfigSchema = import_zod2.z.object({
-  $schema: import_zod2.z.string().optional(),
-  schemaVersion: import_zod2.z.literal(1),
+var ProjectConfigSchema = import_zod4.z.object({
+  $schema: import_zod4.z.string().optional(),
+  schemaVersion: import_zod4.z.literal(1),
   /** IDE identifier */
-  ide: import_zod2.z.string().min(1),
+  ide: import_zod4.z.string().min(1),
   /** Installed packages keyed by package name */
-  packages: import_zod2.z.record(import_zod2.z.string(), PackageEntrySchema)
+  packages: import_zod4.z.record(import_zod4.z.string(), PackageEntrySchema)
 });
 
 // src/schema/installed.ts
-var import_zod3 = require("zod");
-var InstalledResourceSchema = import_zod3.z.object({
+var import_zod5 = require("zod");
+var InstalledResourceSchema = import_zod5.z.object({
   /** Resource identifier matching the variant manifest */
-  id: import_zod3.z.string().min(1),
+  id: import_zod5.z.string().min(1),
   /** Target path where the resource was installed (absolute or project-relative) */
-  target: import_zod3.z.string().min(1),
+  target: import_zod5.z.string().min(1),
   /** Content hash for change detection (e.g. "sha256:...") */
-  hash: import_zod3.z.string().min(1),
+  hash: import_zod5.z.string().min(1),
   /** Update strategy that was applied */
-  strategy: import_zod3.z.enum(["frozen", "regenerable", "managed"]),
+  strategy: import_zod5.z.enum(["frozen", "regenerable", "managed"]),
   /** IDE this resource was installed for (skill resources only) */
   ide: SkillIdeSchema.optional(),
   /** Install scope (skill resources only) */
   scope: SkillScopeSchema.optional()
 });
-var InstalledPackageSchema = import_zod3.z.object({
-  /** Full package name (e.g. "@teamix-evo/design") */
-  package: import_zod3.z.string().min(1),
+var InstalledPackageSchema = import_zod5.z.object({
+  /** Full package name (e.g. "@teamix-evo/tokens") */
+  package: import_zod5.z.string().min(1),
   /** Variant identifier (use "_flat" for non-variant packages such as skills) */
-  variant: import_zod3.z.string().min(1),
+  variant: import_zod5.z.string().min(1),
   /** Installed version */
-  version: import_zod3.z.string().min(1),
+  version: import_zod5.z.string().min(1),
   /** ISO 8601 timestamp of installation */
-  installedAt: import_zod3.z.string().min(1),
+  installedAt: import_zod5.z.string().min(1),
   /** List of installed resources */
-  resources: import_zod3.z.array(InstalledResourceSchema)
+  resources: import_zod5.z.array(InstalledResourceSchema)
 });
-var InstalledManifestSchema = import_zod3.z.object({
-  schemaVersion: import_zod3.z.literal(1),
+var InstalledManifestSchema = import_zod5.z.object({
+  schemaVersion: import_zod5.z.literal(1),
   /** List of installed packages */
-  installed: import_zod3.z.array(InstalledPackageSchema)
+  installed: import_zod5.z.array(InstalledPackageSchema)
+});
+
+// src/schema/skills-lock.ts
+var import_zod6 = require("zod");
+var SkillsLockEntrySchema = import_zod6.z.object({
+  /** Semver version installed from upstream */
+  version: import_zod6.z.string().min(1),
+  /** Upstream package name (typically `@teamix-evo/skills`) */
+  from: import_zod6.z.string().min(1),
+  /** ISO 8601 install / last-sync timestamp */
+  installedAt: import_zod6.z.string().min(1),
+  /** Install scope at time of mirror */
+  scope: SkillScopeSchema,
+  /**
+   * IDEs this skill was mirrored to. Each ide ↔ a mirror path under
+   * `<projectRoot>/.<ide>/skills/<id>/` (project) or `~/.<ide>/skills/<id>/`
+   * (global). The path itself is reconstructed from `scope` + adapter; we
+   * record the ide identifier rather than the full path to keep the lock
+   * portable across machines.
+   */
+  mirroredTo: import_zod6.z.array(SkillIdeSchema)
+});
+var SkillsLockSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(1),
+  /** Map of skill id → lock entry */
+  skills: import_zod6.z.record(import_zod6.z.string().min(1), SkillsLockEntrySchema)
 });
 
 // src/loader.ts
@@ -336,8 +536,8 @@ var path = __toESM(require("path"), 1);
 // src/validator.ts
 function formatZodError(error) {
   return error.issues.map((issue) => {
-    const path2 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-    return `  - ${path2}: ${issue.message}`;
+    const path4 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `  - ${path4}: ${issue.message}`;
   }).join("\n");
 }
 function validateManifest(data) {
@@ -373,6 +573,17 @@ function validateInstalled(data) {
 ${formatZodError(result.error)}`
   };
 }
+function validateSkillsLock(data) {
+  const result = SkillsLockSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: `Invalid skills lock:
+${formatZodError(result.error)}`
+  };
+}
 function validateSkillsPackage(data) {
   const result = SkillsPackageManifestSchema.safeParse(data);
   if (result.success) {
@@ -429,22 +640,22 @@ function validateUiDependencyGraph(entries) {
   const color = /* @__PURE__ */ new Map();
   for (const id of idToEntry.keys()) color.set(id, WHITE);
   const cycles = [];
-  function dfs(id, path2) {
+  function dfs(id, path4) {
     color.set(id, GRAY);
-    path2.push(id);
+    path4.push(id);
     const entry = idToEntry.get(id);
     const deps = entry?.registryDependencies ?? [];
     for (const dep of deps) {
       if (!idToEntry.has(dep)) continue;
       const c = color.get(dep);
       if (c === GRAY) {
-        const startIdx = path2.indexOf(dep);
-        cycles.push([...path2.slice(startIdx), dep]);
+        const startIdx = path4.indexOf(dep);
+        cycles.push([...path4.slice(startIdx), dep]);
       } else if (c === WHITE) {
-        dfs(dep, path2);
+        dfs(dep, path4);
       }
     }
-    path2.pop();
+    path4.pop();
     color.set(id, BLACK);
   }
   for (const id of idToEntry.keys()) {
@@ -566,6 +777,100 @@ async function loadUiPackageManifest(packageDir) {
   return result.data;
 }
 
+// src/tokens-pack-loader.ts
+var fs2 = __toESM(require("fs/promises"), 1);
+var path2 = __toESM(require("path"), 1);
+async function loadTokensPackageManifest(packageDir) {
+  const manifestPath = path2.join(packageDir, "manifest.json");
+  let raw;
+  try {
+    raw = await fs2.readFile(manifestPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Tokens package manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read tokens package manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Invalid JSON in tokens package manifest at ${manifestPath}`
+    );
+  }
+  const result = TokensPackageManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid tokens package manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+function getVariantEntry(catalog, variantName) {
+  return catalog.variants.find((v) => v.name === variantName);
+}
+
+// src/variant-ui-pack-loader.ts
+var fs3 = __toESM(require("fs/promises"), 1);
+var path3 = __toESM(require("path"), 1);
+async function readJson(filePath, kind) {
+  let raw;
+  try {
+    raw = await fs3.readFile(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`${kind} not found: ${filePath}`);
+    }
+    throw new Error(
+      `Failed to read ${kind} at ${filePath}: ${err.message}`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${kind} at ${filePath}`);
+  }
+}
+async function loadVariantUiPackageCatalog(packageDir) {
+  const manifestPath = path3.join(packageDir, "manifest.json");
+  const data = await readJson(manifestPath, "variant-ui catalog");
+  const result = VariantUiPackageCatalogSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid catalog:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+async function loadVariantUiPackageManifest(variantDir) {
+  const manifestPath = path3.join(variantDir, "manifest.json");
+  const data = await readJson(manifestPath, "variant-ui manifest");
+  const result = VariantUiPackageManifestSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid variant manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  const dirName = path3.basename(variantDir);
+  if (result.data.variant !== dirName) {
+    throw new Error(
+      `Variant manifest mismatch: variants/${dirName}/manifest.json declares variant="${result.data.variant}". Names must match.`
+    );
+  }
+  return result.data;
+}
+
 // src/managed-regions.ts
 var REGION_PATTERN = /<!-- teamix-evo:managed:start id="([^"]+)" -->([\s\S]*?)<!-- teamix-evo:managed:end id="\1" -->/g;
 var START_MARKER_PATTERN = /<!-- teamix-evo:managed:start id="([^"]+)" -->/g;
@@ -698,8 +1003,14 @@ function getUpdateAction(strategy, options) {
   SkillEntrySchema,
   SkillIdeSchema,
   SkillScopeSchema,
+  SkillsLockEntrySchema,
+  SkillsLockSchema,
   SkillsPackageManifestSchema,
   TailwindVersionSchema,
+  TokensPackLinkedSchema,
+  TokensPackLockSchema,
+  TokensPackageManifestSchema,
+  TokensVariantEntrySchema,
   UiAliasSchema,
   UiAliasesSchema,
   UiEntryFileSchema,
@@ -708,11 +1019,18 @@ function getUpdateAction(strategy, options) {
   UiPackageManifestSchema,
   UpdateStrategySchema,
   VariantManifestSchema,
+  VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema,
   getUpdateAction,
+  getVariantEntry,
   hasManagedRegion,
   loadSkillsPackageManifest,
+  loadTokensPackageManifest,
   loadUiPackageManifest,
   loadVariantManifest,
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest,
   parseManagedRegions,
   replaceManagedRegion,
   resolveUiEntryOrder,
@@ -720,6 +1038,7 @@ function getUpdateAction(strategy, options) {
   validateConfig,
   validateInstalled,
   validateManifest,
+  validateSkillsLock,
   validateSkillsPackage,
   validateUiDependencyGraph,
   validateUiPackage