@teamix-evo/registry 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -30,6 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DesignPackLinkedSchema: () => DesignPackLinkedSchema,
+  DesignPackLockSchema: () => DesignPackLockSchema,
+  DesignPackManifestSchema: () => DesignPackManifestSchema,
+  DesignPackageManifestSchema: () => DesignPackageManifestSchema,
   InstalledManifestSchema: () => InstalledManifestSchema,
   InstalledPackageSchema: () => InstalledPackageSchema,
   InstalledResourceSchema: () => InstalledResourceSchema,
@@ -40,6 +44,8 @@ __export(index_exports, {
   SkillEntrySchema: () => SkillEntrySchema,
   SkillIdeSchema: () => SkillIdeSchema,
   SkillScopeSchema: () => SkillScopeSchema,
+  SkillsLockEntrySchema: () => SkillsLockEntrySchema,
+  SkillsLockSchema: () => SkillsLockSchema,
   SkillsPackageManifestSchema: () => SkillsPackageManifestSchema,
   TailwindVersionSchema: () => TailwindVersionSchema,
   UiAliasSchema: () => UiAliasSchema,
@@ -50,11 +56,19 @@ __export(index_exports, {
   UiPackageManifestSchema: () => UiPackageManifestSchema,
   UpdateStrategySchema: () => UpdateStrategySchema,
   VariantManifestSchema: () => VariantManifestSchema,
+  VariantUiPackageCatalogSchema: () => VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema: () => VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema: () => VariantUiPackageNameSchema,
   getUpdateAction: () => getUpdateAction,
   hasManagedRegion: () => hasManagedRegion,
+  loadDesignPack: () => loadDesignPack,
+  loadDesignPackageManifest: () => loadDesignPackageManifest,
   loadSkillsPackageManifest: () => loadSkillsPackageManifest,
   loadUiPackageManifest: () => loadUiPackageManifest,
   loadVariantManifest: () => loadVariantManifest,
+  loadVariantUiPackageCatalog: () => loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest: () => loadVariantUiPackageManifest,
+  mergeDefaultAndVariant: () => mergeDefaultAndVariant,
   parseManagedRegions: () => parseManagedRegions,
   replaceManagedRegion: () => replaceManagedRegion,
   resolveUiEntryOrder: () => resolveUiEntryOrder,
@@ -62,9 +76,11 @@ __export(index_exports, {
   validateConfig: () => validateConfig,
   validateInstalled: () => validateInstalled,
   validateManifest: () => validateManifest,
+  validateSkillsLock: () => validateSkillsLock,
   validateSkillsPackage: () => validateSkillsPackage,
   validateUiDependencyGraph: () => validateUiDependencyGraph,
-  validateUiPackage: () => validateUiPackage
+  validateUiPackage: () => validateUiPackage,
+  walkPackTree: () => walkPackTree
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -152,7 +168,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/design/pack.lock.json` records the same variant. MUST equal
+   * the variant directory name in `@teamix-evo/design/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 +201,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",
@@ -237,7 +274,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(),
@@ -254,24 +298,148 @@ var UiPackageManifestSchema = import_zod.z.object({
   entries: import_zod.z.array(UiEntrySchema)
 });
 
-// src/schema/config.ts
+// src/schema/design-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 DesignPackLinkedSchema = import_zod2.z.object({
+  "biz-ui": import_zod2.z.string().optional(),
+  templates: import_zod2.z.string().optional()
+});
+var DesignPackManifestSchema = import_zod2.z.object({
+  $schema: import_zod2.z.string().optional(),
+  schemaVersion: import_zod2.z.literal(1),
+  /**
+   * Pack identifier.
+   * - `"default"` for the built-in baseline (only valid name when `extends` is absent)
+   * - lowercase kebab-case for variants (`opentrek`, `uni-manager`, `acme-erp`, `_template`)
+   */
+  name: import_zod2.z.string().min(1).regex(
+    VARIANT_NAME_RE,
+    'Pack name must be lowercase letters/digits/hyphens (no leading hyphen). Special: "_template" allowed for the variant scaffold.'
+  ).or(import_zod2.z.literal("_template")).or(import_zod2.z.literal("default")),
+  /** Human-readable display name (e.g. "OpenTrek" for variant id "opentrek"). */
+  displayName: import_zod2.z.string().min(1),
+  /** Semver. */
+  version: import_zod2.z.string().regex(SEMVER_RE, "Invalid semver version"),
+  /**
+   * Parent pack name. Required for variants, must be omitted for `default`.
+   * Currently only `"default"` is a valid parent.
+   */
+  extends: import_zod2.z.string().optional(),
+  /** Optional one-liner; useful for `design list-variants` output. */
+  description: import_zod2.z.string().optional(),
+  /** Soft cross-package links (biz-ui / templates with same variant name). */
+  linked: DesignPackLinkedSchema.optional()
+});
+var DesignPackageManifestSchema = import_zod2.z.object({
+  $schema: import_zod2.z.string().optional(),
+  schemaVersion: import_zod2.z.literal(1),
+  /** Always `"design"` for this package. */
+  package: import_zod2.z.literal("design"),
+  /** Semver of the entire design 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) }),
+  /** The default baseline pack — always present. */
+  default: DesignPackManifestSchema,
+  /** All shipped variants (excluding `_template/`). */
+  variants: import_zod2.z.array(DesignPackManifestSchema)
+});
+var DesignPackLockSchema = import_zod2.z.object({
+  $schema: import_zod2.z.string().optional(),
+  schemaVersion: import_zod2.z.literal(1),
+  default: import_zod2.z.object({
+    version: import_zod2.z.string().regex(SEMVER_RE),
+    from: import_zod2.z.string().min(1)
+    // e.g. "@teamix-evo/design"
+  }),
+  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)
+  }),
+  linked: DesignPackLinkedSchema.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 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_zod2.z.object({
+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 +448,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({
+var InstalledPackageSchema = import_zod5.z.object({
   /** Full package name (e.g. "@teamix-evo/design") */
-  package: import_zod3.z.string().min(1),
+  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 +530,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 +567,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 +634,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 +771,200 @@ async function loadUiPackageManifest(packageDir) {
   return result.data;
 }
 
+// src/design-pack-loader.ts
+var fs2 = __toESM(require("fs/promises"), 1);
+var path2 = __toESM(require("path"), 1);
+var PACK_METADATA_FILES = /* @__PURE__ */ new Set(["pack.json"]);
+async function loadDesignPack(packDir) {
+  const manifestPath = path2.join(packDir, "pack.json");
+  let raw;
+  try {
+    raw = await fs2.readFile(manifestPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Design pack manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read design pack manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in design pack manifest at ${manifestPath}`);
+  }
+  const result = DesignPackManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid design pack manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  if (result.data.name === "default" && result.data.extends !== void 0) {
+    throw new Error(
+      `Pack "default" must not have "extends" field: ${manifestPath}`
+    );
+  }
+  if (result.data.name !== "default" && result.data.extends !== "default") {
+    throw new Error(
+      `Variant pack "${result.data.name}" must declare extends: "default" (got ${JSON.stringify(
+        result.data.extends
+      )}): ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+async function loadDesignPackageManifest(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(`Design package manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read design package manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in design package manifest at ${manifestPath}`);
+  }
+  const result = DesignPackageManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid design package manifest:
+${result.error.message}
+  File: ${manifestPath}`
+    );
+  }
+  return result.data;
+}
+async function walkPackTree(packDir) {
+  const out = [];
+  async function recurse(absDir, relDir) {
+    const entries = await fs2.readdir(absDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const abs = path2.join(absDir, entry.name);
+      const rel = relDir ? path2.posix.join(relDir, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        await recurse(abs, rel);
+      } else if (entry.isFile()) {
+        if (relDir === "" && PACK_METADATA_FILES.has(entry.name)) continue;
+        out.push(rel);
+      }
+    }
+  }
+  try {
+    await recurse(packDir, "");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Pack directory not found: ${packDir}`);
+    }
+    throw err;
+  }
+  return out.sort();
+}
+async function mergeDefaultAndVariant(defaultDir, variantDir) {
+  const defaultFiles = new Set(await walkPackTree(defaultDir));
+  const variantFiles = new Set(await walkPackTree(variantDir));
+  const overrides = [];
+  const variantAdds = [];
+  const defaultPassThrough = [];
+  const files = [];
+  const allPaths = Array.from(/* @__PURE__ */ new Set([...defaultFiles, ...variantFiles])).sort();
+  for (const rel of allPaths) {
+    const inDefault = defaultFiles.has(rel);
+    const inVariant = variantFiles.has(rel);
+    if (inVariant && inDefault) {
+      overrides.push(rel);
+      files.push({
+        relPath: rel,
+        sourcePath: path2.join(variantDir, rel),
+        origin: "variant"
+      });
+    } else if (inVariant) {
+      variantAdds.push(rel);
+      files.push({
+        relPath: rel,
+        sourcePath: path2.join(variantDir, rel),
+        origin: "variant"
+      });
+    } else {
+      defaultPassThrough.push(rel);
+      files.push({
+        relPath: rel,
+        sourcePath: path2.join(defaultDir, rel),
+        origin: "default"
+      });
+    }
+  }
+  return { files, overrides, variantAdds, defaultPassThrough };
+}
+
+// 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;
@@ -688,6 +1087,10 @@ function getUpdateAction(strategy, options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DesignPackLinkedSchema,
+  DesignPackLockSchema,
+  DesignPackManifestSchema,
+  DesignPackageManifestSchema,
   InstalledManifestSchema,
   InstalledPackageSchema,
   InstalledResourceSchema,
@@ -698,6 +1101,8 @@ function getUpdateAction(strategy, options) {
   SkillEntrySchema,
   SkillIdeSchema,
   SkillScopeSchema,
+  SkillsLockEntrySchema,
+  SkillsLockSchema,
   SkillsPackageManifestSchema,
   TailwindVersionSchema,
   UiAliasSchema,
@@ -708,11 +1113,19 @@ function getUpdateAction(strategy, options) {
   UiPackageManifestSchema,
   UpdateStrategySchema,
   VariantManifestSchema,
+  VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema,
   getUpdateAction,
   hasManagedRegion,
+  loadDesignPack,
+  loadDesignPackageManifest,
   loadSkillsPackageManifest,
   loadUiPackageManifest,
   loadVariantManifest,
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest,
+  mergeDefaultAndVariant,
   parseManagedRegions,
   replaceManagedRegion,
   resolveUiEntryOrder,
@@ -720,8 +1133,10 @@ function getUpdateAction(strategy, options) {
   validateConfig,
   validateInstalled,
   validateManifest,
+  validateSkillsLock,
   validateSkillsPackage,
   validateUiDependencyGraph,
-  validateUiPackage
+  validateUiPackage,
+  walkPackTree
 });
 //# sourceMappingURL=index.cjs.map