@teamix-evo/registry 0.1.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,
@@ -37,17 +41,46 @@ __export(index_exports, {
   ProjectConfigSchema: () => ProjectConfigSchema,
   ResourceSchema: () => ResourceSchema,
   ResourceTypeSchema: () => ResourceTypeSchema,
+  SkillEntrySchema: () => SkillEntrySchema,
+  SkillIdeSchema: () => SkillIdeSchema,
+  SkillScopeSchema: () => SkillScopeSchema,
+  SkillsLockEntrySchema: () => SkillsLockEntrySchema,
+  SkillsLockSchema: () => SkillsLockSchema,
+  SkillsPackageManifestSchema: () => SkillsPackageManifestSchema,
+  TailwindVersionSchema: () => TailwindVersionSchema,
+  UiAliasSchema: () => UiAliasSchema,
+  UiAliasesSchema: () => UiAliasesSchema,
+  UiEntryFileSchema: () => UiEntryFileSchema,
+  UiEntrySchema: () => UiEntrySchema,
+  UiEntryTypeSchema: () => UiEntryTypeSchema,
+  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,
   shouldUpdate: () => shouldUpdate,
   validateConfig: () => validateConfig,
   validateInstalled: () => validateInstalled,
-  validateManifest: () => validateManifest
+  validateManifest: () => validateManifest,
+  validateSkillsLock: () => validateSkillsLock,
+  validateSkillsPackage: () => validateSkillsPackage,
+  validateUiDependencyGraph: () => validateUiDependencyGraph,
+  validateUiPackage: () => validateUiPackage,
+  walkPackTree: () => walkPackTree
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -62,8 +95,11 @@ var ResourceTypeSchema = import_zod.z.enum([
   "doc",
   "tokens",
   "ai-rules",
-  "config"
+  "config",
+  "skill"
 ]);
+var SkillIdeSchema = import_zod.z.enum(["qoder", "claude"]);
+var SkillScopeSchema = import_zod.z.enum(["project", "global"]);
 var ResourceSchema = import_zod.z.object({
   /** Unique identifier for the resource within the manifest */
   id: import_zod.z.string().min(1),
@@ -71,7 +107,10 @@ var ResourceSchema = import_zod.z.object({
   type: ResourceTypeSchema,
   /** Source path (relative to variant root), typically a template */
   source: import_zod.z.string().min(1),
-  /** Target path (relative to project root) where the resource is installed */
+  /**
+   * Target path (relative to project root) where the resource is installed.
+   * For type="skill" this is ignored: the path is computed from skill name + ide + scope.
+   */
   target: import_zod.z.string().min(1),
   /** How the resource is updated */
   updateStrategy: UpdateStrategySchema,
@@ -80,7 +119,11 @@ var ResourceSchema = import_zod.z.object({
   /** IDs of managed regions (only relevant when updateStrategy is "managed") */
   managedRegions: import_zod.z.array(import_zod.z.string()).optional(),
   /** Whether to recursively process directory contents */
-  recursive: import_zod.z.boolean().optional()
+  recursive: import_zod.z.boolean().optional(),
+  /** Supported IDEs (only meaningful when type="skill"; defaults to all when omitted) */
+  ides: import_zod.z.array(SkillIdeSchema).optional(),
+  /** Default install scope (only meaningful when type="skill"; user can override at install time) */
+  scope: SkillScopeSchema.optional()
 });
 var VariantManifestSchema = import_zod.z.object({
   $schema: import_zod.z.string().optional(),
@@ -104,52 +147,380 @@ var VariantManifestSchema = import_zod.z.object({
   /** List of resources provided by this variant */
   resources: import_zod.z.array(ResourceSchema)
 });
+var SkillEntrySchema = import_zod.z.object({
+  /** Skill identifier (matches name/folder) */
+  id: import_zod.z.string().min(1),
+  /** Skill name — must match the directory name and frontmatter `name` */
+  name: import_zod.z.string().min(1).regex(
+    /^[a-z0-9][a-z0-9-]*$/,
+    "Skill name must be lowercase letters, digits, hyphens (no leading hyphen)"
+  ),
+  /** One-line description for skill discovery */
+  description: import_zod.z.string().min(1),
+  /** Semver version */
+  version: import_zod.z.string().regex(/^\d+\.\d+\.\d+/, "Invalid semver version"),
+  /** Source path relative to package root — file or directory */
+  source: import_zod.z.string().min(1),
+  /** Supported IDEs (defaults to both when omitted) */
+  ides: import_zod.z.array(SkillIdeSchema).default(["qoder", "claude"]),
+  /** Update strategy (defaults to managed) */
+  updateStrategy: UpdateStrategySchema.default("managed"),
+  /** 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(),
+  /**
+   * 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(),
+  schemaVersion: import_zod.z.literal(1),
+  /** Always "skills" for this package */
+  package: import_zod.z.literal("skills"),
+  /** Semver version of the skills package */
+  version: import_zod.z.string().regex(/^\d+\.\d+\.\d+/, "Invalid semver version"),
+  /** Engine compatibility */
+  engines: import_zod.z.object({
+    "teamix-evo": import_zod.z.string().min(1)
+  }),
+  /** Flat list of skills shipped by this package */
+  skills: import_zod.z.array(SkillEntrySchema)
+});
+var UiEntryTypeSchema = import_zod.z.enum([
+  "component",
+  "hook",
+  "util",
+  "block",
+  "template"
+]);
+var UiAliasSchema = import_zod.z.enum([
+  "components",
+  "hooks",
+  "utils",
+  "lib",
+  "business",
+  "templates"
+]);
+var UiEntryStatusSchema = import_zod.z.enum([
+  "stable",
+  "experimental",
+  "deprecated"
+]);
+var UiEntryFileSchema = import_zod.z.object({
+  /** Source path relative to the ui package root (e.g. "src/components/button/button.tsx") */
+  source: import_zod.z.string().min(1),
+  /** Which alias this file resolves under in the consumer project */
+  targetAlias: UiAliasSchema,
+  /** Filename written under the alias directory (e.g. "button.tsx") */
+  targetName: import_zod.z.string().min(1)
+});
+var UiEntrySchema = import_zod.z.object({
+  /** Unique entry identifier within the ui package (e.g. "button") */
+  id: import_zod.z.string().min(1).regex(
+    /^[a-z0-9][a-z0-9-]*$/,
+    "UI entry id must be lowercase letters, digits, hyphens (no leading hyphen)"
+  ),
+  /** Display name (e.g. "Button") */
+  name: import_zod.z.string().min(1),
+  /** Entry type */
+  type: UiEntryTypeSchema,
+  /** One-line description for entry discovery and AI guidance */
+  description: import_zod.z.string().min(1),
+  /** Files this entry ships (typically 1) */
+  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.
+   */
+  meta: import_zod.z.string().optional(),
+  /** Other UI entries this one depends on (e.g. "button" depends on "cn") */
+  registryDependencies: import_zod.z.array(import_zod.z.string()).optional(),
+  /** npm dependencies required by this entry (name → semver range) */
+  dependencies: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  /**
+   * How CLI handles this entry on `ui upgrade`.
+   * Defaults to `frozen` — user-owned source code, untouched after first install.
+   * Upgrade is handled by AI + skill flow (no CLI rewrite). See PLAN §10.9.
+   */
+  updateStrategy: UpdateStrategySchema.default("frozen"),
+  /**
+   * Whether the source file should be passed through Handlebars before write.
+   * Most entries don't need templating (use import-rewrite transformer instead).
+   */
+  template: import_zod.z.boolean().optional(),
+  /**
+   * Maturity / lifecycle status of this entry. Defaults to `stable`.
+   * See {@link UiEntryStatusSchema} for semantics.
+   */
+  status: UiEntryStatusSchema.default("stable"),
+  /**
+   * Free-text rationale shown to consumers when `status` is `deprecated`.
+   * Should explain why the entry is going away and what replaces it.
+   */
+  deprecatedReason: import_zod.z.string().optional(),
+  /**
+   * 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(),
+  /**
+   * 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(),
+  schemaVersion: import_zod.z.literal(1),
+  /** Always "ui" for this package */
+  package: import_zod.z.literal("ui"),
+  /** Semver version of the ui package */
+  version: import_zod.z.string().regex(/^\d+\.\d+\.\d+/, "Invalid semver version"),
+  /** Engine compatibility */
+  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)
+});
 
-// src/schema/config.ts
+// src/schema/design-pack.ts
 var import_zod2 = require("zod");
-var PackageEntrySchema = import_zod2.z.object({
-  /** Variant identifier (e.g. "opentrek") */
-  variant: import_zod2.z.string().min(1),
-  /** Semver version string */
-  version: 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 ProjectConfigSchema = import_zod2.z.object({
+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_zod4.z.object({
+  /** Variant identifier (e.g. "opentrek"; use "_flat" for skills/ui) */
+  variant: import_zod4.z.string().min(1),
+  /** Semver version string */
+  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_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). */
+  aliases: UiAliasesSchema.optional(),
+  /**
+   * Default icon library declared by the project (only meaningful for ui).
+   * Declarative only — does NOT trigger code rewrites; ui entries hardcode imports.
+   */
+  iconLibrary: import_zod4.z.string().min(1).optional(),
+  /** Whether the project uses TSX (true) or JSX (false). ui-specific. */
+  tsx: import_zod4.z.boolean().optional(),
+  /** Whether to emit React Server Components markers (`"use client"`). ui-specific. */
+  rsc: import_zod4.z.boolean().optional()
+});
+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),
-  /** Target path where the resource was installed */
-  target: 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_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),
-  /** Variant identifier */
-  variant: 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_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
@@ -159,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) {
@@ -196,6 +567,126 @@ 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) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    error: `Invalid skills package manifest:
+${formatZodError(result.error)}`
+  };
+}
+function validateUiPackage(data) {
+  const parsed = UiPackageManifestSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      success: false,
+      error: `Invalid ui package manifest:
+${formatZodError(parsed.error)}`
+    };
+  }
+  const graphIssues = validateUiDependencyGraph(parsed.data.entries);
+  if (graphIssues.length > 0) {
+    return {
+      success: false,
+      error: `Invalid ui package manifest dependency graph:
+${graphIssues.map((i) => `  - ${i}`).join("\n")}`
+    };
+  }
+  return { success: true, data: parsed.data };
+}
+function validateUiDependencyGraph(entries) {
+  const issues = [];
+  const idToEntry = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (idToEntry.has(entry.id)) {
+      issues.push(`duplicate entry id: "${entry.id}"`);
+    } else {
+      idToEntry.set(entry.id, entry);
+    }
+  }
+  for (const entry of entries) {
+    const deps = entry.registryDependencies ?? [];
+    for (const dep of deps) {
+      if (!idToEntry.has(dep)) {
+        issues.push(
+          `entry "${entry.id}" depends on unknown entry "${dep}"`
+        );
+      }
+    }
+  }
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  for (const id of idToEntry.keys()) color.set(id, WHITE);
+  const cycles = [];
+  function dfs(id, path4) {
+    color.set(id, GRAY);
+    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 = path4.indexOf(dep);
+        cycles.push([...path4.slice(startIdx), dep]);
+      } else if (c === WHITE) {
+        dfs(dep, path4);
+      }
+    }
+    path4.pop();
+    color.set(id, BLACK);
+  }
+  for (const id of idToEntry.keys()) {
+    if (color.get(id) === WHITE) dfs(id, []);
+  }
+  for (const cycle of cycles) {
+    issues.push(`cyclic registryDependencies: ${cycle.join(" \u2192 ")}`);
+  }
+  return issues;
+}
+function resolveUiEntryOrder(entries, requested) {
+  const idToEntry = new Map(entries.map((e) => [e.id, e]));
+  for (const id of requested) {
+    if (!idToEntry.has(id)) {
+      throw new Error(`Unknown ui entry: "${id}"`);
+    }
+  }
+  const graphIssues = validateUiDependencyGraph(entries);
+  if (graphIssues.length > 0) {
+    throw new Error(
+      `UI dependency graph has issues:
+${graphIssues.map((i) => `  - ${i}`).join("\n")}`
+    );
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(id) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const entry = idToEntry.get(id);
+    const deps = entry?.registryDependencies ?? [];
+    for (const dep of deps) visit(dep);
+    order.push(id);
+  }
+  for (const id of requested) visit(id);
+  return order;
+}
 
 // src/loader.ts
 async function loadVariantManifest(packageDir) {
@@ -225,6 +716,254 @@ async function loadVariantManifest(packageDir) {
   }
   return result.data;
 }
