@teamix-evo/registry 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Teamix Evo Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+# @teamix-evo/registry
+
+> Teamix Evo 协议包 — 提供 Schema、类型、加载器、校验器和策略决策引擎。
+
+## 定位
+
+registry 是整个 Teamix Evo 架构的**协议层**，负责定义：
+
+- 资源清单（VariantManifest）的结构约束
+- 项目配置（ProjectConfig）的 Schema
+- 安装状态（InstalledManifest）的追踪格式
+- 三种更新策略（frozen / regenerable / managed）的决策逻辑
+- Managed Regions 标记的解析与替换
+
+CLI 包和 design 包都依赖本包的协议定义工作。
+
+## 目录结构
+
+```
+packages/registry/
+├── src/
+│   ├── schema/
+│   │   ├── index.ts          # Schema 统一导出
+│   │   ├── manifest.ts       # VariantManifest Zod Schema
+│   │   ├── config.ts         # ProjectConfig Zod Schema
+│   │   └── installed.ts      # InstalledManifest Zod Schema
+│   ├── types.ts              # 从 Schema 推导的 TypeScript 类型
+│   ├── loader.ts             # 从文件系统加载 manifest
+│   ├── validator.ts          # 校验封装 + 友好错误消息
+│   ├── strategy.ts           # updateStrategy 决策函数
+│   ├── managed-regions.ts    # HTML 标记区解析与替换
+│   ├── index.ts              # 公共导出入口
+│   └── __tests__/            # 单元测试
+├── tsup.config.ts            # 构建配置（ESM + CJS + DTS）
+├── tsconfig.json
+└── package.json
+```
+
+## 研发流程
+
+### 1. 环境准备
+
+```bash
+# 在仓库根目录
+pnpm install
+```
+
+### 2. 开发
+
+```bash
+# 监听模式构建（修改即时编译）
+pnpm --filter @teamix-evo/registry dev
+```
+
+### 3. 新增 / 修改 Schema
+
+1. 在 `src/schema/` 中使用 Zod 定义或修改 Schema
+2. 在 `src/types.ts` 中通过 `z.infer<typeof XxxSchema>` 导出对应类型
+3. 在 `src/index.ts` 中确保新增的 Schema 和类型被导出
+4. 如需新增校验函数，在 `src/validator.ts` 中添加
+
+### 4. 修改策略逻辑
+
+- `src/strategy.ts` — 修改 `shouldUpdate` 或 `getUpdateAction`
+- `src/managed-regions.ts` — 修改标记解析或替换逻辑
+
+### 5. 测试
+
+```bash
+# 运行全部测试
+pnpm --filter @teamix-evo/registry test
+
+# 监听模式
+pnpm --filter @teamix-evo/registry test:watch
+```
+
+测试文件位于 `src/__tests__/`，覆盖：
+
+- `manifest.test.ts` — VariantManifest Schema 校验
+- `config.test.ts` — ProjectConfig Schema 校验
+- `installed.test.ts` — InstalledManifest Schema 校验
+- `validator.test.ts` — 友好错误消息格式化
+- `strategy.test.ts` — 三种策略决策逻辑
+- `managed-regions.test.ts` — 标记解析、替换、错误检测
+
+### 6. 类型检查
+
+```bash
+pnpm --filter @teamix-evo/registry typecheck
+```
+
+### 7. 构建
+
+```bash
+pnpm --filter @teamix-evo/registry build
+```
+
+产物输出到 `dist/`，包含：
+
+- `index.js` — ESM 格式
+- `index.cjs` — CommonJS 格式
+- `index.d.ts` — TypeScript 声明
+
+### 8. 发布前检查
+
+- 确保所有测试通过
+- 确保类型检查通过
+- 本包与 `teamix-evo`（CLI）使用 **linked** 版本策略，需一起发布
+
+## 关键约定
+
+- 所有 Schema 使用 [Zod](https://zod.dev/) 定义，运行时校验 + 编译时类型推导一体
+- `Result<T>` 类型用于校验返回，避免 throw（除 loader 和 managed-regions 外）
+- managed regions 标记格式：`<!-- teamix-evo:managed:start id="xxx" -->...<!-- teamix-evo:managed:end id="xxx" -->`
+- 同一文件中 region id 不得重复
+
+## 依赖关系
+
+```
+本包无内部包依赖
+CLI 包 → 依赖本包
+design 包 → devDependencies 引用本包（验证脚本）
+```

package/dist/index.cjs

@@ -37,17 +37,34 @@ __export(index_exports, {
   ProjectConfigSchema: () => ProjectConfigSchema,
   ResourceSchema: () => ResourceSchema,
   ResourceTypeSchema: () => ResourceTypeSchema,
+  SkillEntrySchema: () => SkillEntrySchema,
+  SkillIdeSchema: () => SkillIdeSchema,
+  SkillScopeSchema: () => SkillScopeSchema,
+  SkillsPackageManifestSchema: () => SkillsPackageManifestSchema,
+  TailwindVersionSchema: () => TailwindVersionSchema,
+  UiAliasSchema: () => UiAliasSchema,
+  UiAliasesSchema: () => UiAliasesSchema,
+  UiEntryFileSchema: () => UiEntryFileSchema,
+  UiEntrySchema: () => UiEntrySchema,
+  UiEntryTypeSchema: () => UiEntryTypeSchema,
+  UiPackageManifestSchema: () => UiPackageManifestSchema,
   UpdateStrategySchema: () => UpdateStrategySchema,
   VariantManifestSchema: () => VariantManifestSchema,
   getUpdateAction: () => getUpdateAction,
   hasManagedRegion: () => hasManagedRegion,
+  loadSkillsPackageManifest: () => loadSkillsPackageManifest,
+  loadUiPackageManifest: () => loadUiPackageManifest,
   loadVariantManifest: () => loadVariantManifest,
   parseManagedRegions: () => parseManagedRegions,
   replaceManagedRegion: () => replaceManagedRegion,
+  resolveUiEntryOrder: () => resolveUiEntryOrder,
   shouldUpdate: () => shouldUpdate,
   validateConfig: () => validateConfig,
   validateInstalled: () => validateInstalled,
-  validateManifest: () => validateManifest
+  validateManifest: () => validateManifest,
+  validateSkillsPackage: () => validateSkillsPackage,
+  validateUiDependencyGraph: () => validateUiDependencyGraph,
+  validateUiPackage: () => validateUiPackage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -62,8 +79,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 +91,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 +103,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,14 +131,160 @@ 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()
+});
+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"
+]);
+var UiAliasSchema = import_zod.z.enum(["components", "hooks", "utils", "lib"]);
+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()
+});
+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
 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 PackageEntrySchema = import_zod2.z.object({
-  /** Variant identifier (e.g. "opentrek") */
+  /** Variant identifier (e.g. "opentrek"; use "_flat" for skills/ui) */
   variant: import_zod2.z.string().min(1),
   /** Semver version string */
-  version: import_zod2.z.string().min(1)
+  version: import_zod2.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(),
+  /** 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_zod2.z.string().min(1).optional(),
+  /** Whether the project uses TSX (true) or JSX (false). ui-specific. */
+  tsx: import_zod2.z.boolean().optional(),
+  /** Whether to emit React Server Components markers (`"use client"`). ui-specific. */
+  rsc: import_zod2.z.boolean().optional()
 });
 var ProjectConfigSchema = import_zod2.z.object({
   $schema: import_zod2.z.string().optional(),
@@ -127,17 +300,21 @@ var import_zod3 = require("zod");
 var InstalledResourceSchema = import_zod3.z.object({
   /** Resource identifier matching the variant manifest */
   id: import_zod3.z.string().min(1),
-  /** Target path where the resource was installed */
+  /** Target path where the resource was installed (absolute or project-relative) */
   target: import_zod3.z.string().min(1),
   /** Content hash for change detection (e.g. "sha256:...") */
   hash: import_zod3.z.string().min(1),
   /** Update strategy that was applied */
-  strategy: import_zod3.z.enum(["frozen", "regenerable", "managed"])
+  strategy: import_zod3.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),
-  /** Variant identifier */
+  /** Variant identifier (use "_flat" for non-variant packages such as skills) */
   variant: import_zod3.z.string().min(1),
   /** Installed version */
   version: import_zod3.z.string().min(1),
@@ -196,6 +373,115 @@ function validateInstalled(data) {
 ${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, path2) {
+    color.set(id, GRAY);
+    path2.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]);
+      } else if (c === WHITE) {
+        dfs(dep, path2);
+      }
+    }
+    path2.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 +511,60 @@ 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/managed-regions.ts
 var REGION_PATTERN = /<!-- teamix-evo:managed:start id="([^"]+)" -->([\s\S]*?)<!-- teamix-evo:managed:end id="\1" -->/g;
@@ -233,15 +573,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 +624,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 +642,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);
 }
@@ -341,16 +695,33 @@ function getUpdateAction(strategy, options) {
   ProjectConfigSchema,
   ResourceSchema,
   ResourceTypeSchema,
+  SkillEntrySchema,
+  SkillIdeSchema,
+  SkillScopeSchema,
+  SkillsPackageManifestSchema,
+  TailwindVersionSchema,
+  UiAliasSchema,
+  UiAliasesSchema,
+  UiEntryFileSchema,
+  UiEntrySchema,
+  UiEntryTypeSchema,
+  UiPackageManifestSchema,
   UpdateStrategySchema,
   VariantManifestSchema,
   getUpdateAction,
   hasManagedRegion,
+  loadSkillsPackageManifest,
+  loadUiPackageManifest,
   loadVariantManifest,
   parseManagedRegions,
   replaceManagedRegion,
+  resolveUiEntryOrder,
   shouldUpdate,
   validateConfig,
   validateInstalled,
-  validateManifest
+  validateManifest,
+  validateSkillsPackage,
+  validateUiDependencyGraph,
+  validateUiPackage
 });
 //# sourceMappingURL=index.cjs.map