@tbox.cn/app-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3154 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { fileURLToPath } from "url";
+import { realpathSync as realpathSync3 } from "fs";
+
+// src/commands/create.ts
+import { existsSync as existsSync3, readdirSync, realpathSync } from "fs";
+import { appendFile, cp, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
+
+// src/manifest.ts
+import { existsSync, readFileSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+function manifestPath(appDir) {
+  return path.join(appDir, ".tbox", "app.json");
+}
+function readAppManifest(appDir) {
+  const file = manifestPath(appDir);
+  if (!existsSync(file)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf8"));
+    const templateVersion = raw?.templateVersion;
+    if (typeof templateVersion !== "string" || templateVersion.trim().length === 0) return null;
+    return {
+      templateVersion: templateVersion.trim(),
+      npmModules: Array.isArray(raw?.npmModules) ? raw.npmModules : []
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeAppManifest(appDir, manifest) {
+  const file = manifestPath(appDir);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+}
+function upsertNpmModule(manifest, entry) {
+  const rest = manifest.npmModules.filter((m) => m.id !== entry.id);
+  return { ...manifest, npmModules: [...rest, entry] };
+}
+function removeNpmModule(manifest, id) {
+  return { ...manifest, npmModules: manifest.npmModules.filter((m) => m.id !== id) };
+}
+function updateNpmModule(manifest, id, patch) {
+  return {
+    ...manifest,
+    npmModules: manifest.npmModules.map((m) => m.id === id ? { ...m, ...patch } : m)
+  };
+}
+function isValidModuleId(id) {
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(id) && !id.includes("..");
+}
+function assertValidModuleId(id, source) {
+  if (!isValidModuleId(id)) {
+    throw new Error(`\u975E\u6CD5\u6A21\u5757 id "${id}"\uFF08\u6765\u81EA ${source}\uFF09\uFF1A\u4EC5\u5141\u8BB8\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u4E2D\u5212\u7EBF`);
+  }
+}
+
+// src/source.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, mkdtempSync, rmSync } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
+import { tmpdir } from "os";
+import { readFile, readdir, stat } from "fs/promises";
+import path3 from "path";
+
+// src/registry.ts
+import { execFileSync } from "child_process";
+import path2 from "path";
+var cachedRegistry = null;
+function resolveRegistry(pkgName) {
+  if (pkgName?.startsWith("@tbox.cn/")) {
+    try {
+      const scopeOut = execFileSync("pnpm", ["config", "get", "@tbox.cn:registry"], { encoding: "utf8" });
+      const scopeReg = scopeOut.trim().split(/\r?\n/).pop() ?? "";
+      if (scopeReg) return scopeReg;
+    } catch {
+    }
+  }
+  if (cachedRegistry) return cachedRegistry;
+  try {
+    const out = execFileSync("pnpm", ["config", "get", "registry"], { encoding: "utf8" });
+    cachedRegistry = out.trim().split(/\r?\n/).pop() ?? "https://registry.npmjs.org/";
+  } catch {
+    cachedRegistry = "https://registry.npmjs.org/";
+  }
+  return cachedRegistry;
+}
+function isRegistrySpec(spec) {
+  return /^@[^/]+\/[^@/]+(@.+)?$/.test(spec);
+}
+function specName(spec) {
+  return spec.replace(/@[^/]+$/, "");
+}
+function packFromRegistry(spec, outDir, registry) {
+  const reg = registry ?? resolveRegistry(specName(spec));
+  const viewArgs = ["view", spec, "dist.tarball"];
+  if (registry) viewArgs.push("--registry", registry);
+  const out = execFileSync("pnpm", viewArgs, { encoding: "utf8" });
+  const url = out.trim().split(/\r?\n/).pop() ?? "";
+  if (!url) throw new Error(`registry \u62C9\u53D6\u5931\u8D25\uFF1A${spec} \u65E0 dist.tarball\uFF08registry=${reg}\uFF09`);
+  const file = url.split("/").pop() ?? `${spec.replace(/^@/, "").replace(/\//g, "-").split("@")[0]}.tgz`;
+  const dest = path2.join(path2.resolve(outDir), file);
+  execFileSync("curl", ["-fsSL", "-o", dest, url], { stdio: "ignore" });
+  return dest;
+}
+
+// src/source.ts
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "dist-ssr", ".git", ".tbox"]);
+async function walkDir(dir, base, out) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path3.join(dir, entry.name);
+    const rel = path3.relative(base, full).split(path3.sep).join("/");
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry.name)) continue;
+      await walkDir(full, base, out);
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+}
+var LocalDirSource = class {
+  constructor(dir) {
+    this.dir = dir;
+    this.name = path3.basename(path3.resolve(dir));
+  }
+  dir;
+  name;
+  getDir() {
+    return this.dir;
+  }
+  async listFiles() {
+    const files = [];
+    await walkDir(this.dir, this.dir, files);
+    return files.sort();
+  }
+  async readFile(rel) {
+    return readFile(path3.join(this.dir, rel), "utf8");
+  }
+  /** 目录是否可读（存在且含 package.json） */
+  static isUsable(dir) {
+    return existsSync2(path3.join(dir, "package.json"));
+  }
+  resolveVersion() {
+    return readPackageNameVersion(this.dir).version;
+  }
+};
+function readPackageNameVersion(pkgDir) {
+  let raw;
+  try {
+    raw = readFileSync2(path3.join(pkgDir, "package.json"), "utf8");
+  } catch {
+    return { version: "0.0.0" };
+  }
+  try {
+    const pkg = JSON.parse(raw);
+    return { name: pkg?.name, version: pkg?.version ?? "0.0.0" };
+  } catch {
+    return { version: "0.0.0" };
+  }
+}
+var RegistrySource = class {
+  constructor(spec, registry) {
+    this.spec = spec;
+    this.registry = registry;
+    this.name = spec;
+    this.packDir = mkdtempSync(path3.join(tmpdir(), "tbox-reg-"));
+  }
+  spec;
+  registry;
+  name;
+  inner = null;
+  packDir;
+  resolvedName = "";
+  resolvedVersion = "";
+  resolve() {
+    if (this.inner) return this.inner;
+    const pkgName = this.spec.replace(/@[^/]+$/, "");
+    const reg = this.registry ?? resolveRegistry(pkgName);
+    console.log(`\u{1F4E6} \u4ECE registry \u62C9\u53D6 ${this.spec}\uFF08${reg}\uFF09`);
+    const tgzPath = packFromRegistry(this.spec, this.packDir, this.registry);
+    this.inner = new TarballSource(tgzPath);
+    let name;
+    let version = "";
+    try {
+      const pkg = JSON.parse(readFileSync2(path3.join(this.inner.getDir(), "package.json"), "utf8"));
+      name = pkg.name;
+      version = pkg.version ?? "";
+    } catch {
+    }
+    this.resolvedName = name ?? this.spec;
+    this.resolvedVersion = version;
+    console.log(`   \u2192 ${this.resolvedName}@${this.resolvedVersion}`);
+    return this.inner;
+  }
+  listFiles() {
+    return Promise.resolve(this.resolve()).then((s) => s.listFiles());
+  }
+  readFile(rel) {
+    return Promise.resolve(this.resolve()).then((s) => s.readFile(rel));
+  }
+  resolveVersion() {
+    this.resolve();
+    return this.resolvedVersion;
+  }
+  getDir() {
+    return this.resolve().getDir();
+  }
+  get resolvedPackage() {
+    return { name: this.resolvedName, version: this.resolvedVersion };
+  }
+  dispose() {
+    if (this.inner) this.inner.dispose();
+    try {
+      if (this.packDir.startsWith(tmpdir())) {
+        rmSync(this.packDir, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+};
+function openSource(sourcePath, registry) {
+  if (sourcePath.endsWith(".tgz") && existsSync2(sourcePath)) {
+    const tarball = new TarballSource(sourcePath);
+    return { sourceDir: tarball.getDir(), source: tarball };
+  }
+  if (!existsSync2(sourcePath) && isRegistrySpec(sourcePath)) {
+    const regSource = new RegistrySource(sourcePath, registry);
+    return { sourceDir: regSource.getDir(), source: regSource };
+  }
+  return { sourceDir: sourcePath, source: new LocalDirSource(sourcePath) };
+}
+var TarballSource = class {
+  name;
+  inner;
+  tmpRoot;
+  constructor(tgzPath) {
+    const abs = path3.resolve(tgzPath);
+    this.name = path3.basename(abs, ".tgz");
+    this.tmpRoot = mkdtempSync(path3.join(tmpdir(), "tbox-tgz-"));
+    execFileSync2("tar", ["-xzf", abs, "-C", this.tmpRoot], { stdio: "ignore" });
+    const pkgDir = path3.join(this.tmpRoot, "package");
+    this.inner = new LocalDirSource(existsSync2(pkgDir) ? pkgDir : this.tmpRoot);
+  }
+  getDir() {
+    return this.inner.getDir();
+  }
+  listFiles() {
+    return this.inner.listFiles();
+  }
+  readFile(rel) {
+    return this.inner.readFile(rel);
+  }
+  resolveVersion() {
+    return this.inner.resolveVersion();
+  }
+  /** 释放临时目录（仅删本实例创建的 tmpRoot，防误删系统 tmp 父目录） */
+  dispose() {
+    try {
+      if (this.tmpRoot.startsWith(tmpdir())) {
+        rmSync(this.tmpRoot, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+};
+
+// src/commands/create.ts
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "dist-ssr", ".git", ".DS_Store"]);
+var EXCLUDE_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml"]);
+var TEMPLATE_WORKSPACE_FILE = "pnpm-workspace.template.yaml";
+var APP_WORKSPACE_FILE = "pnpm-workspace.yaml";
+function buildPlatformOverrides(tgzDir, appDir) {
+  const files = readdirSync(tgzDir).filter((f) => /^tbox\.cn-app-(sdk|contracts)-.+\.tgz$/.test(f)).sort();
+  if (files.length === 0) return null;
+  const appReal = realpathSync(appDir);
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const f of files) {
+    const rest = f.replace(/^tbox\.cn-app-/, "").replace(/\.tgz$/, "");
+    const i = rest.lastIndexOf("-");
+    const name = "@tbox.cn/app-" + rest.slice(0, i);
+    if (seen.has(name)) {
+      throw new Error(`--local-deps \u76EE\u5F55\u542B\u540C\u4E00\u5E73\u53F0\u5305\u591A\u7248\u672C\uFF08overrides \u91CD\u590D key \u6B67\u4E49\uFF0C\u987B\u5355\u7248\u672C\u76EE\u5F55\uFF09: ${name}`);
+    }
+    seen.add(name);
+    const rel = path4.relative(appReal, realpathSync(path4.join(tgzDir, f)));
+    lines.push(`  ${JSON.stringify(name)}: ${JSON.stringify(`file:${rel}`)}`);
+  }
+  return "\n# create --local-deps \u6CE8\u5165\uFF1A\u5E73\u53F0\u5305\u7ECF file: \u672C\u5730\u53D1\u5E03\u6001 tgz \u6D88\u8D39\uFF08005 v0.4.0 \u9A8C\u8BC1\u6001\uFF1B\u751F\u4EA7 B \u6863\u79FB\u9664\u672C\u5757\u8D70 registry\uFF09\noverrides:\n" + lines.join("\n") + "\n";
+}
+function validateLocalDeps(tgzDir) {
+  const files = readdirSync(tgzDir).filter((f) => /^tbox\.cn-app-(sdk|contracts)-.+\.tgz$/.test(f));
+  if (files.length === 0) {
+    throw new Error(`--local-deps \u76EE\u5F55\u65E0\u5E73\u53F0\u5305\u4EA7\u7269\uFF08\u7F3A tbox.cn-app-(sdk|contracts)-*.tgz\uFF09: ${tgzDir}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const rest = f.replace(/^tbox\.cn-app-/, "").replace(/\.tgz$/, "");
+    const i = rest.lastIndexOf("-");
+    const name = "@tbox.cn/app-" + rest.slice(0, i);
+    if (seen.has(name)) {
+      throw new Error(`--local-deps \u76EE\u5F55\u542B\u540C\u4E00\u5E73\u53F0\u5305\u591A\u7248\u672C\uFF08overrides \u91CD\u590D key \u6B67\u4E49\uFF0C\u987B\u5355\u7248\u672C\u76EE\u5F55\uFF09: ${name}`);
+    }
+    seen.add(name);
+  }
+}
+async function createApp(opts) {
+  const target = path4.resolve(process.cwd(), opts.name);
+  if (existsSync3(target) && !opts.force) {
+    throw new Error(`\u76EE\u5F55\u5DF2\u5B58\u5728: ${opts.name}\uFF08\u52A0 --force \u8986\u76D6\uFF09`);
+  }
+  const rawSource = opts.source;
+  const source = path4.resolve(rawSource);
+  const isReg = !existsSync3(source) && isRegistrySpec(rawSource);
+  const fromTgz = source.endsWith(".tgz");
+  if (!isReg && !fromTgz && !LocalDirSource.isUsable(source)) {
+    throw new Error(`\u6A21\u677F\u6E90\u65E0\u6548\uFF08\u7F3A package.json\uFF09: ${source}`);
+  }
+  if (!isReg && fromTgz && !existsSync3(source)) {
+    throw new Error(`\u6A21\u677F\u6E90\u65E0\u6548\uFF08tgz \u4E0D\u5B58\u5728\uFF09: ${source}`);
+  }
+  if (isReg && opts.localDeps) {
+    throw new Error("registry \u6E90\uFF08--source @scope/pkg\uFF09\u4E0E --local-deps \u4E92\u65A5\uFF1Aregistry \u5B89\u88C5\u65E0\u9700/\u4E0D\u5141\u8BB8\u672C\u5730\u4F9D\u8D56\u6CE8\u5165");
+  }
+  if (opts.localDeps) {
+    validateLocalDeps(path4.resolve(opts.localDeps));
+  }
+  const opened = openSource(isReg ? rawSource : source, opts.registry);
+  const sourceDir = opened.sourceDir;
+  try {
+    const srcManifest = readAppManifest(sourceDir);
+    if (!srcManifest) {
+      throw new Error(`\u6A21\u677F\u7ED3\u6784\u5F02\u5E38: ${source} \u7684 .tbox/app.json \u7F3A\u5931\u3001\u635F\u574F\u6216\u7F3A\u5C11 templateVersion\uFF08\u51FA\u751F\u7248\u672C\uFF09\u5B57\u6BB5`);
+    }
+    await cp(sourceDir, target, {
+      recursive: true,
+      force: true,
+      filter: (src) => {
+        const name = path4.basename(src);
+        if (EXCLUDE_FILES.has(name)) return false;
+        if (EXCLUDE_DIRS.has(name)) return false;
+        return true;
+      }
+    });
+    const tplWs = path4.join(target, TEMPLATE_WORKSPACE_FILE);
+    if (existsSync3(tplWs)) {
+      await rename(tplWs, path4.join(target, APP_WORKSPACE_FILE));
+    }
+    if (opts.localDeps) {
+      const block = buildPlatformOverrides(path4.resolve(opts.localDeps), target);
+      await appendFile(path4.join(target, APP_WORKSPACE_FILE), block, "utf8");
+    }
+    const pkgFile = path4.join(target, "package.json");
+    if (existsSync3(pkgFile)) {
+      const pkg = JSON.parse(await readFile2(pkgFile, "utf8"));
+      pkg.name = opts.name;
+      await writeFile2(pkgFile, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    }
+    const manifest = { templateVersion: srcManifest.templateVersion, npmModules: [] };
+    await writeAppManifest(target, manifest);
+    console.log(`\u2705 \u5DF2\u521B\u5EFA\u5E94\u7528 ${opts.name}`);
+    if (isReg) {
+      console.log(`   \u26A1 \u5DF2\u4ECE registry \u6A21\u677F\u5305 ${opened.source.name} \u5C55\u5F00\uFF08\u53D1\u5E03\u6001\uFF09`);
+    } else if (fromTgz) {
+      console.log(`   \u26A1 \u5DF2\u4ECE\u6A21\u677F\u5305 ${path4.basename(source)} \u5C55\u5F00\uFF08\u53D1\u5E03\u6001\uFF09`);
+    } else {
+      console.log(`   \u26A1 \u5DF2\u4ECE\u6A21\u677F\u76EE\u5F55\u5C55\u5F00\uFF08\u672C\u5730\u5F00\u53D1\u6E90\uFF09`);
+    }
+    if (opts.localDeps) {
+      console.log(`   \u26A1 \u5DF2\u6CE8\u5165\u5E73\u53F0 overrides\uFF08--local-deps: ${opts.localDeps}\uFF0Cinstall \u79BB\u7EBF\u6D88\u8D39\u672C\u5730\u53D1\u5E03\u6001\u4EA7\u7269\uFF09`);
+    }
+    console.log(`   \u26A1 \u5DF2\u751F\u6210 pnpm-workspace.yaml\uFF08\u5E94\u7528 workspace\uFF09`);
+    console.log(`   \u4E0B\u4E00\u6B65: cd ${opts.name} && pnpm install`);
+    console.log(`   \u{1F510} \u9274\u6743\uFF08006\uFF09: \u751F\u4EA7\u8BF7\u7531\u5E73\u53F0\u6CE8\u5165 AUTH_TOKEN_SECRET \u4E14\u786E\u4FDD NODE_ENV=production\uFF08dev-login \u5F3A\u5236\u5173\u95ED\uFF09\uFF1B`);
+    console.log(`                    \u672C\u5730\u5F00\u53D1\u9ED8\u8BA4\u5F00\u542F dev-login\uFF08\u975E production\uFF09\uFF1B\u5982\u9700\u5173\u95ED\u8BBE AUTH_DEV_LOGIN_DISABLED=true\u3002`);
+  } finally {
+    if (opened.source instanceof TarballSource) opened.source.dispose();
+  }
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync19, readFileSync as readFileSync8, readdirSync as readdirSync2 } from "fs";
+import path23 from "path";
+
+// src/expand.ts
+import { mkdir as mkdir2, rm, writeFile as writeFile3 } from "fs/promises";
+import path5 from "path";
+
+// src/pkg-family.ts
+var PLATFORM_RE = /^@tbox\.cn\/app-(sdk|contracts)/;
+function isPlatform(name) {
+  return PLATFORM_RE.test(name);
+}
+
+// src/expand.ts
+function isWorkspacePkg(name) {
+  return isPlatform(name);
+}
+function rewritePlatformRefs(deps) {
+  for (const name of Object.keys(deps)) {
+    if (isWorkspacePkg(name)) deps[name] = "catalog:";
+  }
+}
+function rewriteExportsToSrc(pkg) {
+  const exports = pkg.exports;
+  if (!exports || typeof exports !== "object") return;
+  const next = {};
+  for (const [sub, val] of Object.entries(exports)) {
+    if (typeof val !== "object" || val === null) continue;
+    const base = sub === "." ? "./src/index.ts" : `./src/${sub.replace(/^\.\//, "")}/index.ts`;
+    next[sub] = { types: base, import: base };
+  }
+  pkg.exports = next;
+}
+async function expandCodegen(appDir, sourceDir, entry) {
+  const src = new LocalDirSource(sourceDir);
+  const targetDir = path5.join(appDir, "packages", entry.id);
+  await rm(targetDir, { recursive: true, force: true });
+  await mkdir2(targetDir, { recursive: true });
+  for (const rel of await src.listFiles()) {
+    if (rel === "package.json") continue;
+    const content = await src.readFile(rel);
+    const out = path5.join(targetDir, rel);
+    await mkdir2(path5.dirname(out), { recursive: true });
+    await writeFile3(out, content);
+  }
+  const rawPkg = await src.readFile("package.json");
+  const pkg = JSON.parse(rawPkg);
+  pkg.name = `@app/${entry.id}`;
+  pkg.private = true;
+  if (pkg.dependencies && typeof pkg.dependencies === "object") {
+    rewritePlatformRefs(pkg.dependencies);
+  }
+  if (pkg.peerDependencies && typeof pkg.peerDependencies === "object") {
+    rewritePlatformRefs(pkg.peerDependencies);
+  }
+  rewriteExportsToSrc(pkg);
+  await writeFile3(path5.join(targetDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n", "utf8");
+}
+var LOCAL_SERVER_ENTRY = (id) => `import type { ServerContext, ServerModule } from '@tbox.cn/app-sdk/server';
+
+/**
+ * ${id} \u672C\u5730\u6A21\u5757\uFF08local \u6A21\u5F0F\uFF0Capp \u81EA\u6709\u5305\uFF09\u6CE8\u518C\u5165\u53E3\u3002
+ * \u5728\u6B64\u6CE8\u518C\u5DE5\u5177 / \u5361\u7247 meta / handler / \u8DEF\u7531 / Service\uFF08\u53EA\u6CE8\u518C\u4E0D\u89E3\u6790\uFF0CresolveService \u4EC5 handle/\u4E8B\u4EF6\u56DE\u8C03\u5185\uFF09\u3002
+ * cards map \u7684 key \u7EA6\u5B9A = meta.cardType\uFF1B\u65E0\u5361\u7247\u6A21\u5757\u5199\u7A7A map\u3002
+ */
+const cards = {} as const;
+
+export const serverModule = {
+  cards,
+  // \u53C2\u6570\u547D\u540D _ctx\uFF1A\u9AA8\u67B6\u65B9\u6CD5\u4F53\u4E3A\u7A7A\uFF0C\u89C4\u907F tsconfig.base noUnusedParameters\uFF08TS6133\uFF09
+  register(_ctx: ServerContext): void {
+    // _ctx.tools.register(...);
+    // _ctx.cards.registerMap(cards);
+    // _ctx.handlers.register({ id: '...', handle: async () => ({ cards: [], text: '' }) });
+    // _ctx.services.register('member', member);
+  },
+} satisfies ServerModule;
+`;
+var LOCAL_SERVICE = `/**
+ * Service \u5C42\uFF08\u4E1A\u52A1\u4E13\u5C5E\u5B9E\u73B0\uFF0C\u76F4\u63A5 import \u6216\u7ECF ctx.services \u6CE8\u518C\u4F9B\u8DE8\u6A21\u5757\u6D88\u8D39\uFF09\u3002
+ */
+export {};
+`;
+var LOCAL_HANDLER = `/**
+ * Handler \u5B9A\u4E49\uFF08001 \xA73.2\uFF09\u3002
+ */
+import type { HandlerDefinition } from '@tbox.cn/app-sdk/server';
+
+export const exampleHandler: HandlerDefinition = {
+  id: 'example',
+  handle: async () => ({ cards: [], text: '\u672C\u5730\u6A21\u5757\u793A\u4F8B' }),
+};
+`;
+var LOCAL_CLIENT_INDEX = `/**
+ * \u5BA2\u6237\u7AEF\u5165\u53E3\uFF1A\u5BFC\u51FA clientModule\uFF08CLI sync \u88C5\u914D\u8BFB\u53D6\uFF1B\u4E0E serverModule \u9010\u884C\u5BF9\u79F0\uFF09\u3002
+ * cards map \u7684 key \u7EA6\u5B9A = cardType\uFF1B\u65E0\u5361\u7247\u6A21\u5757\u5199\u7A7A map\u3002
+ */
+import type { ClientContext, ClientModule } from '@tbox.cn/app-sdk/client';
+
+const cards = {} as const;
+
+export const clientModule = {
+  cards,
+  // \u53C2\u6570\u547D\u540D _ctx\uFF1A\u9AA8\u67B6\u65B9\u6CD5\u4F53\u4E3A\u7A7A\uFF0C\u89C4\u907F tsconfig.base noUnusedParameters\uFF08TS6133\uFF09
+  register(_ctx: ClientContext): void {
+    // _ctx.cards.registerMap(cards);
+  },
+} satisfies ClientModule;
+`;
+var LOCAL_ROOT_INDEX = `/**
+ * \u672C\u5730\u6A21\u5757\u4E3B\u5165\u53E3\uFF08package.json exports "." \u6307\u5411\uFF09\u3002
+ * \u6D88\u8D39\u65B9\u901A\u5E38\u8D70 ./server / ./client \u5B50\u8DEF\u5F84\uFF1B\u4E3B\u5165\u53E3\u805A\u5408\u5BFC\u51FA\u4FBF\u4E8E\u76F4\u63A5\u5F15\u7528\u3002
+ */
+export * from './server';
+export * from './client';
+`;
+var LOCAL_TSCONFIG = `{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "types": ["node"]
+  },
+  "include": ["src"]
+}
+`;
+async function createLocalSkeleton(appDir, shortName) {
+  const id = shortName.startsWith("module-") ? shortName : `module-${shortName}`;
+  const dir = path5.join(appDir, "packages", id);
+  await rm(dir, { recursive: true, force: true });
+  await mkdir2(path5.join(dir, "src/server"), { recursive: true });
+  await mkdir2(path5.join(dir, "src/client"), { recursive: true });
+  const pkg = {
+    name: `@app/${id}`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    exports: {
+      ".": { types: "./src/index.ts", import: "./src/index.ts" },
+      "./server": { types: "./src/server/index.ts", import: "./src/server/index.ts" },
+      "./client": { types: "./src/client/index.ts", import: "./src/client/index.ts" }
+    },
+    // 本地模块自带工具链：typecheck/test 可在生成应用内直接跑（pnpm verify 全 @app/* 范围）
+    scripts: { typecheck: "tsc --noEmit", test: "vitest run --passWithNoTests" },
+    dependencies: {
+      "@tbox.cn/app-sdk": "catalog:",
+      "@tbox.cn/app-contracts": "catalog:"
+    },
+    peerDependencies: {
+      zod: "catalog:",
+      react: "catalog:",
+      "@mastra/core": "catalog:"
+    },
+    devDependencies: {
+      typescript: "catalog:",
+      vitest: "catalog:",
+      "@types/react": "catalog:",
+      "@types/node": "catalog:"
+    }
+  };
+  const component = {
+    schemaVersion: 1,
+    name: id,
+    version: "0.1.0",
+    kind: "business",
+    risk: { level: "low", writeBoundary: "source" },
+    distribution: { defaultMode: "local" },
+    contributes: {
+      handlers: [],
+      tools: [],
+      cards: [],
+      routes: [],
+      pages: [],
+      tabs: []
+    },
+    dependencies: { modules: [] },
+    env: []
+  };
+  await writeFile3(path5.join(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  await writeFile3(
+    path5.join(dir, "tbox.component.json"),
+    JSON.stringify(component, null, 2) + "\n",
+    "utf8"
+  );
+  await writeFile3(path5.join(dir, "tsconfig.json"), LOCAL_TSCONFIG, "utf8");
+  await writeFile3(path5.join(dir, "src/server/index.ts"), LOCAL_SERVER_ENTRY(id), "utf8");
+  await writeFile3(path5.join(dir, "src/server/service.ts"), LOCAL_SERVICE, "utf8");
+  await writeFile3(path5.join(dir, "src/server/handler.ts"), LOCAL_HANDLER, "utf8");
+  await writeFile3(path5.join(dir, "src/client/index.ts"), LOCAL_CLIENT_INDEX, "utf8");
+  await writeFile3(path5.join(dir, "src/index.ts"), LOCAL_ROOT_INDEX, "utf8");
+  return id;
+}
+
+// src/apps-deps.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
+import { writeFile as writeFile4 } from "fs/promises";
+import path6 from "path";
+var APP_TARGETS = ["apps/server/package.json", "apps/client/package.json"];
+async function updateAppsDependency(appDir, pkgName, action) {
+  let changed = false;
+  for (const rel of APP_TARGETS) {
+    const file = path6.join(appDir, rel);
+    if (!existsSync4(file)) continue;
+    const pkg = JSON.parse(readFileSync3(file, "utf8"));
+    const deps = pkg.dependencies ??= {};
+    if (action === "add" && !deps[pkgName]) {
+      deps[pkgName] = "workspace:*";
+      changed = true;
+    } else if (action === "remove" && deps[pkgName]) {
+      delete deps[pkgName];
+      changed = true;
+    }
+    if (changed) await writeFile4(file, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+  return changed;
+}
+async function removePackageDir(appDir, id) {
+  const dir = path6.join(appDir, "packages", id);
+  if (!existsSync4(dir)) return false;
+  const { rm: rm2 } = await import("fs/promises");
+  await rm2(dir, { recursive: true, force: true });
+  return true;
+}
+
+// src/sync-all.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { readFile as readFile3, writeFile as writeFile6 } from "fs/promises";
+import path9 from "path";
+
+// src/assembly.ts
+var ASSEMBLY_FILES = [
+  { path: "apps/server/src/modules.ts", kind: "server-modules" },
+  { path: "apps/client/src/modules.ts", kind: "client-modules" }
+];
+function camelCaseId(id) {
+  return id.split(/[^A-Za-z0-9]+/).filter(Boolean).map(
+    (part, i) => i === 0 ? part.toLowerCase() : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+  ).join("");
+}
+function importAlias(kind, id) {
+  return camelCaseId(id);
+}
+function contributesTo(kind, m) {
+  return KINDS[kind].contributes(m);
+}
+function idFromPkg(pkg) {
+  return pkg.replace(/^@[^/]+\//, "").replace(/\/(server|client)$/, "").replace(/\/$/, "");
+}
+var KINDS = {
+  "server-modules": {
+    mapMarker: "register",
+    importExport: "serverModule",
+    importSuffix: "server",
+    entryPattern: /^\s*([A-Za-z_$][\w$]*),\s*$/,
+    header: "const modules = [",
+    footer: "];",
+    contributes: (m) => m.hasServerEntry
+  },
+  "client-modules": {
+    mapMarker: "register",
+    importExport: "clientModule",
+    importSuffix: "client",
+    entryPattern: /^\s*([A-Za-z_$][\w$]*),\s*$/,
+    header: "const modules = [",
+    footer: "];",
+    // 客户端装配仅收录"有卡片 + 有 clientModule 入口"的模块；老形态（无 clientModule）跳过并由
+    // assembly-drift 告警提示升级（D8：新 app + 老模块 → 探测缺失跳过）
+    contributes: (m) => m.hasClientEntry && m.hasCards
+  }
+};
+var IMPORT_LINE_PATTERN = /^import\s*\{\s*([\w$]+)\s+as\s+([\w$]+)\s*\}\s*from\s*['"]([^'"]+)['"];\s*$/;
+function extractBlock(content, marker) {
+  const begin = `// @tbox:${marker}-begin`;
+  const end = `// @tbox:${marker}-end`;
+  const bIdx = content.indexOf(begin);
+  if (bIdx === -1) return null;
+  const eIdx = content.indexOf(end, bIdx);
+  if (eIdx === -1) return null;
+  const start = bIdx + begin.length;
+  return { block: content.slice(start, eIdx), start, end: eIdx };
+}
+function replaceBlock(content, range, newBlock) {
+  return content.slice(0, range.start) + newBlock + content.slice(range.end);
+}
+function parseAssemblyFile(content, kind) {
+  const spec = KINDS[kind];
+  const moduleIds = [];
+  const nonStandardLines = [];
+  const broken = [];
+  const imports = extractBlock(content, "imports");
+  if (imports) {
+    for (const line of imports.block.split(/\r?\n/)) {
+      const m = line.match(IMPORT_LINE_PATTERN);
+      if (m) {
+        moduleIds.push(idFromPkg(m[3]));
+      } else if (line.trim()) {
+        nonStandardLines.push(`imports: ${line.trim()}`);
+      }
+    }
+  } else {
+    broken.push("imports");
+  }
+  const map = extractBlock(content, spec.mapMarker);
+  if (map) {
+    const lines = map.block.split(/\r?\n/);
+    const headIdx = lines.findIndex((l) => l.trim().startsWith(spec.header));
+    const tailIdx = [...lines].reverse().findIndex((l) => l.trim() === spec.footer);
+    const lastIdx = tailIdx === -1 ? -1 : lines.length - 1 - tailIdx;
+    if (headIdx === -1 || lastIdx <= headIdx) {
+      broken.push(spec.mapMarker);
+    } else {
+      for (const line of lines.slice(headIdx + 1, lastIdx)) {
+        if (!line.match(spec.entryPattern) && line.trim()) {
+          nonStandardLines.push(`${spec.mapMarker}: ${line.trim()}`);
+        }
+      }
+    }
+  } else {
+    broken.push(spec.mapMarker);
+  }
+  const aliasToId = /* @__PURE__ */ new Map();
+  if (imports) {
+    for (const line of imports.block.split(/\r?\n/)) {
+      const m = line.match(IMPORT_LINE_PATTERN);
+      if (m) aliasToId.set(m[2], idFromPkg(m[3]));
+    }
+  }
+  const mapIds = [];
+  if (map) {
+    const lines = map.block.split(/\r?\n/);
+    const headIdx = lines.findIndex((l) => l.trim().startsWith(spec.header));
+    const tailIdx = [...lines].reverse().findIndex((l) => l.trim() === spec.footer);
+    const lastIdx = tailIdx === -1 ? -1 : lines.length - 1 - tailIdx;
+    if (headIdx !== -1 && lastIdx > headIdx) {
+      for (const line of lines.slice(headIdx + 1, lastIdx)) {
+        const m = line.match(spec.entryPattern);
+        if (m) {
+          const id = aliasToId.get(m[1]);
+          if (id) mapIds.push(id);
+        }
+      }
+    }
+  }
+  return {
+    moduleIds: [.../* @__PURE__ */ new Set([...moduleIds, ...mapIds])],
+    nonStandardLines,
+    broken
+  };
+}
+function syncAssemblyFile(content, kind, declared, force = false) {
+  const spec = KINDS[kind];
+  const warnings = [];
+  const desired = declared.filter(spec.contributes);
+  const desiredByAlias = new Map(desired.map((m) => [importAlias(kind, m.id), m]));
+  let next = content;
+  let changed = false;
+  const importsRange = extractBlock(next, "imports");
+  if (!importsRange) {
+    warnings.push(`[${kind}] imports \u951A\u533A\u7F3A\u5931/\u7834\u574F\uFF0C\u8DF3\u8FC7`);
+    return { content: next, changed, warnings, moduleIds: [] };
+  }
+  const importLines = importsRange.block.split(/\r?\n/);
+  const keptImports = [];
+  for (const line of importLines) {
+    const m = line.match(IMPORT_LINE_PATTERN);
+    if (!m) {
+      if (line.trim() === "") continue;
+      if (!force) warnings.push(`[${kind}] imports \u951A\u533A\u975E\u6807\u884C\u4FDD\u7559: ${line.trim()}`);
+      if (!force) keptImports.push(line);
+      continue;
+    }
+    const localName = m[2];
+    const pkg = m[3];
+    const target = desiredByAlias.get(localName);
+    if (target && idFromPkg(target.pkg) === idFromPkg(pkg)) {
+      keptImports.push(line);
+    } else if (target) {
+      keptImports.push(specImportLine(kind, localName, target.pkg));
+      changed = true;
+    } else {
+      changed = true;
+    }
+  }
+  for (const m of desired) {
+    const localName = importAlias(kind, m.id);
+    if (!keptImports.some((l) => l.includes(`as ${localName} } from`))) {
+      keptImports.push(specImportLine(kind, localName, m.pkg));
+      changed = true;
+    }
+  }
+  const newImportsBlock = normalizeBlock(keptImports.join("\n"));
+  if (newImportsBlock !== importsRange.block) {
+    next = replaceBlock(next, importsRange, newImportsBlock);
+    changed = true;
+  }
+  const mapRange = extractBlock(next, spec.mapMarker);
+  if (!mapRange) {
+    warnings.push(`[${kind}] ${spec.mapMarker} \u951A\u533A\u7F3A\u5931/\u7834\u574F\uFF0C\u8DF3\u8FC7`);
+    return { content: next, changed, warnings, moduleIds: [] };
+  }
+  const mapLines = mapRange.block.split(/\r?\n/);
+  const headIdx = mapLines.findIndex((l) => l.trim().startsWith(spec.header));
+  const reverseTailIdx = [...mapLines].reverse().findIndex((l) => l.trim() === spec.footer);
+  const tailIdx = reverseTailIdx === -1 ? -1 : mapLines.length - 1 - reverseTailIdx;
+  if (headIdx === -1 || tailIdx <= headIdx) {
+    if (force) {
+      const forcedBlock = normalizeBlock([spec.header, ...desired.map((m) => specEntryLine(kind, importAlias(kind, m.id))), spec.footer].join("\n"));
+      if (forcedBlock !== mapRange.block) {
+        next = replaceBlock(next, mapRange, forcedBlock);
+        changed = true;
+      }
+      return { content: next, changed, warnings, moduleIds: desired.map((m) => m.id) };
+    }
+    warnings.push(`[${kind}] ${spec.mapMarker} \u951A\u533A\u7ED3\u6784\u4E0D\u7B26\u5408\u9884\u671F\uFF0C\u964D\u7EA7\u4E3A\u544A\u8B66\u4E0D\u8986\u76D6`);
+    return { content: next, changed, warnings, moduleIds: [] };
+  }
+  const preservedHead = mapLines.slice(0, headIdx);
+  const preservedTail = mapLines.slice(tailIdx + 1);
+  const body = mapLines.slice(headIdx + 1, tailIdx);
+  const keptEntries = [];
+  for (const line of body) {
+    const m = line.match(spec.entryPattern);
+    if (!m) {
+      if (line.trim() === "") continue;
+      if (!force) warnings.push(`[${kind}] ${spec.mapMarker} \u951A\u533A\u975E\u6807\u884C\u4FDD\u7559: ${line.trim()}`);
+      if (!force) keptEntries.push(line);
+      continue;
+    }
+    const localName = m[1];
+    if (desiredByAlias.has(localName)) {
+      keptEntries.push(specEntryLine(kind, localName));
+    } else {
+      changed = true;
+    }
+  }
+  for (const m of desired) {
+    const localName = importAlias(kind, m.id);
+    if (!keptEntries.some((l) => l.includes(localName))) {
+      keptEntries.push(specEntryLine(kind, localName));
+      changed = true;
+    }
+  }
+  const newMapBlock = normalizeBlock(
+    [...preservedHead, spec.header, ...keptEntries, spec.footer, ...preservedTail].join("\n")
+  );
+  if (newMapBlock !== mapRange.block) {
+    next = replaceBlock(next, mapRange, newMapBlock);
+    changed = true;
+  }
+  return { content: next, changed, warnings, moduleIds: desired.map((m) => m.id) };
+}
+function normalizeBlock(block) {
+  const lines = block.split(/\r?\n/);
+  while (lines.length > 0 && lines[0].trim() === "") lines.shift();
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+  return "\n" + lines.join("\n") + "\n";
+}
+function specImportLine(kind, localName, pkg) {
+  const spec = KINDS[kind];
+  return `import { ${spec.importExport} as ${localName} } from '${pkg}/${spec.importSuffix}';`;
+}
+function specEntryLine(kind, localName) {
+  return `  ${localName},`;
+}
+
+// src/declared.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import path7 from "path";
+
+// src/component-schema.ts
+import { z } from "zod";
+var cardContribSchema = z.object({
+  cardType: z.string(),
+  schemaVersion: z.number().optional()
+});
+var pageContribSchema = z.object({
+  route: z.string(),
+  component: z.string()
+});
+var tabContribSchema = z.object({
+  route: z.string(),
+  label: z.string(),
+  icon: z.string().optional(),
+  order: z.number().optional()
+});
+var moduleDependencySchema = z.object({
+  id: z.string(),
+  range: z.string().optional(),
+  required: z.boolean().default(true)
+});
+var componentDescriptorSchema = z.object({
+  schemaVersion: z.number().default(1),
+  name: z.string(),
+  version: z.string().default("0.0.0"),
+  kind: z.enum(["platform", "business", "third-party"]).default("business"),
+  risk: z.object({
+    level: z.enum(["high", "medium", "low"]).default("low"),
+    writeBoundary: z.enum(["sdk-enforced", "source"]).default("source")
+  }).default({}),
+  distribution: z.object({
+    defaultMode: z.enum(["hybrid", "sdk", "codegen", "local"]).default("codegen")
+  }).default({}),
+  contributes: z.object({
+    handlers: z.array(z.string()).default([]),
+    tools: z.array(z.string()).default([]),
+    cards: z.array(cardContribSchema).default([]),
+    routes: z.array(z.string()).default([]),
+    pages: z.array(pageContribSchema).default([]),
+    tabs: z.array(tabContribSchema).default([])
+  }).default({}),
+  dependencies: z.object({
+    modules: z.array(moduleDependencySchema).default([])
+  }).default({}),
+  env: z.array(z.string()).default([])
+}).strict();
+function parseComponentDescriptor(raw) {
+  const result = componentDescriptorSchema.safeParse(raw);
+  if (result.success) return { ok: true, value: result.data };
+  return {
+    ok: false,
+    errors: result.error.issues.map(
+      (issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`
+    )
+  };
+}
+
+// src/declared.ts
+function readComponentFile(dir) {
+  const file = path7.join(dir, "tbox.component.json");
+  if (!existsSync5(file)) return null;
+  try {
+    const parsed = parseComponentDescriptor(JSON.parse(readFileSync4(file, "utf8")));
+    return parsed.ok ? parsed.value : null;
+  } catch {
+    return null;
+  }
+}
+function probeModuleObjectExport(dir, sub, symbol) {
+  const file = path7.join(dir, "src", sub, "index.ts");
+  if (!existsSync5(file)) return false;
+  try {
+    const src = readFileSync4(file, "utf8");
+    return new RegExp(`export\\s+const\\s+${symbol}\\b`).test(src);
+  } catch {
+    return false;
+  }
+}
+async function listLocalModules(appDir) {
+  const packagesDir = path7.join(appDir, "packages");
+  const result = [];
+  if (!existsSync5(packagesDir)) return result;
+  const entries = await readdir2(packagesDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = path7.join(packagesDir, entry.name);
+    if (!existsSync5(path7.join(dir, "package.json"))) continue;
+    const descriptor = readComponentFile(dir);
+    if (descriptor) {
+      result.push({ id: descriptor.name ?? entry.name, dir, descriptor });
+    }
+  }
+  return result.sort((a, b) => a.id.localeCompare(b.id));
+}
+function readDescriptorFromNodeModules(appDir, pkg) {
+  try {
+    const p = path7.join(appDir, "node_modules", ...pkg.split("/"), "tbox.component.json");
+    if (!existsSync5(p)) return null;
+    const parsed = parseComponentDescriptor(JSON.parse(readFileSync4(p, "utf8")));
+    return parsed.ok ? parsed.value : null;
+  } catch {
+    return null;
+  }
+}
+async function collectDeclared(appDir) {
+  const manifest = readAppManifest(appDir);
+  const declared = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of manifest?.npmModules ?? []) {
+    seen.add(entry.id);
+    const local = path7.join(appDir, "packages", entry.id);
+    const descriptor = readComponentFile(local) ?? readDescriptorFromNodeModules(appDir, entry.package);
+    const probeDir = existsSync5(path7.join(local, "src")) ? local : path7.join(appDir, "node_modules", ...entry.package.split("/"));
+    const c = descriptor?.contributes;
+    declared.push({
+      id: entry.id,
+      pkg: entry.mode === "sdk" ? entry.package : `@app/${entry.id}`,
+      mode: entry.mode,
+      hasServerEntry: descriptor !== null && probeModuleObjectExport(probeDir, "server", "serverModule"),
+      hasClientEntry: descriptor !== null && probeModuleObjectExport(probeDir, "client", "clientModule"),
+      hasCards: (c?.cards?.length ?? 0) > 0
+    });
+  }
+  for (const mod of await listLocalModules(appDir)) {
+    if (seen.has(mod.id)) continue;
+    const c = mod.descriptor.contributes;
+    declared.push({
+      id: mod.id,
+      pkg: `@app/${mod.id}`,
+      mode: "local",
+      hasServerEntry: probeModuleObjectExport(mod.dir, "server", "serverModule"),
+      hasClientEntry: probeModuleObjectExport(mod.dir, "client", "clientModule"),
+      hasCards: (c.cards?.length ?? 0) > 0
+    });
+  }
+  return declared;
+}
+
+// src/deps-merge.ts
+import { writeFile as writeFile5 } from "fs/promises";
+import path8 from "path";
+import { readFileSync as readFileSync5 } from "fs";
+function readJsonOrNull(p) {
+  try {
+    return JSON.parse(readFileSyncSafe(p) ?? "{}");
+  } catch {
+    return null;
+  }
+}
+async function mergeModuleDeps(appDir, targetPackageJson, moduleDeps) {
+  const file = path8.join(appDir, targetPackageJson);
+  const pkg = readJsonOrNull(file) ?? {};
+  const deps = pkg.dependencies ?? {};
+  const merged = {};
+  const conflicts = [];
+  for (const [name, spec] of Object.entries(moduleDeps)) {
+    if (isPlatform(name)) continue;
+    if (spec === "workspace:*" || spec.startsWith("catalog:")) continue;
+    const existing = deps[name];
+    if (!existing) {
+      deps[name] = spec;
+      merged[name] = spec;
+      continue;
+    }
+    if (existing === spec) continue;
+    const inter = intersectRanges(existing, spec);
+    if (inter) {
+      if (inter !== existing) {
+        deps[name] = inter;
+        merged[name] = inter;
+      }
+    } else {
+      conflicts.push(`${name}: \u5DF2\u6709 ${existing}\uFF0C\u6A21\u5757\u8981\u6C42 ${spec}`);
+    }
+  }
+  pkg.dependencies = deps;
+  await writeFile5(file, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  return { merged, conflicts };
+}
+function intersectRanges(a, b) {
+  const clean = (s) => s.replace(/^\^/, "");
+  const pa = parseVer(clean(a));
+  const pb = parseVer(clean(b));
+  if (!pa || !pb) return null;
+  if (pa.major !== pb.major) return null;
+  if (pa.minor > pb.minor) return a;
+  if (pb.minor > pa.minor) return b;
+  return pa.patch > pb.patch ? a : b;
+}
+function parseVer(v) {
+  const m = v.match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (!m) return null;
+  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3] ?? 0) };
+}
+function readFileSyncSafe(p) {
+  try {
+    return readFileSync5(p, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/sync-all.ts
+async function syncAll(appDir, opts = {}) {
+  const declared = await collectDeclared(appDir);
+  const warnings = [];
+  const changedFiles = [];
+  const depConflicts = [];
+  for (const file of ASSEMBLY_FILES) {
+    const full = path9.join(appDir, file.path);
+    if (!existsSync6(full)) {
+      warnings.push(`\u7F3A\u5C11\u88C5\u914D\u6587\u4EF6 ${file.path}`);
+      continue;
+    }
+    const content = await readFile3(full, "utf8");
+    const result = syncAssemblyFile(content, file.kind, declared, opts.force ?? false);
+    warnings.push(...result.warnings.map((w) => `${file.path}: ${w}`));
+    if (result.changed) {
+      await writeFile6(full, result.content, "utf8");
+      changedFiles.push(file.path);
+    }
+  }
+  const targets = ["apps/server/package.json", "apps/client/package.json"];
+  for (const mod of declared) {
+    const pkgFile = path9.join(appDir, "packages", mod.id, "package.json");
+    if (!existsSync6(pkgFile)) continue;
+    let deps = {};
+    try {
+      deps = JSON.parse(readFileSync6(pkgFile, "utf8")).dependencies ?? {};
+    } catch {
+      continue;
+    }
+    for (const target of targets) {
+      if (!existsSync6(path9.join(appDir, target))) continue;
+      const result = await mergeModuleDeps(appDir, target, deps);
+      depConflicts.push(...result.conflicts.map((c) => `${mod.id} \u2192 ${target}: ${c}`));
+    }
+  }
+  return { declared, changedFiles, warnings, depConflicts };
+}
+
+// src/diff.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import path10 from "path";
+async function collectActual(appDir) {
+  const result = {};
+  for (const file of ASSEMBLY_FILES) {
+    const full = path10.join(appDir, file.path);
+    if (!existsSync7(full)) {
+      result[file.kind] = { moduleIds: [], nonStandardLines: [], broken: ["missing-file"] };
+      continue;
+    }
+    const content = await readFile4(full, "utf8");
+    const parsed = parseAssemblyFile(content, file.kind);
+    result[file.kind] = {
+      moduleIds: parsed.moduleIds,
+      nonStandardLines: parsed.nonStandardLines,
+      broken: parsed.broken
+    };
+  }
+  return result;
+}
+
+// src/doctor/rules/workspace-dag.ts
+import { existsSync as existsSync8 } from "fs";
+import { readdir as readdir4 } from "fs/promises";
+import path12 from "path";
+
+// src/doctor/util.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import path11 from "path";
+async function walkFiles(dir, base, out) {
+  const entries = await readdir3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+    const full = path11.join(dir, entry.name);
+    if (entry.isDirectory()) await walkFiles(full, base, out);
+    else if (entry.isFile() && /\.(ts|tsx|mjs|js)$/.test(entry.name)) {
+      out.push(path11.relative(base, full).split(path11.sep).join("/"));
+    }
+  }
+}
+async function readTextOrEmpty(p) {
+  try {
+    return await readFile5(p, "utf8");
+  } catch {
+    return "";
+  }
+}
+function readJsonOrNull2(p) {
+  try {
+    return JSON.parse(readFileSync7(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readPkgJson(dir) {
+  return readJsonOrNull2(path11.join(dir, "package.json"));
+}
+function intersectRanges2(a, b) {
+  const clean = (s) => s.replace(/^\^/, "");
+  const pa = parseVer2(clean(a));
+  const pb = parseVer2(clean(b));
+  if (!pa || !pb) return null;
+  if (pa.major !== pb.major) return null;
+  if (pa.minor > pb.minor) return a;
+  if (pb.minor > pa.minor) return b;
+  return pa.patch > pb.patch ? a : b;
+}
+function parseVer2(v) {
+  const m = v.match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (!m) return null;
+  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3] ?? 0) };
+}
+
+// src/doctor/rules/workspace-dag.ts
+async function workspaceDagRule(ctx) {
+  const issues = [];
+  const packagesDir = path12.join(ctx.appDir, "packages");
+  if (!existsSync8(packagesDir)) return issues;
+  for (const entry of await readdir4(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dir = path12.join(packagesDir, entry.name);
+    if (!existsSync8(path12.join(dir, "tbox.component.json"))) continue;
+    const pkg = readPkgJson(dir);
+    const allDeps = { ...pkg?.dependencies ?? {}, ...pkg?.peerDependencies ?? {} };
+    for (const name of Object.keys(allDeps)) {
+      if (/^@app\/(module|scenario)-/.test(name) || /^@tbox\.cn\/app-(module|scenario)-/.test(name)) {
+        issues.push({
+          rule: "workspace-dag",
+          level: "error",
+          message: `${entry.name} \u4F9D\u8D56\u4E1A\u52A1\u6A21\u5757 ${name}\uFF08module \u4E0D\u5F97\u4F9D\u8D56 module/scenario\uFF09`
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/register-pure.ts
+import { existsSync as existsSync9 } from "fs";
+import { readdir as readdir5 } from "fs/promises";
+import path13 from "path";
+
+// src/doctor/ast.ts
+import ts from "typescript";
+function parseSource(src) {
+  return ts.createSourceFile("entry.ts", src, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function unwrapAs(expr) {
+  if (!expr) return expr;
+  if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) return expr.expression;
+  return expr;
+}
+function findFunctionBody(src, name) {
+  const sf = parseSource(src);
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts.isFunctionDeclaration(node) && node.name?.text === name && node.body) {
+      result = node.body;
+      return;
+    }
+    if (ts.isVariableStatement(node) && node.declarationList.declarations.some(
+      (d) => ts.isIdentifier(d.name) && d.name.text === name
+    )) {
+      const decl = node.declarationList.declarations.find(
+        (d) => ts.isIdentifier(d.name) && d.name.text === name
+      );
+      const init = unwrapAs(decl.initializer);
+      if (init && ts.isArrowFunction(init) && init.body && ts.isBlock(init.body)) {
+        result = init.body;
+        return;
+      }
+      const methodBody = objectMethodBody(init, "register");
+      if (methodBody) {
+        result = methodBody;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return result;
+}
+function objectMethodBody(init, methodName) {
+  if (!init || !ts.isObjectLiteralExpression(init)) return null;
+  for (const prop of init.properties) {
+    if (ts.isMethodDeclaration(prop) && prop.name.getText() === methodName && prop.body) {
+      return prop.body;
+    }
+    if (ts.isPropertyAssignment(prop) && prop.name.getText() === methodName && prop.initializer) {
+      const fn = prop.initializer;
+      if (ts.isArrowFunction(fn) && fn.body && ts.isBlock(fn.body)) return fn.body;
+      if (ts.isFunctionExpression(fn) && fn.body) return fn.body;
+    }
+  }
+  return null;
+}
+function findModuleRegisterBody(src, objectName) {
+  const sf = parseSource(src);
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts.isVariableStatement(node) && node.declarationList.declarations.some(
+      (d) => ts.isIdentifier(d.name) && d.name.text === objectName
+    )) {
+      const decl = node.declarationList.declarations.find(
+        (d) => ts.isIdentifier(d.name) && d.name.text === objectName
+      );
+      const methodBody = objectMethodBody(unwrapAs(decl.initializer), "register");
+      if (methodBody) {
+        result = methodBody;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return result ?? findFunctionBody(src, "registerServer");
+}
+function hasTopLevelResolveService(body) {
+  let found = false;
+  function visit(node) {
+    if (found) return;
+    if (ts.isArrowFunction(node)) return;
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isIdentifier(expr) && expr.text === "resolveService") {
+        found = true;
+        return;
+      }
+      const text = expr.getText();
+      if (text === "ctx.resolveService" || text.endsWith(".services.resolve")) {
+        found = true;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(body);
+  return found;
+}
+function hasCardsRegisterCall(body) {
+  let found = false;
+  function visit(node) {
+    if (found) return;
+    if (ts.isCallExpression(node)) {
+      const text = node.expression.getText();
+      if (text.endsWith(".cards.registerMap") || text.endsWith(".cards.register")) {
+        found = true;
+        return;
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(body);
+  return found;
+}
+function extractCardsRegisterArgs(src) {
+  const sf = parseSource(src);
+  const args = [];
+  function visit(node) {
+    if (ts.isCallExpression(node)) {
+      const exprText = node.expression.getText();
+      if (exprText.endsWith(".cards.register")) {
+        const arg = node.arguments[0];
+        if (arg) args.push(arg.getText().replace(/['"]/g, ""));
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return args;
+}
+function extractRelativeImports(src) {
+  const sf = parseSource(src);
+  const map = {};
+  function visit(node) {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+      const spec = node.moduleSpecifier.text;
+      if (spec.startsWith("./") || spec.startsWith("../")) {
+        const clause = node.importClause;
+        if (clause?.name) {
+          map[clause.name.text] = spec;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return map;
+}
+
+// src/doctor/rules/register-pure.ts
+async function registerPureRule(ctx) {
+  const issues = [];
+  const packagesDir = path13.join(ctx.appDir, "packages");
+  if (!existsSync9(packagesDir)) return issues;
+  for (const entry of await readdir5(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const entryFile = path13.join(packagesDir, entry.name, "src/server/index.ts");
+    if (!existsSync9(entryFile)) continue;
+    const src = await readTextOrEmpty(entryFile);
+    const body = findModuleRegisterBody(src, "serverModule");
+    if (body && hasTopLevelResolveService(body)) {
+      issues.push({
+        rule: "register-pure",
+        level: "error",
+        message: `${entry.name}: \u6CE8\u518C\u5165\u53E3\uFF08serverModule.register\uFF09\u5185\u51FA\u73B0 resolveService\uFF08\u53EA\u5141\u8BB8\u5728 handle/\u4E8B\u4EF6\u56DE\u8C03\u5185\uFF09`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/doctor/module-cards.ts
+import { existsSync as existsSync10 } from "fs";
+import path14 from "path";
+import ts2 from "typescript";
+function unwrapAs2(expr) {
+  if (ts2.isAsExpression(expr) || ts2.isSatisfiesExpression(expr)) return expr.expression;
+  return expr;
+}
+function parseCardsObject(src, objectName) {
+  const sf = parseSource(src);
+  let result = null;
+  function mapFromObject(obj) {
+    const map = {};
+    for (const prop of obj.properties) {
+      if (!ts2.isPropertyAssignment(prop)) continue;
+      const name = prop.name;
+      const key = ts2.isIdentifier(name) ? name.text : ts2.isStringLiteral(name) ? name.text : "";
+      if (key) map[key] = prop.initializer;
+    }
+    return map;
+  }
+  for (const stmt of sf.statements) {
+    if (!ts2.isVariableStatement(stmt)) continue;
+    for (const d of stmt.declarationList.declarations) {
+      if (!ts2.isIdentifier(d.name) || !d.initializer) continue;
+      if (d.name.text === "cards") {
+        const init = unwrapAs2(d.initializer);
+        if (ts2.isObjectLiteralExpression(init)) {
+          result = mapFromObject(init);
+          return result;
+        }
+      }
+      if (objectName && d.name.text === objectName) {
+        const init = unwrapAs2(d.initializer);
+        if (ts2.isObjectLiteralExpression(init)) {
+          for (const prop of init.properties) {
+            if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name) && prop.name.text === "cards") {
+              const cardsInit = unwrapAs2(prop.initializer);
+              if (ts2.isObjectLiteralExpression(cardsInit)) {
+                result = mapFromObject(cardsInit);
+                return result;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function parseClientCardsMap(src) {
+  const map = parseCardsObject(src, "clientModule");
+  return map ? Object.keys(map) : [];
+}
+function extractMetaFields(src) {
+  const ct = src.match(/cardType:\s*['"]([^'"]+)['"]/);
+  const sv = src.match(/schemaVersion:\s*(\d+)/);
+  return {
+    cardType: ct?.[1],
+    schemaVersion: sv ? Number(sv[1]) : void 0
+  };
+}
+function resolveTsPath(base, rel) {
+  const candidates = [rel, `${rel}.ts`, `${rel}.tsx`, `${rel}/index.ts`, `${rel}/index.tsx`];
+  for (const c of candidates) {
+    if (existsSync10(path14.join(base, c))) return path14.join(base, c);
+  }
+  return null;
+}
+function resolveValueCardType(expr, imports, baseDir) {
+  const e = unwrapAs2(expr);
+  if (ts2.isObjectLiteralExpression(e)) {
+    const fields = extractMetaFields(e.getText());
+    return { cardType: fields.cardType, schemaVersion: fields.schemaVersion };
+  }
+  if (ts2.isStringLiteral(e)) {
+    return { cardType: e.text };
+  }
+  if (ts2.isIdentifier(e)) {
+    const rel = imports[e.text];
+    if (!rel) return null;
+    const resolved = resolveTsPath(baseDir, rel.replace(/^\.\//, ""));
+    if (!resolved) return null;
+    return { resolved };
+  }
+  return null;
+}
+async function resolveServerRegisteredCards(modDir) {
+  const entryFile = path14.join(modDir, "src/server/index.ts");
+  if (!existsSync10(entryFile)) return { cardTypes: [], schemaVersions: {}, keyMismatches: [], registerMissing: false };
+  const entrySrc = await readTextOrEmpty(entryFile);
+  const imports = extractRelativeImports(entrySrc);
+  const baseDir = path14.join(modDir, "src/server");
+  const cardTypes = [];
+  const schemaVersions = {};
+  const keyMismatches = [];
+  const cardsMap = parseCardsObject(entrySrc, "serverModule");
+  if (cardsMap) {
+    let registerMissing = false;
+    if (Object.keys(cardsMap).length > 0) {
+      const registerBody = findModuleRegisterBody(entrySrc, "serverModule");
+      registerMissing = !registerBody || !hasCardsRegisterCall(registerBody);
+    }
+    for (const [key, expr] of Object.entries(cardsMap)) {
+      const value = resolveValueCardType(expr, imports, baseDir);
+      if (!value) continue;
+      if (value.resolved) {
+        const metaSrc = await readTextOrEmpty(value.resolved);
+        const fields = extractMetaFields(metaSrc);
+        if (fields.cardType) {
+          cardTypes.push(fields.cardType);
+          if (fields.schemaVersion) schemaVersions[fields.cardType] = fields.schemaVersion;
+          if (key !== fields.cardType) keyMismatches.push({ key, cardType: fields.cardType });
+        }
+      } else if (value.cardType) {
+        cardTypes.push(value.cardType);
+        if (value.schemaVersion) schemaVersions[value.cardType] = value.schemaVersion;
+        if (key !== value.cardType) keyMismatches.push({ key, cardType: value.cardType });
+      }
+    }
+    return { cardTypes: [...new Set(cardTypes)], schemaVersions, keyMismatches, registerMissing };
+  }
+  for (const arg of extractCardsRegisterArgs(entrySrc)) {
+    if (arg.includes("cardType:")) {
+      const fields2 = extractMetaFields(arg);
+      if (fields2.cardType) {
+        cardTypes.push(fields2.cardType);
+        if (fields2.schemaVersion) schemaVersions[fields2.cardType] = fields2.schemaVersion;
+      }
+      continue;
+    }
+    if (/^[a-zA-Z0-9][\w-]*$/.test(arg) && !imports[arg]) {
+      cardTypes.push(arg);
+      continue;
+    }
+    const rel = imports[arg];
+    if (!rel) continue;
+    const resolved = resolveTsPath(baseDir, rel.replace(/^\.\//, ""));
+    if (!resolved) continue;
+    const metaSrc = await readTextOrEmpty(resolved);
+    const fields = extractMetaFields(metaSrc);
+    if (fields.cardType) {
+      cardTypes.push(fields.cardType);
+      if (fields.schemaVersion) schemaVersions[fields.cardType] = fields.schemaVersion;
+    }
+  }
+  return { cardTypes: [...new Set(cardTypes)], schemaVersions, keyMismatches, registerMissing: false };
+}
+function hasModuleObject(src, objectName) {
+  const sf = parseSource(src);
+  return sf.statements.some(
+    (stmt) => ts2.isVariableStatement(stmt) && stmt.declarationList.declarations.some(
+      (d) => ts2.isIdentifier(d.name) && d.name.text === objectName
+    )
+  );
+}
+async function resolveClientRegisterMissing(modDir) {
+  const entryFile = path14.join(modDir, "src/client/index.ts");
+  if (!existsSync10(entryFile)) return false;
+  const entrySrc = await readTextOrEmpty(entryFile);
+  if (!hasModuleObject(entrySrc, "clientModule")) return false;
+  const cardsMap = parseCardsObject(entrySrc, "clientModule");
+  if (!cardsMap || Object.keys(cardsMap).length === 0) return false;
+  const registerBody = findModuleRegisterBody(entrySrc, "clientModule");
+  return !registerBody || !hasCardsRegisterCall(registerBody);
+}
+async function collectModuleCards(ctx) {
+  const modules = await listLocalModules(ctx.appDir);
+  const result = [];
+  for (const mod of modules) {
+    const declared = {};
+    for (const c of mod.descriptor.contributes.cards ?? []) {
+      declared[c.cardType] = c.schemaVersion ?? 1;
+    }
+    const clientFile = path14.join(mod.dir, "src/client/index.ts");
+    const clientMap = existsSync10(clientFile) ? parseClientCardsMap(await readTextOrEmpty(clientFile)) : [];
+    const server = await resolveServerRegisteredCards(mod.dir);
+    result.push({
+      id: mod.id,
+      declared,
+      clientMap,
+      serverRegistered: server.cardTypes,
+      serverSchemaVersions: server.schemaVersions,
+      serverKeyMismatches: server.keyMismatches,
+      serverRegisterMissing: server.registerMissing,
+      clientRegisterMissing: await resolveClientRegisterMissing(mod.dir)
+    });
+  }
+  return result;
+}
+
+// src/doctor/rules/card-type-consistent.ts
+async function cardTypeConsistentRule(ctx) {
+  const issues = [];
+  for (const mod of await collectModuleCards(ctx)) {
+    const declared = Object.keys(mod.declared);
+    if (declared.length === 0 && mod.serverKeyMismatches.length === 0 && !mod.serverRegisterMissing && !mod.clientRegisterMissing) {
+      continue;
+    }
+    for (const mm of mod.serverKeyMismatches) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "error",
+        message: `${mod.id}: serverModule.cards key "${mm.key}" !== meta.cardType "${mm.cardType}"\uFF08key \u7EA6\u5B9A = cardType\uFF09`
+      });
+    }
+    if (mod.serverRegisterMissing) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "error",
+        message: `${mod.id}: serverModule \u58F0\u660E\u4E86 cards \u4F46 register \u5185\u672A\u8C03\u7528 ctx.cards.registerMap(cards)\uFF08\u6CE8\u518C\u52A8\u4F5C\u7F3A\u5931\uFF0C\u8FD0\u884C\u65F6\u7F3A\u5361\uFF09`
+      });
+    }
+    if (mod.clientRegisterMissing) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "error",
+        message: `${mod.id}: clientModule \u58F0\u660E\u4E86 cards \u4F46 register \u5185\u672A\u8C03\u7528 ctx.cards.registerMap(cards)\uFF08\u6CE8\u518C\u52A8\u4F5C\u7F3A\u5931\uFF0C\u8FD0\u884C\u65F6\u7F3A\u5361\uFF09`
+      });
+    }
+    const missingClient = declared.filter((t) => !mod.clientMap.includes(t));
+    if (missingClient.length > 0) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "error",
+        message: `${mod.id}: \u58F0\u660E\u5361\u7247 ${missingClient.join(",")} \u672A\u5728\u5BA2\u6237\u7AEF cards map \u5BFC\u51FA`
+      });
+    }
+    const missingServer = declared.filter((t) => !mod.serverRegistered.includes(t));
+    if (missingServer.length > 0) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "error",
+        message: `${mod.id}: \u58F0\u660E\u5361\u7247 ${missingServer.join(",")} \u672A\u5728\u670D\u52A1\u7AEF\u6CE8\u518C\uFF08serverModule.cards meta / cards.register\uFF09`
+      });
+    }
+    const extraClient = mod.clientMap.filter((t) => !declared.includes(t));
+    if (extraClient.length > 0) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "warning",
+        message: `${mod.id}: \u5BA2\u6237\u7AEF\u5BFC\u51FA\u672A\u58F0\u660E\u7684\u5361\u7247 ${extraClient.join(",")}`
+      });
+    }
+    const extraServer = mod.serverRegistered.filter((t) => !declared.includes(t));
+    if (extraServer.length > 0) {
+      issues.push({
+        rule: "card-type-consistent",
+        level: "warning",
+        message: `${mod.id}: \u670D\u52A1\u7AEF\u6CE8\u518C\u672A\u58F0\u660E\u7684\u5361\u7247 ${extraServer.join(",")}`
+      });
+    }
+  }
+  return issues;
+}
+async function clientCardCoverRule(ctx) {
+  const issues = [];
+  const mods = await collectModuleCards(ctx);
+  const registered = {};
+  for (const mod of mods) {
+    for (const t of mod.serverRegistered) {
+      if (t in registered) registered[t] += `,${mod.id}`;
+      else registered[t] = mod.id;
+    }
+  }
+  if (Object.keys(registered).length === 0) return issues;
+  const assembled = /* @__PURE__ */ new Set();
+  for (const mod of mods) {
+    for (const t of mod.clientMap) assembled.add(t);
+  }
+  for (const [cardType, moduleIds] of Object.entries(registered)) {
+    if (!assembled.has(cardType)) {
+      issues.push({
+        rule: "client-card-cover",
+        level: "error",
+        message: `\u670D\u52A1\u7AEF\u6CE8\u518C\u5361\u7247 ${cardType}\uFF08\u6A21\u5757 ${moduleIds}\uFF09\u672A\u51FA\u73B0\u5728\u5E94\u7528\u5BA2\u6237\u7AEF\u88C5\u914D\uFF08\u6F0F\u88C5\u914D\uFF09`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/contract-version.ts
+import { existsSync as existsSync11 } from "fs";
+import { readdir as readdir6, stat as stat2 } from "fs/promises";
+import path15 from "path";
+async function contractVersionRule(ctx) {
+  const issues = [];
+  const packagesDir = path15.join(ctx.appDir, "packages");
+  if (!existsSync11(packagesDir)) return issues;
+  const installed = /* @__PURE__ */ new Map();
+  for (const entry of await readdir6(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const pkg = readPkgJson(path15.join(packagesDir, entry.name));
+    if (pkg?.name && pkg.name.startsWith("@tbox.cn/app-contracts")) {
+      installed.set(pkg.name, pkg.version ?? "0.0.0");
+    }
+  }
+  const nmScope = path15.join(ctx.appDir, "node_modules", "@tbox.cn");
+  if (existsSync11(nmScope)) {
+    for (const entry of await readdir6(nmScope, { withFileTypes: true })) {
+      const full = path15.join(nmScope, entry.name);
+      let isDir = entry.isDirectory();
+      if (!isDir && entry.isSymbolicLink()) {
+        try {
+          isDir = (await stat2(full)).isDirectory();
+        } catch {
+          isDir = false;
+        }
+      }
+      if (!isDir) continue;
+      const pkg = readPkgJson(full);
+      if (pkg?.name && pkg.name.startsWith("@tbox.cn/app-contracts")) {
+        installed.set(pkg.name, pkg.version ?? "0.0.0");
+      }
+    }
+  }
+  for (const entry of await readdir6(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const dir = path15.join(packagesDir, entry.name);
+    if (!existsSync11(path15.join(dir, "tbox.component.json"))) continue;
+    const pkg = readPkgJson(dir);
+    const allDeps = { ...pkg?.dependencies ?? {}, ...pkg?.peerDependencies ?? {} };
+    for (const [name, range] of Object.entries(allDeps)) {
+      if (!name.startsWith("@tbox.cn/app-contracts")) continue;
+      const installedVersion = installed.get(name);
+      if (!installedVersion) continue;
+      if (range === "*" || range.startsWith("workspace:") || range.startsWith("catalog:")) continue;
+      const cleanRange = range.replace(/^\^/, "");
+      if (cleanRange === installedVersion) continue;
+      const inter = intersectRanges2(range, installedVersion);
+      if (!inter) {
+        issues.push({
+          rule: "contract-version",
+          level: "error",
+          message: `${entry.name}: \u5951\u7EA6 ${name} \u8303\u56F4 ${range} \u4E0E\u5B9E\u88C5 ${installedVersion} \u65E0\u4EA4\u96C6`
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/module-deps-assembled.ts
+import { existsSync as existsSync12 } from "fs";
+import { readdir as readdir7 } from "fs/promises";
+import path16 from "path";
+async function moduleDepsAssembledRule(ctx) {
+  const issues = [];
+  const installedIds = /* @__PURE__ */ new Set();
+  const packagesDir = path16.join(ctx.appDir, "packages");
+  if (existsSync12(packagesDir)) {
+    for (const entry of await readdir7(packagesDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) installedIds.add(entry.name);
+    }
+  }
+  for (const m of ctx.declared) installedIds.add(m.id);
+  const assembledIds = /* @__PURE__ */ new Set();
+  for (const file of ASSEMBLY_FILES) {
+    for (const id of ctx.actual[file.kind]?.moduleIds ?? []) assembledIds.add(id);
+  }
+  const depGraph = /* @__PURE__ */ new Map();
+  const localMods = await listLocalModules(ctx.appDir);
+  for (const mod of localMods) {
+    const deps = (mod.descriptor.dependencies?.modules ?? []).map((d) => d.id);
+    depGraph.set(mod.id, deps);
+  }
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  const cycleStacks = [];
+  function dfs(id, stack) {
+    color.set(id, GRAY);
+    stack.push(id);
+    for (const dep of depGraph.get(id) ?? []) {
+      const c = color.get(dep) ?? WHITE;
+      if (c === GRAY) {
+        const idx = stack.indexOf(dep);
+        if (idx >= 0) cycleStacks.push([...stack.slice(idx), dep]);
+      } else if (c === WHITE) {
+        dfs(dep, stack);
+      }
+    }
+    stack.pop();
+    color.set(id, BLACK);
+  }
+  for (const id of depGraph.keys()) {
+    if ((color.get(id) ?? WHITE) === WHITE) dfs(id, []);
+  }
+  for (const cycle of cycleStacks) {
+    issues.push({
+      rule: "module-deps-assembled",
+      level: "error",
+      message: `dependencies.modules \u58F0\u660E\u5C42\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56\uFF1A${cycle.join(" \u2192 ")}`
+    });
+  }
+  for (const mod of localMods) {
+    for (const dep of mod.descriptor.dependencies?.modules ?? []) {
+      if (dep.required && !installedIds.has(dep.id)) {
+        issues.push({
+          rule: "module-deps-assembled",
+          level: "error",
+          message: `${mod.id}: \u4F9D\u8D56\u6A21\u5757 ${dep.id} \u672A\u5B89\u88C5\uFF08\u7F3A\u5931 packages/${dep.id} \u6216 npm \u6E05\u5355\uFF09`
+        });
+        continue;
+      }
+      const depIsBusiness = localMods.some((m) => m.id === dep.id);
+      if (depIsBusiness && dep.required && !assembledIds.has(dep.id)) {
+        issues.push({
+          rule: "module-deps-assembled",
+          level: "error",
+          message: `${mod.id}: \u4F9D\u8D56\u4E1A\u52A1\u6A21\u5757 ${dep.id} \u5DF2\u5B89\u88C5\u4F46\u672A\u88C5\u914D\uFF08modules.ts \u7F3A\u884C\uFF0C\u8FD0\u884C sync\uFF09`
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/singleton.ts
+import { existsSync as existsSync13 } from "fs";
+import { readdir as readdir8 } from "fs/promises";
+import { createRequire } from "module";
+import { realpathSync as realpathSync2 } from "fs";
+import path17 from "path";
+async function singletonRule(ctx) {
+  const issues = [];
+  const candidates = ["react", "zod", "@mastra/core"];
+  const dirs = ["apps/client", "apps/server", "packages/app-sdk", "packages/contracts"];
+  const packagesDir = path17.join(ctx.appDir, "packages");
+  if (existsSync13(packagesDir)) {
+    for (const entry of await readdir8(packagesDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && existsSync13(path17.join(packagesDir, entry.name, "package.json"))) {
+        dirs.push(path17.join("packages", entry.name));
+      }
+    }
+  }
+  for (const name of candidates) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const rel of dirs) {
+      const dir = path17.join(ctx.appDir, rel);
+      if (!existsSync13(path17.join(dir, "package.json"))) continue;
+      const resolved = resolveFrom(dir, name);
+      if (resolved) {
+        const list = seen.get(resolved) ?? [];
+        list.push(rel);
+        seen.set(resolved, list);
+      }
+    }
+    if (seen.size > 1) {
+      issues.push({
+        rule: "singleton",
+        level: "error",
+        message: `${name} \u89E3\u6790\u7ED3\u679C\u4E0D\u552F\u4E00\uFF1A${[...seen.entries()].map(([p, dirs2]) => `${p}(${dirs2.join(",")})`).join(" vs ")}`
+      });
+    }
+  }
+  return issues;
+}
+function resolveFrom(dir, name) {
+  try {
+    const req = createRequire(path17.join(dir, "__noop__.js"));
+    return realpathSync2(req.resolve(name));
+  } catch {
+    return null;
+  }
+}
+
+// src/doctor/rules/sdk-internal-import.ts
+import { existsSync as existsSync14 } from "fs";
+import path18 from "path";
+var SDK_PUBLIC_ENTRIES = /* @__PURE__ */ new Set([
+  "@tbox.cn/app-sdk",
+  "@tbox.cn/app-sdk/server",
+  "@tbox.cn/app-sdk/client",
+  "@tbox.cn/app-sdk/platform"
+]);
+var FRAMEWORK_INTERNAL_PATTERNS = [
+  { re: /^@mastra\/core/, label: "@mastra/core*\uFF08\u6846\u67B6\u5185\u90E8\uFF0C\u6539\u7ECF @tbox.cn/app-sdk\uFF09" },
+  { re: /^@ag-ui\//, label: "@ag-ui/*\uFF08\u6846\u67B6\u5185\u90E8\uFF0C\u6539\u7ECF @tbox.cn/app-sdk\uFF09" },
+  { re: /^@ai-sdk\//, label: "@ai-sdk/*\uFF08\u6846\u67B6\u5185\u90E8\uFF09" },
+  { re: /^ai$/, label: "ai\uFF08\u6846\u67B6\u5185\u90E8\uFF09" },
+  { re: /^zustand$/, label: "zustand\uFF08\u6846\u67B6\u5185\u90E8\uFF09" }
+];
+async function sdkInternalImportRule(ctx) {
+  const issues = [];
+  const roots = ["apps", "packages"];
+  for (const root of roots) {
+    const rootDir = path18.join(ctx.appDir, root);
+    if (!existsSync14(rootDir)) continue;
+    const files = [];
+    await walkFiles(rootDir, ctx.appDir, files);
+    for (const rel of files) {
+      if (rel.startsWith("packages/app-sdk/") || rel.startsWith("packages/contracts/")) continue;
+      const src = await readTextOrEmpty(path18.join(ctx.appDir, rel));
+      for (const spec of src.matchAll(/from\s+['"]([^'"]+)['"]/g)) {
+        const target = spec[1];
+        if (target.startsWith("@tbox.cn/app-sdk/") && !SDK_PUBLIC_ENTRIES.has(target)) {
+          issues.push({
+            rule: "sdk-internal-import",
+            level: "error",
+            message: `${rel}: \u4E0D\u5141\u8BB8 import SDK \u5185\u90E8\u8DEF\u5F84 ${target}`
+          });
+        } else if (target.startsWith("@tbox.cn/app-contracts/")) {
+          issues.push({
+            rule: "sdk-internal-import",
+            level: "error",
+            message: `${rel}: \u4E0D\u5141\u8BB8 import \u5951\u7EA6\u5B50\u8DEF\u5F84 ${target}\uFF08\u4EC5 @tbox.cn/app-contracts\uFF09`
+          });
+        } else if (isModuleFile(ctx.appDir, rel)) {
+          for (const pat of FRAMEWORK_INTERNAL_PATTERNS) {
+            if (pat.re.test(target)) {
+              issues.push({
+                rule: "sdk-internal-import",
+                level: "error",
+                message: `${rel}: \u6A21\u5757\u4E0D\u5141\u8BB8\u76F4\u63A5 import ${pat.label}`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
+function isModuleFile(appDir, rel) {
+  const m = rel.match(/^packages\/([^/]+)\//);
+  if (!m) return false;
+  return existsSync14(path18.join(appDir, "packages", m[1], "tbox.component.json"));
+}
+
+// src/doctor/rules/assembly-drift.ts
+function assemblyDriftRule(ctx) {
+  const issues = [];
+  for (const file of ASSEMBLY_FILES) {
+    const declaredIds = new Set(
+      ctx.declared.filter((m) => contributesTo(file.kind, m)).map((m) => m.id)
+    );
+    const actualIds = new Set(ctx.actual[file.kind]?.moduleIds ?? []);
+    const missing = [...declaredIds].filter((id) => !actualIds.has(id));
+    const extra = [...actualIds].filter((id) => !declaredIds.has(id));
+    if (missing.length > 0) {
+      issues.push({
+        rule: "assembly-drift",
+        level: "warning",
+        message: `${file.path}: \u5DF2\u58F0\u660E\u672A\u88C5\u914D \u2192 ${missing.join(", ")}`
+      });
+    }
+    if (extra.length > 0) {
+      issues.push({
+        rule: "assembly-drift",
+        level: "warning",
+        message: `${file.path}: \u5DF2\u88C5\u914D\u672A\u58F0\u660E \u2192 ${extra.join(", ")}`
+      });
+    }
+    const broken = ctx.actual[file.kind]?.broken ?? [];
+    if (broken.length > 0) {
+      issues.push({
+        rule: "assembly-drift",
+        level: "warning",
+        message: `${file.path}: \u951A\u533A\u7834\u574F \u2192 ${broken.join(", ")}`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/schema-version.ts
+async function schemaVersionRule(ctx) {
+  const issues = [];
+  for (const mod of await collectModuleCards(ctx)) {
+    for (const [cardType, declaredSv] of Object.entries(mod.declared)) {
+      const serverSv = mod.serverSchemaVersions[cardType] ?? 1;
+      if (serverSv !== declaredSv) {
+        issues.push({
+          rule: "schema-version",
+          level: "error",
+          message: `${mod.id}: \u5361\u7247 ${cardType} contributes.schemaVersion=${declaredSv} \u4E0E meta schemaVersion=${serverSv} \u4E0D\u4E00\u81F4`
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/naked-write-route.ts
+import { existsSync as existsSync15 } from "fs";
+import path19 from "path";
+var ALLOWED_POST_PREFIXES = ["/webhook", "/upload", "/demo", "/run"];
+async function nakedWriteRouteRule(ctx) {
+  const issues = [];
+  for (const mod of await listLocalModules(ctx.appDir)) {
+    const serverDir = path19.join(mod.dir, "src/server");
+    if (!existsSync15(serverDir)) continue;
+    const files = [];
+    await walkFiles(serverDir, mod.dir, files);
+    for (const rel of files) {
+      const src = await readTextOrEmpty(path19.join(mod.dir, rel));
+      for (const m of src.matchAll(/\.(?:post|put|patch|delete)\(\s*['"]([^'"]+)['"]/g)) {
+        const route = m[1];
+        if (!route.startsWith("/")) continue;
+        const allowed = ALLOWED_POST_PREFIXES.some((p) => route.startsWith(p));
+        if (!allowed) {
+          issues.push({
+            rule: "naked-write-route",
+            level: "warning",
+            message: `${mod.id}/${rel}: \u88F8\u5199\u8DEF\u7531 ${m[0].replace("(", " (")} \u5EFA\u8BAE\u6539\u8D70 ctx.actions.registerAction\uFF08\u5168\u5C40\u52A8\u4F5C\u5206\u53D1\u5668\uFF09`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/descriptor-schema.ts
+import { existsSync as existsSync16 } from "fs";
+import { readdir as readdir9 } from "fs/promises";
+import path20 from "path";
+async function descriptorSchemaRule(ctx) {
+  const issues = [];
+  const packagesDir = path20.join(ctx.appDir, "packages");
+  if (!existsSync16(packagesDir)) return issues;
+  for (const entry of await readdir9(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const file = path20.join(packagesDir, entry.name, "tbox.component.json");
+    if (!existsSync16(file)) continue;
+    try {
+      const parsed = parseComponentDescriptor(JSON.parse(await readTextOrEmpty(file)));
+      if (!parsed.ok) {
+        issues.push({
+          rule: "descriptor-schema",
+          level: "error",
+          message: `${entry.name}/tbox.component.json: ${parsed.errors.join("; ")}`
+        });
+      }
+    } catch {
+      issues.push({
+        rule: "descriptor-schema",
+        level: "error",
+        message: `${entry.name}/tbox.component.json: JSON \u89E3\u6790\u5931\u8D25`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/workspace-ref-resolved.ts
+import { existsSync as existsSync17 } from "fs";
+import { readdir as readdir10 } from "fs/promises";
+import path21 from "path";
+async function workspaceRefResolvedRule(ctx) {
+  const issues = [];
+  if (existsSync17(path21.join(ctx.appDir, "pnpm-workspace.template.yaml"))) return issues;
+  const memberIndex = /* @__PURE__ */ new Map();
+  for (const root of ["apps", "packages"]) {
+    const rootDir = path21.join(ctx.appDir, root);
+    if (!existsSync17(rootDir)) continue;
+    for (const entry of await readdir10(rootDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const dir = path21.join(rootDir, entry.name);
+      const pkg = readPkgJson(dir);
+      if (pkg?.name) memberIndex.set(pkg.name, path21.join(root, entry.name));
+    }
+  }
+  if (memberIndex.size === 0) return issues;
+  for (const [name, rel] of memberIndex) {
+    const pkg = readPkgJson(path21.join(ctx.appDir, rel));
+    if (!pkg) continue;
+    for (const key of ["dependencies", "peerDependencies", "devDependencies"]) {
+      const deps = pkg[key];
+      if (!deps || typeof deps !== "object") continue;
+      for (const [depName, spec] of Object.entries(deps)) {
+        if (typeof spec !== "string" || !spec.startsWith("workspace:")) continue;
+        if (!memberIndex.has(depName)) {
+          issues.push({
+            rule: "workspace-ref-resolved",
+            level: "error",
+            message: `${rel}: workspace:* \u5F15\u7528 ${depName} \u672A\u547D\u4E2D\u4EFB\u4F55\u6210\u5458\uFF08packages/ \u6216 apps/\uFF09`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+// src/doctor/rules/legacy-platform-files.ts
+import { existsSync as existsSync18 } from "fs";
+import path22 from "path";
+var LEGACY_PATHS = [
+  "apps/server/src/auth",
+  "apps/server/src/agent",
+  "apps/server/src/gateway",
+  "apps/server/src/http",
+  "apps/server/src/plugins/integration.ts",
+  "apps/server/src/config/tts-config.ts",
+  "apps/server/src/config/model-providers.ts",
+  "apps/client/src/env",
+  "apps/client/src/bridge",
+  "apps/client/src/adapters",
+  "apps/client/src/services/http.ts",
+  "apps/client/src/services/auth-client.ts",
+  "apps/client/src/services/user-id.ts",
+  "apps/client/src/services/tbox-session.ts"
+];
+function legacyPlatformFilesRule(ctx) {
+  const issues = [];
+  for (const rel of LEGACY_PATHS) {
+    if (existsSync18(path22.join(ctx.appDir, rel))) {
+      issues.push({
+        rule: "legacy-platform-files",
+        level: "error",
+        message: `${rel} \u4E3A\u65E7\u5F62\u6001\u5E73\u53F0\u6587\u4EF6\uFF08007\uFF1A\u5E73\u53F0\u80FD\u529B\u5DF2\u4E0B\u6C89 @tbox.cn/app-sdk\uFF09\u3002\u8BF7\u5220\u9664\u5E76\u6539\u7528 SDK API\uFF08server: createAuthRuntime/createPlatformApiRouter/createTtsProxy/createModelProvider/createPluginIntegration\uFF1Bclient: createAuthClient/createPlatformAdapters/createPlatformApi/configureRuntime\uFF09\uFF0C\u8BE6\u89C1 docs/proposals/007\u3002`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/doctor/index.ts
+var DOCTOR_RULES = [
+  { name: "workspace-dag", run: workspaceDagRule },
+  { name: "register-pure", run: registerPureRule },
+  { name: "card-type-consistent", run: cardTypeConsistentRule },
+  { name: "client-card-cover", run: clientCardCoverRule },
+  { name: "contract-version", run: contractVersionRule },
+  { name: "module-deps-assembled", run: moduleDepsAssembledRule },
+  { name: "singleton", run: singletonRule },
+  { name: "sdk-internal-import", run: sdkInternalImportRule },
+  { name: "assembly-drift", run: assemblyDriftRule },
+  { name: "schema-version", run: schemaVersionRule },
+  { name: "naked-write-route", run: nakedWriteRouteRule },
+  { name: "descriptor-schema", run: descriptorSchemaRule },
+  { name: "workspace-ref-resolved", run: workspaceRefResolvedRule },
+  { name: "legacy-platform-files", run: legacyPlatformFilesRule }
+];
+async function runDoctor(ctx, opts) {
+  const issues = [];
+  const only = opts?.only?.length ? new Set(opts.only) : null;
+  const skip = new Set(opts?.skip ?? []);
+  for (const rule of DOCTOR_RULES) {
+    if (only && !only.has(rule.name)) continue;
+    if (skip.has(rule.name)) continue;
+    try {
+      issues.push(...await rule.run(ctx));
+    } catch (err) {
+      issues.push({
+        rule: rule.name,
+        level: "error",
+        message: `\u89C4\u5219\u6267\u884C\u5F02\u5E38: ${err?.message ?? String(err)}`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/deps-resolve.ts
+function isContractId(id, localIds) {
+  return !localIds.has(id) || id.startsWith("contracts-");
+}
+async function resolveDependencies(appDir, rootIds, declared, extraRoots = []) {
+  const mods = await listLocalModules(appDir);
+  const localIds = new Set(mods.map((m) => m.id));
+  const installedIds = new Set(declared?.map((m) => m.id) ?? []);
+  const pkgVersion = /* @__PURE__ */ new Map();
+  for (const mod of mods) {
+    pkgVersion.set(mod.id, mod.descriptor.version ?? "0.0.0");
+  }
+  const extraDeps = new Map(extraRoots.map((r) => [r.id, r.deps]));
+  const visited = /* @__PURE__ */ new Set();
+  const edges = [];
+  const queue = [...rootIds, ...extraRoots.map((r) => r.id)];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (visited.has(id)) continue;
+    visited.add(id);
+    const mod = mods.find((m) => m.id === id);
+    const deps = extraDeps.get(id) ?? mod?.descriptor.dependencies?.modules ?? [];
+    for (const dep of deps) {
+      edges.push(dep);
+      if (!visited.has(dep.id) && (localIds.has(dep.id) || extraDeps.has(dep.id))) queue.push(dep.id);
+    }
+  }
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  const cycles = [];
+  function dfs(id, stack) {
+    color.set(id, GRAY);
+    stack.push(id);
+    for (const dep of adjacency.get(id) ?? []) {
+      const c = color.get(dep) ?? WHITE;
+      if (c === GRAY) {
+        const idx = stack.indexOf(dep);
+        if (idx >= 0) cycles.push([...stack.slice(idx), dep]);
+      } else if (c === WHITE) {
+        dfs(dep, stack);
+      }
+    }
+    stack.pop();
+    color.set(id, BLACK);
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  const modById = new Map(mods.map((m) => [m.id, m]));
+  for (const id of visited) {
+    const mod = modById.get(id);
+    const deps = extraDeps.get(id) ?? mod?.descriptor.dependencies?.modules ?? [];
+    adjacency.set(id, deps.filter((d) => visited.has(d.id)).map((d) => d.id));
+  }
+  for (const id of visited) {
+    if ((color.get(id) ?? WHITE) === WHITE) dfs(id, []);
+  }
+  const toInstall = [...visited].filter((id) => !installedIds.has(id));
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const id of toInstall) inDegree.set(id, 0);
+  const dependents = /* @__PURE__ */ new Map();
+  for (const id of toInstall) {
+    for (const dep of adjacency.get(id) ?? []) {
+      if (inDegree.has(dep)) {
+        inDegree.set(id, (inDegree.get(id) ?? 0) + 1);
+        const list = dependents.get(dep);
+        if (list) list.push(id);
+        else dependents.set(dep, [id]);
+      }
+    }
+  }
+  const ready = toInstall.filter((id) => (inDegree.get(id) ?? 0) === 0);
+  const order = [];
+  while (ready.length > 0) {
+    const id = ready.shift();
+    order.push(id);
+    for (const dependent of dependents.get(id) ?? []) {
+      const nd = (inDegree.get(dependent) ?? 0) - 1;
+      inDegree.set(dependent, nd);
+      if (nd === 0) ready.push(dependent);
+    }
+  }
+  if (order.length !== toInstall.length) {
+  }
+  const contracts = /* @__PURE__ */ new Set();
+  const business = /* @__PURE__ */ new Set();
+  const conflicts = [];
+  for (const edge of edges) {
+    const id = edge.id;
+    if (!installedIds.has(id) || !pkgVersion.has(id)) {
+      if (isContractId(id, localIds)) contracts.add(id);
+      else if (!isContractId(id, localIds)) business.add(id);
+    }
+    if (edge.range && pkgVersion.has(id)) {
+      const targetVersion = pkgVersion.get(id);
+      if (edge.range !== "*" && !edge.range.startsWith("workspace:")) {
+        const inter = intersectRanges2(edge.range, targetVersion);
+        if (!inter) {
+          conflicts.push(`${id}: \u4F9D\u8D56\u8303\u56F4 ${edge.range} \u4E0E\u76EE\u6807\u7248\u672C ${targetVersion} \u65E0\u4EA4\u96C6`);
+        }
+      }
+    }
+  }
+  return {
+    order,
+    contracts: [...contracts],
+    business: [...business],
+    cycles,
+    conflicts
+  };
+}
+
+// src/commands/add.ts
+function readSourceDescriptor(sourceDir) {
+  const file = path23.join(sourceDir, "tbox.component.json");
+  if (!existsSync19(file)) return null;
+  try {
+    const parsed = parseComponentDescriptor(JSON.parse(readFileSync8(file, "utf8")));
+    return parsed.ok ? parsed.value : null;
+  } catch {
+    return null;
+  }
+}
+function resolveDepSource(sourcePath, depId) {
+  if (!sourcePath) return null;
+  const dir = path23.dirname(sourcePath);
+  const siblingDir = path23.join(dir, depId);
+  if (existsSync19(path23.join(siblingDir, "package.json"))) return siblingDir;
+  try {
+    const tgz = readdirSync2(dir).find(
+      (f) => f.endsWith(".tgz") && f.includes(`-${depId}-`)
+    );
+    if (tgz) return path23.join(dir, tgz);
+  } catch {
+  }
+  return null;
+}
+function isInstalled(appDir, id) {
+  if (existsSync19(path23.join(appDir, "packages", id))) return true;
+  const manifest = readAppManifest(appDir);
+  return manifest?.npmModules.some((m) => m.id === id && m.mode === "sdk") ?? false;
+}
+async function addModule(opts) {
+  await addModuleWithDeps(opts, /* @__PURE__ */ new Set(), false);
+}
+async function addModuleWithDeps(opts, visited, asDependency) {
+  const tarballs = [];
+  try {
+    await addModuleWithDepsCore(opts, visited, asDependency, tarballs);
+  } finally {
+    for (const t of tarballs) t.dispose();
+  }
+}
+async function addModuleWithDepsCore(opts, visited, asDependency, tarballs) {
+  const appDir = process.cwd();
+  if (!readAppManifest(appDir)) throw new Error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F tbox-app \u5E94\u7528\uFF08\u7F3A .tbox/app.json\uFF09");
+  let id;
+  let sourceDescriptor = null;
+  let opened = null;
+  const isReg = !!opts.source && isRegistrySpec(opts.source);
+  if (opts.mode === "local") {
+    const short = opts.pkg;
+    id = short.startsWith("module-") ? short : `module-${short}`;
+    assertValidModuleId(id, `--mode local ${opts.pkg}`);
+  } else {
+    if (!opts.source) throw new Error(`--mode ${opts.mode} \u9700\u8981 --source <\u76EE\u5F55\u6216 tgz \u6216 registry \u5305>`);
+    const isRegSource = isReg && !existsSync19(path23.resolve(opts.source));
+    if (!isRegSource && !opts.source.endsWith(".tgz") && !LocalDirSource.isUsable(opts.source)) {
+      throw new Error(`\u6A21\u5757\u6E90\u65E0\u6548\uFF08\u7F3A package.json\uFF09: ${opts.source}`);
+    }
+    opened = openSource(opts.source, opts.registry);
+    if (opened.source instanceof TarballSource || opened.source instanceof RegistrySource) {
+      tarballs.push(opened.source);
+    }
+    const pkgOnly = opts.pkg.replace(/@[^/]+$/, "");
+    id = pkgOnly.replace(/^@tbox\.cn\/app-/, "").replace(/^@[^/]+\//, "");
+    assertValidModuleId(id, `--mode ${opts.mode} ${opts.pkg}`);
+    sourceDescriptor = readSourceDescriptor(opened.sourceDir);
+  }
+  if (asDependency && isInstalled(appDir, id)) {
+    console.log(`   \u26A0\uFE0F \u4F9D\u8D56 ${id} \u5DF2\u5B89\u88C5\uFF0C\u8DF3\u8FC7`);
+    return;
+  }
+  if (!asDependency && isInstalled(appDir, id)) {
+    const where = existsSync19(path23.join(appDir, "packages", id)) ? `packages/${id}` : "manifest \u5DF2\u767B\u8BB0\uFF08sdk \u5305\uFF0C\u65E0\u672C\u5730\u76EE\u5F55\uFF09";
+    throw new Error(`\u6A21\u5757 ${id} \u5DF2\u5B58\u5728\uFF08${where}\uFF09\u3002\u82E5\u8981\u91CD\u65B0\u5C55\u5F00\u8BF7\u5148 remove \u6216\u624B\u52A8\u5904\u7406\uFF1B\u88C5\u914D\u552F\u4E00\u8986\u76D6\u5165\u53E3\u4E3A sync --force`);
+  }
+  if (visited.has(id)) return;
+  visited.add(id);
+  if (!opts.noDeps) {
+    const ownDeps = sourceDescriptor?.dependencies?.modules ?? [];
+    const resolution = await resolveDependencies(appDir, [], void 0, [
+      { id, deps: ownDeps }
+    ]);
+    if (resolution.cycles.length > 0) {
+      throw new Error(
+        `\u4F9D\u8D56\u73AF\uFF1A${resolution.cycles.map((c) => c.join(" \u2192 ")).join("\uFF1B")}`
+      );
+    }
+    for (const c of resolution.conflicts) console.warn(`   \u26A0\uFE0F \u4F9D\u8D56\u7248\u672C\u51B2\u7A81: ${c}`);
+    const installSeq = [
+      ...resolution.contracts,
+      ...resolution.order
+    ].filter((depId) => depId !== id && !isInstalled(appDir, depId));
+    for (const depId of [...new Set(installSeq)]) {
+      const depPkg = /^(module|scenario|contracts)-/.test(depId) ? `@tbox.cn/app-${depId}` : `@tbox.cn/${depId}`;
+      const depSource = isReg ? depPkg : resolveDepSource(opts.source, depId);
+      if (!depSource) {
+        console.warn(`   \u26A0\uFE0F \u4F9D\u8D56 ${depId} \u672A\u5B89\u88C5\u4E14\u672A\u627E\u5230\u6E90\uFF08--source \u5144\u5F1F\u76EE\u5F55/tgz\uFF09\uFF0C\u53EF --no-deps \u8DF3\u8FC7`);
+        continue;
+      }
+      const depOpened = openSource(depSource, opts.registry);
+      if (depOpened.source instanceof TarballSource || depOpened.source instanceof RegistrySource) {
+        tarballs.push(depOpened.source);
+      }
+      const depIsBusiness = existsSync19(path23.join(depOpened.sourceDir, "tbox.component.json"));
+      await addModuleWithDeps(
+        { pkg: depPkg, mode: depIsBusiness ? "codegen" : "sdk", source: depSource, registry: opts.registry },
+        visited,
+        true
+      );
+    }
+  }
+  let entry;
+  if (opts.mode === "local") {
+    const short = opts.pkg;
+    const localId = short.startsWith("module-") ? short : `module-${short}`;
+    await createLocalSkeleton(appDir, short);
+    entry = { id: localId, package: `@app/${localId}`, version: "0.1.0", mode: "local" };
+    await updateAppsDependency(appDir, `@app/${localId}`, "add");
+  } else {
+    const sourceDir = opened.sourceDir;
+    const version = opened.source.resolveVersion();
+    if (opts.mode === "codegen") {
+      await expandCodegen(appDir, sourceDir, { id, package: `@app/${id}`, version, mode: "codegen", baseVersion: version });
+      await updateAppsDependency(appDir, `@app/${id}`, "add");
+    }
+    entry = {
+      id,
+      package: opts.pkg.replace(/@[^/]+$/, ""),
+      version,
+      mode: opts.mode,
+      ...opts.mode === "codegen" ? { baseVersion: version } : {}
+    };
+  }
+  const manifest = readAppManifest(appDir);
+  await writeAppManifest(appDir, upsertNpmModule(manifest, entry));
+  const sync = await syncAll(appDir);
+  if (sync.changedFiles.length > 0) {
+    console.log(`   \u88C5\u914D\u66F4\u65B0: ${sync.changedFiles.join(", ")}`);
+  }
+  for (const w of sync.warnings) console.warn(`   \u26A0\uFE0F ${w}`);
+  for (const c of sync.depConflicts) console.warn(`   \u26A0\uFE0F \u4F9D\u8D56\u51B2\u7A81: ${c}`);
+  const actual = await collectActual(appDir);
+  const issues = await runDoctor({ appDir, declared: sync.declared, actual });
+  const errors = issues.filter((i) => i.level === "error");
+  if (errors.length > 0) {
+    console.error("\u274C doctor \u9519\u8BEF\uFF1A");
+    for (const e of errors) console.error(`   - [${e.rule}] ${e.message}`);
+    process.exitCode = 1;
+  }
+  console.log(`\u2705 \u5DF2\u5B89\u88C5 ${entry.package}\uFF08mode=${opts.mode}${asDependency ? ", \u4F9D\u8D56" : ""}\uFF09`);
+  if (opts.mode !== "local") {
+    console.log(`   \u4E0B\u4E00\u6B65: pnpm install && tbox-app module doctor`);
+  }
+}
+
+// src/commands/remove.ts
+async function removeModule(id, opts = {}) {
+  const appDir = process.cwd();
+  assertValidModuleId(id, "remove \u53C2\u6570");
+  const manifest = readAppManifest(appDir);
+  if (!manifest) throw new Error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F tbox-app \u5E94\u7528\uFF08\u7F3A .tbox/app.json\uFF09");
+  if (!opts.force) {
+    const blockers = [];
+    for (const mod of await listLocalModules(appDir)) {
+      if (mod.id === id) continue;
+      const dep = (mod.descriptor.dependencies?.modules ?? []).find((d) => d.id === id);
+      if (dep && dep.required) blockers.push(mod.id);
+    }
+    if (blockers.length > 0) {
+      throw new Error(`\u6A21\u5757 ${id} \u88AB\u4F9D\u8D56\uFF0C\u65E0\u6CD5\u79FB\u9664\uFF1A${blockers.join(", ")}\uFF08--force \u5FFD\u7565\uFF09`);
+    }
+  }
+  const entry = manifest.npmModules.find((m) => m.id === id);
+  const isNpmModule = Boolean(entry);
+  if (isNpmModule) {
+    await writeAppManifest(appDir, removeNpmModule(manifest, id));
+  }
+  const removedDir = await removePackageDir(appDir, id);
+  if (removedDir) console.log(`   \u5DF2\u5220\u9664 packages/${id}`);
+  else if (entry?.mode === "sdk") console.log(`   \u5DF2\u79FB\u9664 manifest \u767B\u8BB0\uFF08sdk \u5305\uFF0C\u65E0\u672C\u5730\u76EE\u5F55\uFF09`);
+  if (entry?.mode === "codegen" || entry?.mode === "local" || !isNpmModule) {
+    await updateAppsDependency(appDir, `@app/${id}`, "remove");
+  }
+  const sync = await syncAll(appDir);
+  if (sync.changedFiles.length > 0) {
+    console.log(`   \u88C5\u914D\u66F4\u65B0: ${sync.changedFiles.join(", ")}`);
+  }
+  for (const w of sync.warnings) console.warn(`   \u26A0\uFE0F ${w}`);
+  for (const c of sync.depConflicts) console.warn(`   \u26A0\uFE0F \u4F9D\u8D56\u51B2\u7A81: ${c}`);
+  const actual = await collectActual(appDir);
+  const issues = await runDoctor({ appDir, declared: sync.declared, actual });
+  const errors = issues.filter((i) => i.level === "error");
+  if (errors.length > 0) {
+    console.error("\u274C doctor \u9519\u8BEF\uFF1A");
+    for (const e of errors) console.error(`   - [${e.rule}] ${e.message}`);
+    process.exitCode = 1;
+  }
+  console.log(`\u2705 \u5DF2\u79FB\u9664 ${id}`);
+}
+
+// src/commands/sync.ts
+async function syncCommand(opts = {}) {
+  const appDir = process.cwd();
+  const sync = await syncAll(appDir, { force: opts.force ?? false });
+  if (sync.changedFiles.length === 0) {
+    console.log("\u88C5\u914D\u5DF2\u540C\u6B65\uFF0C\u65E0\u53D8\u66F4");
+  } else {
+    console.log(`\u5DF2\u66F4\u65B0\u88C5\u914D\u6587\u4EF6: ${sync.changedFiles.join(", ")}`);
+  }
+  for (const w of sync.warnings) console.warn(`   \u26A0\uFE0F ${w}`);
+  for (const c of sync.depConflicts) console.warn(`   \u26A0\uFE0F \u4F9D\u8D56\u51B2\u7A81: ${c}`);
+  const actual = await collectActual(appDir);
+  const issues = await runDoctor({ appDir, declared: sync.declared, actual });
+  const errors = issues.filter((i) => i.level === "error");
+  if (errors.length > 0) {
+    console.error("\u274C doctor \u9519\u8BEF\uFF1A");
+    for (const e of errors) console.error(`   - [${e.rule}] ${e.message}`);
+    process.exitCode = 1;
+  } else {
+    console.log("\u2705 doctor \u65E0\u9519\u8BEF");
+  }
+  for (const w of issues.filter((i) => i.level === "warning")) {
+    console.warn(`   \u26A0\uFE0F [${w.rule}] ${w.message}`);
+  }
+}
+
+// src/commands/list.ts
+async function listCommand() {
+  const appDir = process.cwd();
+  const manifest = readAppManifest(appDir);
+  const declared = await collectDeclared(appDir);
+  console.log(`\u6A21\u677F\u7248\u672C: ${manifest?.templateVersion ?? "\u672A\u77E5"}`);
+  if (declared.length === 0) {
+    console.log("\uFF08\u65E0\u5DF2\u88C5\u6A21\u5757\uFF09");
+    return;
+  }
+  for (const m of declared) {
+    console.log(`  ${m.id.padEnd(28)} ${m.pkg}  [${m.mode}]`);
+  }
+  const npmIds = new Set((manifest?.npmModules ?? []).map((m) => m.id));
+  const localOnly = (await listLocalModules(appDir)).filter((m) => !npmIds.has(m.id));
+  if (localOnly.length > 0) {
+    console.log("  \u672C\u5730\u6A21\u5757\uFF08\u672A\u5728 app.json \u767B\u8BB0\uFF09:");
+    for (const m of localOnly) console.log(`    ${m.id}`);
+  }
+}
+
+// src/commands/diff.ts
+async function diffCommand(module) {
+  const appDir = process.cwd();
+  const declared = await collectDeclared(appDir);
+  const actual = await collectActual(appDir);
+  let dirty = false;
+  for (const file of ASSEMBLY_FILES) {
+    const kind = file.kind;
+    const declaredIds = declared.filter((m) => contributesTo(kind, m)).map((m) => m.id);
+    const actualIds = actual[kind]?.moduleIds ?? [];
+    let missing = declaredIds.filter((id) => !actualIds.includes(id));
+    let extra = actualIds.filter((id) => !declaredIds.includes(id));
+    if (module) {
+      missing = missing.filter((id) => id === module);
+      extra = extra.filter((id) => id === module);
+    }
+    const broken = actual[kind]?.broken ?? [];
+    const nonStandard = actual[kind]?.nonStandardLines ?? [];
+    const lines = [];
+    if (broken.length > 0) lines.push(`\u26A0\uFE0F \u951A\u533A\u7834\u574F: ${broken.join(", ")}`);
+    if (missing.length > 0) lines.push(`  - \u5DF2\u58F0\u660E\u672A\u88C5\u914D: ${missing.join(", ")}`);
+    if (extra.length > 0) lines.push(`  + \u5DF2\u88C5\u914D\u672A\u58F0\u660E: ${extra.join(", ")}`);
+    for (const ns of nonStandard) lines.push(`  ? \u975E\u6807\u884C: ${ns}`);
+    if (lines.length > 0) {
+      dirty = true;
+      console.log(`${file.path}`);
+      for (const l of lines) console.log(`  ${l}`);
+    }
+  }
+  if (!dirty) {
+    console.log("\u65E0\u6F02\u79FB\uFF1A\u58F0\u660E\u96C6\u5408\u4E0E\u5B9E\u9645\u88C5\u914D\u96C6\u5408\u4E00\u81F4");
+  }
+}
+
+// src/commands/doctor.ts
+async function doctorCommand(opts = {}) {
+  const appDir = process.cwd();
+  const declared = await collectDeclared(appDir);
+  const actual = await collectActual(appDir);
+  const issues = await runDoctor(
+    { appDir, declared, actual },
+    {
+      only: opts.only ? opts.only.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+      skip: opts.skip ? opts.skip.split(",").map((s) => s.trim()).filter(Boolean) : void 0
+    }
+  );
+  const errors = issues.filter((i) => i.level === "error");
+  const warnings = issues.filter((i) => i.level === "warning");
+  if (opts.json) {
+    console.log(JSON.stringify({ errors, warnings, rules: issues }, null, 2));
+    if (errors.length > 0) process.exitCode = 1;
+    return { issues };
+  }
+  if (issues.length === 0) {
+    console.log("\u2705 doctor \u5168\u7EFF\uFF08\u7ED3\u6784\u6821\u9A8C\u901A\u8FC7\uFF09");
+  } else {
+    for (const e of errors) console.error(`\u274C [${e.rule}] ${e.message}`);
+    for (const w of warnings) console.warn(`\u26A0\uFE0F [${w.rule}] ${w.message}`);
+    if (errors.length > 0) {
+      console.error(`doctor \u5931\u8D25: ${errors.length} \u4E2A\u9519\u8BEF`);
+      process.exitCode = 1;
+    } else {
+      console.log(`doctor \u901A\u8FC7\uFF08${warnings.length} \u4E2A\u544A\u8B66\uFF09`);
+    }
+  }
+  return { issues };
+}
+
+// src/commands/update.ts
+import { existsSync as existsSync20 } from "fs";
+import { readdir as readdir11, readFile as readFile6, unlink, writeFile as writeFile7 } from "fs/promises";
+import path24 from "path";
+
+// src/merge3.ts
+import { diffArrays } from "diff";
+function computeHunks(base, target) {
+  const changes = diffArrays(base, target);
+  const hunks = [];
+  let baseIdx = 0;
+  let pending = null;
+  for (const c of changes) {
+    if (c.removed) {
+      if (!pending) pending = { start: baseIdx, oldLines: [...c.value], newLines: [] };
+      else pending.oldLines.push(...c.value);
+      baseIdx += c.value.length;
+    } else if (c.added) {
+      if (!pending) pending = { start: baseIdx, oldLines: [], newLines: [...c.value] };
+      else pending.newLines.push(...c.value);
+    } else {
+      if (pending) {
+        hunks.push(pending);
+        pending = null;
+      }
+      baseIdx += c.value.length;
+    }
+  }
+  if (pending) hunks.push(pending);
+  return hunks;
+}
+function merge3(base, ours, theirs) {
+  const baseLines = base === "" ? [] : base.split("\n");
+  const oursLines = ours === "" ? [] : ours.split("\n");
+  const theirsLines = theirs === "" ? [] : theirs.split("\n");
+  const oursHunks = computeHunks(baseLines, oursLines);
+  const theirsHunks = computeHunks(baseLines, theirsLines);
+  const byStart = /* @__PURE__ */ new Map();
+  for (const h of oursHunks) byStart.set(h.start, { ours: h });
+  for (const h of theirsHunks) {
+    const existing = byStart.get(h.start);
+    if (existing) existing.theirs = h;
+    else byStart.set(h.start, { theirs: h });
+  }
+  const out = [];
+  const conflicts = [];
+  const consumed = /* @__PURE__ */ new Set();
+  const applyHunk = (o, t) => {
+    const oldLen = Math.max(o?.oldLines.length ?? 0, t?.oldLines.length ?? 0);
+    if (o && t) {
+      const same = JSON.stringify(o.oldLines) === JSON.stringify(t.oldLines) && JSON.stringify(o.newLines) === JSON.stringify(t.newLines);
+      if (same) {
+        out.push(...o.newLines);
+      } else {
+        conflicts.push([...o.newLines, "--", ...t.newLines].join("\n"));
+        out.push("<<<<<<< ours", ...o.newLines, "=======", ...t.newLines, ">>>>>>> theirs");
+      }
+    } else if (o) {
+      out.push(...o.newLines);
+    } else {
+      out.push(...t.newLines);
+    }
+    return oldLen;
+  };
+  let i = 0;
+  while (i < baseLines.length) {
+    const entry = byStart.get(i);
+    if (!entry || consumed.has(i)) {
+      out.push(baseLines[i]);
+      i++;
+      continue;
+    }
+    consumed.add(i);
+    const oldLen = applyHunk(entry.ours, entry.theirs);
+    if (oldLen > 0) i += oldLen;
+  }
+  const tail = byStart.get(baseLines.length);
+  if (tail && !consumed.has(baseLines.length)) {
+    applyHunk(tail.ours, tail.theirs);
+  }
+  return { merged: out.join("\n"), conflicts };
+}
+
+// src/commands/update.ts
+var EXCLUDED = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".tbox"]);
+function openSourceDir(source) {
+  if (source.endsWith(".tgz") && existsSync20(source)) {
+    const tarball = new TarballSource(source);
+    return { dir: tarball.getDir(), tarball };
+  }
+  return { dir: path24.resolve(source), tarball: null };
+}
+async function readPackageFiles(dir) {
+  const map = /* @__PURE__ */ new Map();
+  async function walk(rel) {
+    const full = path24.join(dir, rel);
+    const entries = await readdir11(full, { withFileTypes: true });
+    for (const entry of entries) {
+      if (EXCLUDED.has(entry.name)) continue;
+      const child = rel ? `${rel}/${entry.name}` : entry.name;
+      const childFull = path24.join(full, entry.name);
+      if (entry.isDirectory()) {
+        await walk(child);
+      } else {
+        try {
+          map.set(child, await readFile6(childFull, "utf8"));
+        } catch {
+        }
+      }
+    }
+  }
+  await walk("");
+  return map;
+}
+async function updateModule(opts) {
+  const appDir = process.cwd();
+  const manifest = readAppManifest(appDir);
+  if (!manifest) throw new Error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F tbox-app \u5E94\u7528\uFF08\u7F3A .tbox/app.json\uFF09");
+  const entry = manifest.npmModules.find((m) => m.id === opts.module);
+  if (!entry) throw new Error(`\u6A21\u5757 ${opts.module} \u672A\u5728 .tbox/app.json \u767B\u8BB0`);
+  if (entry.mode === "sdk") {
+    if (opts.dryRun) {
+      console.log(`[dry-run] pnpm update ${entry.package}`);
+      return;
+    }
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    execFileSync4("pnpm", ["update", entry.package], { stdio: "inherit", cwd: appDir });
+    console.log(`\u2705 \u5DF2\u5347\u7EA7 ${entry.package}\uFF08sdk \u6A21\u5F0F\uFF09`);
+    return;
+  }
+  const pkgDir = path24.join(appDir, "packages", opts.module);
+  if (!existsSync20(pkgDir)) throw new Error(`\u7F3A\u5C11 packages/${opts.module}`);
+  const ours = await readPackageFiles(pkgDir);
+  const tarballs = [];
+  try {
+    let theirs;
+    let theirsVersion;
+    if (opts.source) {
+      const src = openSourceDir(opts.source);
+      if (src.tarball) tarballs.push(src.tarball);
+      theirs = await readPackageFiles(src.dir);
+      theirsVersion = src.tarball ? src.tarball.resolveVersion() : readPkgJson(src.dir)?.version ?? entry.version;
+    } else {
+      throw new Error("codegen \u5347\u7EA7\u9700\u8981 --source <\u65B0\u7248\u672C\u5730\u76EE\u5F55\u6216 tgz>\uFF08npm \u62C9\u53D6\u4E3A manual\uFF0C\u771F\u5B9E\u53D1\u5E03\u540E\u56DE\u843D\uFF09");
+    }
+    let base = /* @__PURE__ */ new Map();
+    if (opts.baseSource) {
+      const bsrc = openSourceDir(opts.baseSource);
+      if (bsrc.tarball) tarballs.push(bsrc.tarball);
+      base = await readPackageFiles(bsrc.dir);
+    }
+    const allKeys = /* @__PURE__ */ new Set([...base.keys(), ...ours.keys(), ...theirs.keys()]);
+    let mergedFiles = /* @__PURE__ */ new Map();
+    const conflictList = [];
+    for (const key of allKeys) {
+      const b = base.get(key) ?? "";
+      const o = ours.get(key) ?? "";
+      const t = theirs.get(key) ?? "";
+      if (opts.ours) {
+        if (o) mergedFiles.set(key, o);
+        continue;
+      }
+      if (opts.theirs) {
+        if (t) mergedFiles.set(key, t);
+        continue;
+      }
+      const result = merge3(b, o, t);
+      mergedFiles.set(key, result.merged);
+      if (result.conflicts.length > 0) {
+        conflictList.push(`${key}: ${result.conflicts.length} \u5904\u51B2\u7A81`);
+      }
+    }
+    if (opts.dryRun) {
+      console.log(`[dry-run] ${opts.module}: ${allKeys.size} \u6587\u4EF6\u5408\u5E76\uFF0C\u51B2\u7A81 ${conflictList.length} \u5904`);
+      for (const c of conflictList) console.log(`  \u26A0\uFE0F ${c}`);
+      return;
+    }
+    for (const [key, content] of mergedFiles) {
+      const out = path24.join(pkgDir, key);
+      if (content === "" && existsSync20(out)) {
+        await unlink(out);
+        console.log(`   \u{1F5D1} \u5DF2\u5220\u9664 ${key}\uFF08\u5347\u7EA7\u6E90\u5220\u9664\u8BE5\u6587\u4EF6\uFF09`);
+        continue;
+      }
+      await writeFile7(out, content, "utf8");
+    }
+    await writeAppManifest(appDir, updateNpmModule(manifest, opts.module, { baseVersion: theirsVersion, version: theirsVersion }));
+    const sync = await syncAll(appDir);
+    const actual = await collectActual(appDir);
+    const issues = await runDoctor({ appDir, declared: sync.declared, actual });
+    const errors = issues.filter((i) => i.level === "error");
+    if (errors.length > 0) {
+      console.error("\u274C doctor \u9519\u8BEF\uFF1A");
+      for (const e of errors) console.error(`   - [${e.rule}] ${e.message}`);
+      process.exitCode = 1;
+    }
+    if (conflictList.length > 0) {
+      console.warn("\u26A0\uFE0F \u5347\u7EA7\u5B8C\u6210\uFF0C\u5B58\u5728\u51B2\u7A81\u6807\u8BB0\uFF08<<<<<<< ours / >>>>>>> theirs\uFF09\uFF0C\u8BF7\u4EBA\u5DE5/Agent \u89E3\u51B3\u540E\u8FD0\u884C doctor:");
+      for (const c of conflictList) console.warn(`   - ${c}`);
+    } else {
+      console.log(`\u2705 \u5DF2\u5347\u7EA7 ${opts.module} \u2192 ${theirsVersion}`);
+    }
+  } finally {
+    for (const t of tarballs) t.dispose();
+  }
+}
+
+// src/commands/publish.ts
+import { existsSync as existsSync22, readFileSync as readFileSync10, mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import path26 from "path";
+
+// src/commands/pack.ts
+import { existsSync as existsSync21, readFileSync as readFileSync9, readdirSync as readdirSync3 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import path25 from "path";
+function tarballFileName(name, version) {
+  const plain = name.replace(/^@/, "").replace("/", "-");
+  return `${plain}-${version}.tgz`;
+}
+function validatePublishableModule(moduleDir) {
+  if (!existsSync21(moduleDir) || !existsSync21(path25.join(moduleDir, "package.json"))) {
+    throw new Error(`\u6A21\u5757\u76EE\u5F55\u65E0\u6548\uFF08\u7F3A package.json\uFF09: ${moduleDir}`);
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync9(path25.join(moduleDir, "package.json"), "utf8"));
+  } catch {
+    throw new Error(`package.json \u89E3\u6790\u5931\u8D25: ${path25.join(moduleDir, "package.json")}`);
+  }
+  const name = typeof pkg.name === "string" ? pkg.name : "";
+  if (!/^@tbox\.cn\//.test(name)) {
+    throw new Error(`\u53D1\u5E03\u5305\u540D\u5FC5\u987B\u4E3A @tbox.cn/* scope: ${name || "(\u7F3A\u5931)"}`);
+  }
+  const version = typeof pkg.version === "string" ? pkg.version : "";
+  if (!/^\d+\.\d+\.\d+/.test(version)) {
+    throw new Error(`\u7248\u672C\u53F7\u65E0\u6548\uFF08\u9700 semver x.y.z\uFF09: ${version || "(\u7F3A\u5931)"}`);
+  }
+  return { name, version };
+}
+function packModule(moduleDir, outDir) {
+  const { name, version } = validatePublishableModule(moduleDir);
+  const absOut = path25.resolve(outDir);
+  execFileSync3("pnpm", ["pack", "--pack-destination", absOut], { stdio: "inherit", cwd: moduleDir });
+  return path25.join(absOut, tarballFileName(name, version));
+}
+function detectKind(pkgDir, name) {
+  if (existsSync21(path25.join(pkgDir, "pnpm-workspace.template.yaml"))) return "template";
+  if (existsSync21(path25.join(pkgDir, "tbox.component.json"))) return "module";
+  if (/^@[^/]+\/app-contracts/.test(name)) return "contract";
+  return "generic";
+}
+function listAllFiles(dir) {
+  const out = [];
+  function walk(rel) {
+    const full = path25.join(dir, rel);
+    for (const entry of readdirSync3(full, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const child = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) walk(child);
+      else out.push(child);
+    }
+  }
+  walk("");
+  return out;
+}
+function collectExportTargets(exports) {
+  const targets = [];
+  const push = (v) => {
+    if (typeof v === "string") targets.push(v);
+  };
+  if (typeof exports === "string") push(exports);
+  else if (exports && typeof exports === "object") {
+    for (const v of Object.values(exports)) {
+      if (typeof v === "string") push(v);
+      else if (v && typeof v === "object") {
+        for (const t of Object.values(v)) push(t);
+      }
+    }
+  }
+  return targets;
+}
+function verifyPkgDir(pkgDir, kind) {
+  const issues = [];
+  const pkgFile = path25.join(pkgDir, "package.json");
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync9(pkgFile, "utf8"));
+  } catch {
+    issues.push({ rule: "pack-manifest", level: "error", message: "\u4EA7\u7269\u7F3A\u5C11\u53EF\u89E3\u6790\u7684 package.json" });
+    return issues;
+  }
+  const kindOf = kind ?? detectKind(pkgDir, pkg.name ?? "");
+  const files = listAllFiles(pkgDir);
+  for (const key of ["dependencies", "peerDependencies", "devDependencies"]) {
+    const deps = pkg[key];
+    if (!deps || typeof deps !== "object") continue;
+    for (const [n, spec] of Object.entries(deps)) {
+      if (typeof spec === "string" && /^(workspace:|catalog:)/.test(spec)) {
+        issues.push({
+          rule: "pack-protocol-residue",
+          level: "error",
+          message: `${n}: \u53D1\u5E03\u6001\u6B8B\u7559 pnpm \u79C1\u6709\u534F\u8BAE "${spec}"\uFF08\u5E94\u5DF2\u5F52\u4E00\u5316\u4E3A\u5B9E\u88C5\u7248\u672C\uFF09`
+        });
+      }
+    }
+  }
+  if (pkg.exports !== void 0) {
+    for (const t of collectExportTargets(pkg.exports)) {
+      if (t.includes("/src/") || t === "src") {
+        issues.push({
+          rule: "pack-exports",
+          level: "error",
+          message: `exports \u6307\u5411\u5F00\u53D1\u6001\u6E90\u7801 "${t}"\uFF08\u53D1\u5E03\u6001\u5E94\u6307\u5411 dist/\uFF09`
+        });
+      } else if (t.startsWith("./") && !existsSync21(path25.join(pkgDir, t))) {
+        issues.push({
+          rule: "pack-exports",
+          level: "error",
+          message: `exports \u76EE\u6807\u7F3A\u5931\uFF08\u4EA7\u7269\u5185\u4E0D\u5B58\u5728\uFF09: ${t}`
+        });
+      }
+    }
+  }
+  const filesField = pkg.files;
+  if (Array.isArray(filesField) && filesField.length > 0) {
+    const allow = /* @__PURE__ */ new Set([...filesField.map((w) => String(w)), "package.json"]);
+    const bad = files.filter((f) => ![...allow].some((w) => f === w || f.startsWith(`${w}/`)));
+    if (bad.length > 0) {
+      issues.push({
+        rule: "pack-whitelist",
+        level: "error",
+        message: `\u4EA7\u7269\u542B\u767D\u540D\u5355\u5916\u6587\u4EF6: ${bad.slice(0, 5).join(", ")}${bad.length > 5 ? ` \u7B49 ${bad.length} \u4E2A` : ""}`
+      });
+    }
+  } else {
+    issues.push({
+      rule: "pack-whitelist",
+      level: "warning",
+      message: "\u672A\u58F0\u660E files \u767D\u540D\u5355\uFF0C\u4EA7\u7269\u8303\u56F4\u4E0D\u53EF\u63A7\uFF08\u5EFA\u8BAE\u58F0\u660E files \u9650\u5236\u6253\u5305\u5185\u5BB9\uFF09"
+    });
+  }
+  const leaked = files.filter((f) => /(^|\/)\.env$/.test(f) || /(^|\/)\.npmrc$/.test(f));
+  if (leaked.length > 0) {
+    issues.push({ rule: "pack-leak", level: "error", message: `\u4EA7\u7269\u542B\u654F\u611F\u6587\u4EF6: ${leaked.join(", ")}` });
+  }
+  if (kindOf === "module") {
+    for (const required of ["src", "dist", "tbox.component.json"]) {
+      if (!files.includes(required) && !existsSync21(path25.join(pkgDir, required))) {
+        issues.push({ rule: "pack-files", level: "error", message: `\u4E1A\u52A1\u6A21\u5757\u4EA7\u7269\u7F3A\u5C11 ${required}` });
+      }
+    }
+  } else if (kindOf === "template") {
+    for (const required of [
+      "pnpm-workspace.template.yaml",
+      "apps/server/package.json",
+      "apps/client/package.json",
+      "packages/module-weather/package.json",
+      ".tbox/app.json",
+      "tsconfig.base.json",
+      "scripts/verify-generated.mjs"
+    ]) {
+      if (!existsSync21(path25.join(pkgDir, required))) {
+        issues.push({ rule: "pack-files", level: "error", message: `\u6A21\u677F\u4EA7\u7269\u7F3A\u5C11 ${required}` });
+      }
+    }
+    for (const leaked2 of ["pnpm-workspace.yaml", "pnpm-lock.yaml"]) {
+      if (existsSync21(path25.join(pkgDir, leaked2))) {
+        issues.push({
+          rule: "pack-files",
+          level: "error",
+          message: `\u6A21\u677F\u4EA7\u7269\u6CC4\u6F0F ${leaked2}\uFF08\u5E94\u4EC5\u542B pnpm-workspace.template.yaml\uFF09`
+        });
+      }
+    }
+  } else if (kindOf === "contract") {
+    const dts = files.filter((f) => f.startsWith("dist/") && f.endsWith(".d.ts"));
+    if (dts.length === 0) {
+      issues.push({ rule: "pack-files", level: "error", message: "\u5951\u7EA6\u5305\u4EA7\u7269\u7F3A\u5C11 dist/*.d.ts" });
+    }
+  } else {
+    const bin = pkg.bin;
+    const binTargets = typeof bin === "string" ? [bin] : bin && typeof bin === "object" ? Object.values(bin) : [];
+    for (const target of binTargets) {
+      if (typeof target === "string" && !files.includes(target)) {
+        issues.push({ rule: "pack-files", level: "error", message: `bin \u6307\u5411\u6587\u4EF6\u7F3A\u5931: ${target}` });
+      }
+    }
+  }
+  const declaredDocs = Array.isArray(filesField) && filesField.length > 0;
+  for (const doc of ["LICENSE", "README.md"]) {
+    if (!files.includes(doc)) {
+      issues.push({
+        rule: "pack-docs",
+        level: "warning",
+        message: `\u4EA7\u7269\u7F3A\u5C11 ${doc}${declaredDocs ? "\uFF08files \u767D\u540D\u5355\u5DF2\u58F0\u660E\uFF1B\u53D1\u5E03\u5B8C\u5907\u6027 backlog\uFF09" : "\uFF08\u5EFA\u8BAE\u8865\u5145\u4EE5\u5B8C\u5907\u53D1\u5E03\u5143\u6570\u636E\uFF09"}`
+      });
+    }
+  }
+  return issues;
+}
+async function verifyTarball(tgzPath) {
+  const tarball = new TarballSource(tgzPath);
+  try {
+    const pkgDir = tarball.getDir();
+    const pkg = JSON.parse(await tarball.readFile("package.json"));
+    const kind = detectKind(pkgDir, pkg.name ?? "");
+    const issues = verifyPkgDir(pkgDir, kind);
+    if (pkg.name && pkg.version) {
+      const expect = tarballFileName(pkg.name, pkg.version);
+      if (path25.basename(tgzPath) !== expect) {
+        issues.push({
+          rule: "pack-filename",
+          level: "error",
+          message: `tgz \u6587\u4EF6\u540D ${path25.basename(tgzPath)} \u4E0E\u5305 ${pkg.name}@${pkg.version} \u671F\u671B ${expect} \u4E0D\u4E00\u81F4`
+        });
+      }
+    }
+    return issues;
+  } finally {
+    tarball.dispose();
+  }
+}
+function printIssues(issues) {
+  for (const i of issues) {
+    console.log(`  ${i.level === "error" ? "\u274C" : "\u26A0\uFE0F"} [${i.rule}] ${i.message}`);
+  }
+}
+async function packCommand(opts) {
+  const moduleDir = path25.resolve(process.cwd(), opts.module);
+  const tgzPath = packModule(moduleDir, opts.out);
+  console.log(`\u2705 \u5DF2\u6253\u5305 ${path25.basename(tgzPath)} \u2192 ${path25.resolve(opts.out)}`);
+  if (opts.check) {
+    const issues = await verifyTarball(tgzPath);
+    printIssues(issues);
+    if (issues.some((i) => i.level === "error")) process.exitCode = 1;
+  }
+}
+
+// src/commands/publish.ts
+async function publishModule(opts) {
+  const cwd = process.cwd();
+  const moduleDir = path26.resolve(cwd, opts.module);
+  if (!existsSync22(moduleDir) || !existsSync22(path26.join(moduleDir, "package.json"))) {
+    throw new Error(`\u6A21\u5757\u76EE\u5F55\u65E0\u6548\uFF08\u7F3A package.json\uFF09: ${opts.module}`);
+  }
+  let tgzPath;
+  let workDir = null;
+  if (opts.tgz) {
+    tgzPath = path26.resolve(opts.tgz);
+    if (!existsSync22(tgzPath)) throw new Error(`tgz \u4EA7\u7269\u4E0D\u5B58\u5728: ${opts.tgz}`);
+    const tarball = new TarballSource(tgzPath);
+    try {
+      const tgzPkg = JSON.parse(await tarball.readFile("package.json"));
+      const modulePkg = JSON.parse(readFileSync10(path26.join(moduleDir, "package.json"), "utf8"));
+      if (tgzPkg.name !== modulePkg.name) {
+        throw new Error(
+          `--tgz \u5305\u540D ${tgzPkg.name ?? "(\u672A\u77E5)"} \u4E0E\u6A21\u5757 ${modulePkg.name ?? "(\u672A\u77E5)"} \u4E0D\u4E00\u81F4\uFF08\u8BF7\u786E\u8BA4 --tgz \u4E0E\u6A21\u5757\u5339\u914D\uFF09`
+        );
+      }
+    } finally {
+      tarball.dispose();
+    }
+  } else {
+    workDir = mkdtempSync2(path26.join(tmpdir2(), "tbox-publish-"));
+    tgzPath = packModule(moduleDir, workDir);
+  }
+  try {
+    const issues = await verifyTarball(tgzPath);
+    if (issues.length > 0) printIssues(issues);
+    const errors = issues.filter((i) => i.level === "error");
+    if (errors.length > 0) {
+      throw new Error(`\u4EA7\u7269\u95E8\u7981\u5931\u8D25\uFF08${errors.length} \u5904 error\uFF09\uFF0C\u5DF2\u4E2D\u6B62\u53D1\u5E03: ${path26.basename(tgzPath)}`);
+    }
+    if (!workDir) workDir = mkdtempSync2(path26.join(tmpdir2(), "tbox-publish-"));
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    const registryArgs = opts.registry ? ["--registry", opts.registry] : [];
+    execFileSync4(
+      "pnpm",
+      ["publish", tgzPath, "--access", opts.access ?? "public", ...registryArgs, ...opts.dryRun ? ["--dry-run"] : []],
+      { stdio: "inherit", cwd: workDir }
+    );
+    console.log(
+      `\u2705 \u5DF2\u53D1\u5E03 ${path26.basename(tgzPath)}${opts.registry ? ` \u2192 ${opts.registry}` : ""}${opts.dryRun ? "\uFF08dry-run\uFF09" : ""}`
+    );
+  } finally {
+    if (workDir) {
+      try {
+        rmSync2(workDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+
+// src/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("tbox-app").description("tbox \u7EC4\u4EF6\u5316\u5E94\u7528 CLI\uFF1Acreate / module add|remove|list|sync|diff|doctor").version("0.1.0");
+  program.command("create <name>").description("\u4ECE\u6A21\u677F\u751F\u6210\u591A\u5305 workspace \u5E94\u7528\u9AA8\u67B6").option("--source <\u8DEF\u5F84>", "\u6A21\u677F\u6E90\uFF08\u672C\u5730\u76EE\u5F55 / \u6A21\u677F pack tgz / registry \u5305 @scope/pkg[@version]\uFF09").option("--local-deps <tgz\u76EE\u5F55>", "\u6CE8\u5165\u5E73\u53F0 overrides\uFF08file: \u672C\u5730\u53D1\u5E03\u6001 tgz\uFF0Cinstall \u79BB\u7EBF\u9A8C\u8BC1\u6001\uFF1B\u751F\u4EA7 B \u6863\u4E0D\u4F20\uFF09").option("--registry <url>", "\u62C9\u53D6 registry\uFF08registry \u6E90\u65F6\u751F\u6548\uFF1B\u7F3A\u7701\u81EA\u52A8\u89E3\u6790\u73AF\u5883\u955C\u50CF\uFF09").option("--force", "\u8986\u76D6\u5DF2\u5B58\u5728\u76EE\u5F55").action(async (name, opts) => {
+    try {
+      await createApp({ name, source: opts.source ?? "", force: opts.force, localDeps: opts.localDeps, registry: opts.registry });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  const moduleCmd = program.command("module").description("\u6A21\u5757\u7BA1\u7406\uFF08add/remove/list/sync/diff/doctor/update/publish/pack\uFF09");
+  moduleCmd.command("add <pkg>").description("\u5B89\u88C5/\u5C55\u5F00\u6A21\u5757\uFF08--mode local|codegen|sdk\uFF1B--source \u652F\u6301\u76EE\u5F55/tgz/registry \u5305\uFF09").option("--mode <local|codegen|sdk>", "\u5206\u53D1\u6A21\u5F0F", "codegen").option("--source <\u8DEF\u5F84>", "\u6A21\u5757\u6E90\uFF08\u672C\u5730\u76EE\u5F55/tgz/registry \u5305 @scope/pkg[@version]\uFF09").option("--registry <url>", "\u62C9\u53D6 registry\uFF08registry \u6E90\u65F6\u751F\u6548\uFF1B\u7F3A\u7701\u81EA\u52A8\u89E3\u6790\u73AF\u5883\u955C\u50CF\uFF09").option("--no-deps", "\u8DF3\u8FC7\u4F9D\u8D56\u81EA\u52A8\u89E3\u6790\uFF08P3 W3-B \u9003\u751F\u95E8\uFF09").action(async (pkg, opts) => {
+    try {
+      await addModule({ pkg, mode: opts.mode, source: opts.source, registry: opts.registry, noDeps: !opts.deps });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("remove <id>").description("\u5378\u8F7D\u6A21\u5757\uFF08\u5220\u5305 + \u6E05\u7406\u88C5\u914D\uFF09").option("--force", "\u5FFD\u7565\u53CD\u5411\u4F9D\u8D56\u68C0\u67E5\u5F3A\u5236\u79FB\u9664").action(async (id, opts) => {
+    try {
+      await removeModule(id, { force: opts.force });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("list").description("\u5217\u51FA\u5DF2\u88C5\u6A21\u5757").action(async () => {
+    try {
+      await listCommand();
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("sync").description("\u589E\u91CF\u88C5\u914D 4 \u6587\u4EF6\uFF08\u4E0D\u8986\u76D6\uFF1B\u7ED3\u6784\u7834\u574F\u964D\u7EA7\u4E3A\u544A\u8B66\uFF09").option("--force", "\u5168\u91CF\u8986\u76D6\u88C5\u914D\u6587\u4EF6\uFF08002 \xA76.5\uFF1A\u552F\u4E00\u8986\u76D6\u5165\u53E3\uFF09").action(async (opts) => {
+    try {
+      await syncCommand({ force: opts.force });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("diff [module]").description("\u88C5\u914D\u6F02\u79FB\u53CC\u5411 diff\uFF08module \u53EF\u6307\u5B9A\uFF0C\u9ED8\u8BA4\u5168\u90E8\uFF09").action(async (module) => {
+    try {
+      await diffCommand(module);
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("doctor").description("\u7ED3\u6784\u6821\u9A8C\uFF08doctor \u5B8C\u6574\u7248 13 \u6761\u89C4\u5219\uFF09").option("--json", "\u53EA\u8F93\u51FA JSON \u7ED3\u679C").option("--only <\u89C4\u5219\u5217\u8868>", "\u53EA\u8FD0\u884C\u6307\u5B9A\u89C4\u5219\uFF08\u9017\u53F7\u5206\u9694\uFF09").option("--skip <\u89C4\u5219\u5217\u8868>", "\u8DF3\u8FC7\u6307\u5B9A\u89C4\u5219\uFF08\u9017\u53F7\u5206\u9694\uFF09").action(async (opts) => {
+    try {
+      await doctorCommand(opts);
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("update <module>").description("\u5347\u7EA7\u7EC4\u4EF6\uFF08codegen\u21923-way merge\uFF1Bsdk\u2192pnpm update\uFF09").option("--dry-run", "\u53EA\u6253\u5370\u5408\u5E76\u7ED3\u679C\u4E0D\u5199\u56DE").option("--ours", "\u51B2\u7A81\u5FEB\u901F\u53D6\u672C\u5730\u7248\u672C").option("--theirs", "\u51B2\u7A81\u5FEB\u901F\u53D6\u65B0\u7248\u7248\u672C").option("--source <\u8DEF\u5F84>", "\u65B0\u7248\u672C\u5730\u6E90\u76EE\u5F55\u6216 tgz").option("--base-source <\u8DEF\u5F84>", "base \u672C\u5730\u6E90\u76EE\u5F55\u6216 tgz").action(async (module, opts) => {
+    try {
+      await updateModule({ module, ...opts });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("pack <module>").description("\u672C\u5730\u6253\u5305\u4E0D\u53D1\u5E03\uFF08\u6A21\u5757\u76EE\u5F55\u5982 modules/module-member\uFF1Bpnpm pack \u5185\u5EFA\u5F52\u4E00\u5316 \u2192 \u53D1\u5E03\u6001 tgz\uFF09").requiredOption("--out <dir>", "\u4EA7\u7269\u76EE\u5F55\uFF08pnpm \u81EA\u52A8\u521B\u5EFA\uFF0C\u540C\u540D\u8986\u76D6\u5199\uFF09").option("--check", "\u4EA7\u7269\u65AD\u8A00\uFF08\u534F\u8BAE\u6B8B\u7559 / exports / \u767D\u540D\u5355 / \u6CC4\u6F0F / \u6587\u4EF6\u4E00\u81F4\u6027\uFF09").action(async (module, opts) => {
+    try {
+      await packCommand({ module, out: opts.out, check: opts.check });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  moduleCmd.command("publish <module>").description("\u6A21\u5757\u664B\u5347 npm\uFF08\u6A21\u5757\u76EE\u5F55\u5982 modules/module-member\uFF1B\u6821\u9A8C + \u6253\u5305 + \u4EA7\u7269\u95E8\u7981 + pnpm publish <tgz>\uFF09").option("--tgz <path>", "\u590D\u7528\u5DF2\u9A8C\u8BC1\u4EA7\u7269\uFF08\u7F3A\u7701\u73B0\u573A pack \u5230\u4E34\u65F6\u76EE\u5F55\uFF09").option("--dry-run", "\u6821\u9A8C + \u95E8\u7981 + \u6253\u5370\uFF0C\u4E0D\u771F\u5B9E\u53D1\u5E03").option("--access <public|restricted>", "npm access", "public").option("--registry <url>", "\u53D1\u5E03 registry\uFF08\u7F3A\u7701 pnpm \u914D\u7F6E\u89E3\u6790\uFF1A@tbox.cn scope \u4F18\u5148\uFF09").action(async (module, opts) => {
+    try {
+      await publishModule({
+        module,
+        tgz: opts.tgz,
+        dryRun: opts.dryRun,
+        access: opts.access,
+        registry: opts.registry
+      });
+    } catch (err) {
+      console.error("\u274C", err.message);
+      process.exitCode = 1;
+    }
+  });
+  return program;
+}
+var isMain = typeof process.argv[1] === "string" && realpathSync3(fileURLToPath(import.meta.url)) === realpathSync3(process.argv[1]);
+if (isMain) {
+  createProgram().parseAsync(process.argv);
+}
+export {
+  createProgram
+};