+async function loadSkillsPackageManifest(packageDir) {
+  const manifestPath = path.join(packageDir, "manifest.json");
+  let raw;
+  try {
+    raw = await fs.readFile(manifestPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`Skills manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read skills manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in skills manifest at ${manifestPath}`);
+  }
+  const result = validateSkillsPackage(data);
+  if (!result.success) {
+    throw new Error(`${result.error}
+  File: ${manifestPath}`);
+  }
+  return result.data;
+}
+async function loadUiPackageManifest(packageDir) {
+  const manifestPath = path.join(packageDir, "manifest.json");
+  let raw;
+  try {
+    raw = await fs.readFile(manifestPath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(`UI manifest not found: ${manifestPath}`);
+    }
+    throw new Error(
+      `Failed to read ui manifest at ${manifestPath}: ${err.message}`
+    );
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ui manifest at ${manifestPath}`);
+  }
+  const result = validateUiPackage(data);
+  if (!result.success) {
+    throw new Error(`${result.error}
+  File: ${manifestPath}`);
+  }
+  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;
@@ -233,15 +972,25 @@ var END_MARKER_PATTERN = /<!-- teamix-evo:managed:end id="([^"]+)" -->/g;
 function parseManagedRegions(content) {
   const startIds = /* @__PURE__ */ new Set();
   const endIds = /* @__PURE__ */ new Set();
+  const startCounts = /* @__PURE__ */ new Map();
   let match;
   const startRe = new RegExp(START_MARKER_PATTERN.source, "g");
   while ((match = startRe.exec(content)) !== null) {
-    startIds.add(match[1]);
+    const id = match[1];
+    startIds.add(id);
+    startCounts.set(id, (startCounts.get(id) ?? 0) + 1);
   }
   const endRe = new RegExp(END_MARKER_PATTERN.source, "g");
   while ((match = endRe.exec(content)) !== null) {
     endIds.add(match[1]);
   }
+  for (const [id, count] of startCounts) {
+    if (count > 1) {
+      throw new Error(
+        `Duplicate managed region: found ${count} start markers for "${id}". Each id must be unique within a file.`
+      );
+    }
+  }
   for (const id of startIds) {
     if (!endIds.has(id)) {
       throw new Error(
@@ -274,7 +1023,9 @@ function replaceManagedRegion(content, id, newContent) {
   const startMarker = `<!-- teamix-evo:managed:start id="${id}" -->`;
   const endMarker = `<!-- teamix-evo:managed:end id="${id}" -->`;
   const pattern = new RegExp(
-    `<!-- teamix-evo:managed:start id="${escapeRegExp(id)}" -->[\\s\\S]*?<!-- teamix-evo:managed:end id="${escapeRegExp(id)}" -->`,
+    `<!-- teamix-evo:managed:start id="${escapeRegExp(
+      id
+    )}" -->[\\s\\S]*?<!-- teamix-evo:managed:end id="${escapeRegExp(id)}" -->`,
     "g"
   );
   if (!pattern.test(content)) {
@@ -290,7 +1041,9 @@ ${endMarker}`
 }
 function hasManagedRegion(content, id) {
   const pattern = new RegExp(
-    `<!-- teamix-evo:managed:start id="${escapeRegExp(id)}" -->[\\s\\S]*?<!-- teamix-evo:managed:end id="${escapeRegExp(id)}" -->`
+    `<!-- teamix-evo:managed:start id="${escapeRegExp(
+      id
+    )}" -->[\\s\\S]*?<!-- teamix-evo:managed:end id="${escapeRegExp(id)}" -->`
   );
   return pattern.test(content);
 }
@@ -334,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,
@@ -341,16 +1098,45 @@ function getUpdateAction(strategy, options) {
   ProjectConfigSchema,
   ResourceSchema,
   ResourceTypeSchema,
+  SkillEntrySchema,
+  SkillIdeSchema,
+  SkillScopeSchema,
+  SkillsLockEntrySchema,
+  SkillsLockSchema,
+  SkillsPackageManifestSchema,
+  TailwindVersionSchema,
+  UiAliasSchema,
+  UiAliasesSchema,
+  UiEntryFileSchema,
+  UiEntrySchema,
+  UiEntryTypeSchema,
+  UiPackageManifestSchema,
   UpdateStrategySchema,
   VariantManifestSchema,
+  VariantUiPackageCatalogSchema,
+  VariantUiPackageManifestSchema,
+  VariantUiPackageNameSchema,
   getUpdateAction,
   hasManagedRegion,
+  loadDesignPack,
+  loadDesignPackageManifest,
+  loadSkillsPackageManifest,
+  loadUiPackageManifest,
   loadVariantManifest,
+  loadVariantUiPackageCatalog,
+  loadVariantUiPackageManifest,
+  mergeDefaultAndVariant,
   parseManagedRegions,
   replaceManagedRegion,
+  resolveUiEntryOrder,
   shouldUpdate,
   validateConfig,
   validateInstalled,
-  validateManifest
+  validateManifest,
+  validateSkillsLock,
+  validateSkillsPackage,
+  validateUiDependencyGraph,
+  validateUiPackage,
+  walkPackTree
 });
 //# sourceMappingURL=index.cjs.map