@pactor-app/module-pack 0.0.0-stage → 1.56.0

package/dist/index.cjs

@@ -0,0 +1,1568 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CLIENT_EXTERNALS: () => CLIENT_EXTERNALS,
+  CLIENT_STYLES_ENTRY: () => CLIENT_STYLES_ENTRY,
+  CONFIG_DEFAULTS: () => CONFIG_DEFAULTS,
+  CONFIG_FILE: () => CONFIG_FILE,
+  ConfigError: () => ConfigError,
+  DEFAULT_TARGET: () => DEFAULT_TARGET,
+  INCLUDE_KEY: () => INCLUDE_KEY,
+  IncludeError: () => IncludeError,
+  MODULE_ID_PREFIX: () => MODULE_ID_PREFIX,
+  ModuleBuildError: () => ModuleBuildError,
+  ProfileError: () => ProfileError,
+  SERVER_BUNDLE_FILE: () => SERVER_BUNDLE_FILE,
+  SERVER_ENTRY: () => SERVER_ENTRY,
+  SERVER_EXTERNALS: () => SERVER_EXTERNALS,
+  ServerBundleError: () => ServerBundleError,
+  buildModule: () => buildModule,
+  bumpPackageVersion: () => bumpPackageVersion,
+  bumpVersion: () => bumpVersion,
+  bundleClient: () => bundleClient,
+  bundleServer: () => bundleServer,
+  collectModuleSource: () => collectModuleSource,
+  compileTailwind: () => compileTailwind,
+  deriveApiPrefix: () => deriveApiPrefix,
+  deriveModuleId: () => deriveModuleId,
+  discoverActions: () => discoverActions,
+  discoverComponents: () => discoverComponents,
+  emitDsl: () => emitDsl,
+  emitModule: () => emitModule,
+  expandIncludes: () => expandIncludes,
+  getProfile: () => getProfile,
+  initModule: () => initModule,
+  innospotsWebShellV1: () => innospotsWebShellV1,
+  innospotsWebShellV2: () => innospotsWebShellV2,
+  innospotsWebShellV3: () => innospotsWebShellV3,
+  listProfiles: () => listProfiles,
+  loadModuleConfig: () => loadModuleConfig,
+  loadYamlExpanded: () => loadYamlExpanded,
+  matchPathPattern: () => matchPathPattern,
+  parseJsonc: () => parseJsonc,
+  parseYamlFile: () => parseYamlFile,
+  readProjectVersion: () => readProjectVersion,
+  renderClientEntry: () => renderClientEntry,
+  renderModuleStyles: () => renderModuleStyles,
+  renderServerEntry: () => renderServerEntry,
+  resolvePactorVersionRange: () => resolvePactorVersionRange,
+  rewriteDslUrls: () => rewriteDslUrls,
+  rewriteNavigationTo: () => rewriteNavigationTo,
+  transformSitemap: () => transformSitemap,
+  tsconfigAliases: () => tsconfigAliases,
+  validateModule: () => validateModule,
+  writeManifest: () => writeManifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/build.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
+
+// src/bundle-client.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_esbuild = require("esbuild");
+var CLIENT_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "next",
+  "next/*",
+  "pactor-app",
+  "pactor-app/*",
+  "@pactor-app/*"
+];
+function bundleClient(options) {
+  const entry = (0, import_node_path.join)(options.projectDir, options.clientEntry);
+  if (!(0, import_node_fs.existsSync)(entry)) {
+    return {
+      bundled: false,
+      css: false,
+      message: `client \u5165\u53E3\u4E0D\u5B58\u5728: ${options.clientEntry}\uFF08\u6309\u7EAF DSL \u6A21\u5757\u5904\u7406\uFF0C\u8DF3\u8FC7 client \u6253\u5305\uFF09`
+    };
+  }
+  (0, import_node_fs.mkdirSync)(options.outDir, { recursive: true });
+  (0, import_esbuild.buildSync)({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    outdir: options.outDir,
+    entryNames: "index",
+    sourcemap: true,
+    alias: tsconfigAliases(options.projectDir),
+    external: [...CLIENT_EXTERNALS],
+    logLevel: "silent"
+  });
+  return {
+    bundled: true,
+    css: (0, import_node_fs.existsSync)((0, import_node_path.join)(options.outDir, "index.css"))
+  };
+}
+function tsconfigAliases(projectDir) {
+  const file = (0, import_node_path.join)(projectDir, "tsconfig.json");
+  if (!(0, import_node_fs.existsSync)(file)) return {};
+  const compilerOptions = readTsconfig(file);
+  const paths = compilerOptions.paths ?? {};
+  const baseUrl = compilerOptions.baseUrl ?? ".";
+  const alias = {};
+  for (const [key, targets] of Object.entries(paths)) {
+    const target = targets[0];
+    if (typeof target !== "string") continue;
+    const name = key.endsWith("/*") ? key.slice(0, -2) : key;
+    const rel = target.endsWith("/*") ? target.slice(0, -2) : target;
+    alias[name] = (0, import_node_path.resolve)((0, import_node_path.dirname)(file), baseUrl, rel);
+  }
+  return alias;
+}
+function readTsconfig(file, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(file) || !(0, import_node_fs.existsSync)(file)) return {};
+  seen.add(file);
+  let raw;
+  try {
+    raw = parseJsonc((0, import_node_fs.readFileSync)(file, "utf8"));
+  } catch {
+    return {};
+  }
+  let base2 = {};
+  if (typeof raw.extends === "string" && raw.extends.startsWith(".")) {
+    base2 = readTsconfig((0, import_node_path.resolve)((0, import_node_path.dirname)(file), raw.extends), seen);
+  }
+  const own = raw.compilerOptions ?? {};
+  return {
+    baseUrl: own.baseUrl ?? base2.baseUrl,
+    paths: { ...base2.paths ?? {}, ...own.paths ?? {} }
+  };
+}
+function parseJsonc(text) {
+  let out = "";
+  let inString = false;
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (inString) {
+      out += c;
+      if (c === "\\") {
+        out += text[i + 1] ?? "";
+        i += 2;
+        continue;
+      }
+      if (c === '"') inString = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i += 1;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i += 1;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+
+// src/bundle-server.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_esbuild2 = require("esbuild");
+var SERVER_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/*",
+  "next",
+  "next/*",
+  "pactor-app",
+  "pactor-app/*",
+  "@pactor-app/*"
+];
+var SERVER_BUNDLE_FILE = "index.mjs";
+var ServerBundleError = class extends Error {
+};
+function bundleServer(options) {
+  const projectRoot = (0, import_node_path2.resolve)(options.projectDir);
+  const entry = (0, import_node_path2.resolve)(projectRoot, options.serverEntry);
+  if (!entry.startsWith(`${projectRoot}${import_node_path2.sep}`)) {
+    throw new ServerBundleError(
+      `server \u5165\u53E3\u5FC5\u987B\u4F4D\u4E8E\u5DE5\u7A0B\u6839\u5185: ${options.serverEntry}`
+    );
+  }
+  if (!(0, import_node_fs2.existsSync)(entry)) {
+    throw new ServerBundleError(`server \u5165\u53E3\u4E0D\u5B58\u5728: ${options.serverEntry}`);
+  }
+  (0, import_node_fs2.mkdirSync)(options.outDir, { recursive: true });
+  (0, import_esbuild2.buildSync)({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    outdir: options.outDir,
+    entryNames: "index",
+    outExtension: { ".js": ".mjs" },
+    sourcemap: true,
+    alias: tsconfigAliases(projectRoot),
+    external: [...SERVER_EXTERNALS],
+    logLevel: "silent"
+  });
+  if (!(0, import_node_fs2.existsSync)((0, import_node_path2.join)(options.outDir, SERVER_BUNDLE_FILE))) {
+    throw new ServerBundleError(
+      `server \u6253\u5305\u672A\u4EA7\u51FA ${SERVER_BUNDLE_FILE}\uFF08\u8BF7\u68C0\u67E5 serverEntry \u4E0E esbuild \u914D\u7F6E\uFF09`
+    );
+  }
+  return { bundled: true, entry: SERVER_BUNDLE_FILE };
+}
+
+// src/collect.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+function collectModuleSource(yamlRoot) {
+  const pages = /* @__PURE__ */ new Map();
+  const layouts = [];
+  const fragments = [];
+  const warnings = [];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+      const full = (0, import_node_path3.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.name.endsWith(".yaml") || entry.name === "sitemap.yaml") {
+        continue;
+      }
+      const rel = (0, import_node_path3.relative)(yamlRoot, full);
+      if (entry.name.endsWith(".layout.yaml")) {
+        layouts.push(rel);
+        continue;
+      }
+      if (entry.name.endsWith(".fragment.yaml")) {
+        fragments.push(rel);
+        continue;
+      }
+      let id = entry.name.slice(0, -".yaml".length);
+      if (id.endsWith(".page")) {
+        id = id.slice(0, -".page".length);
+      }
+      if (pages.has(id)) {
+        warnings.push(`\u9875\u9762 id \u91CD\u590D: ${id}\uFF08${rel} \u8986\u76D6 ${pages.get(id)}\uFF09`);
+      }
+      pages.set(id, rel);
+    }
+  };
+  walk(yamlRoot);
+  layouts.sort();
+  fragments.sort();
+  return { yamlRoot, pages, layouts, fragments, warnings };
+}
+
+// src/compile-styles.ts
+var import_node_child_process = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_os = require("os");
+var import_node_path4 = require("path");
+function compileTailwind(options) {
+  const warnings = [];
+  if (!options.tailwind.enabled) {
+    return { compiled: false, warnings };
+  }
+  const work = (0, import_node_fs4.mkdtempSync)((0, import_node_path4.join)((0, import_node_os.tmpdir)(), "pactor-tailwind-"));
+  try {
+    let input;
+    if (options.tailwind.input !== void 0) {
+      input = (0, import_node_path4.join)(options.projectDir, options.tailwind.input);
+      if (!(0, import_node_fs4.existsSync)(input)) {
+        warnings.push(`tailwind.input \u4E0D\u5B58\u5728: ${options.tailwind.input}\uFF0C\u8DF3\u8FC7\u9884\u7F16\u8BD1`);
+        return { compiled: false, warnings };
+      }
+    } else {
+      const scan = (options.tailwind.scan ?? options.scanDirs).map(
+        (dir) => `@source "${dir.replace(/\\/g, "/")}";`
+      );
+      input = (0, import_node_path4.join)(work, "input.css");
+      (0, import_node_fs4.writeFileSync)(input, `@import "tailwindcss";
+${scan.join("\n")}
+`, "utf8");
+    }
+    const out = (0, import_node_path4.join)(work, "tailwind.css");
+    (0, import_node_child_process.execFileSync)(
+      "npx",
+      ["--no-install", "tailwindcss", "--input", input, "--output", out],
+      { cwd: options.projectDir, stdio: "pipe" }
+    );
+    if ((0, import_node_fs4.existsSync)(out)) {
+      const css = (0, import_node_fs4.readFileSync)(out, "utf8");
+      if (css.trim().length > 0) {
+        (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(options.cssFile), { recursive: true });
+        (0, import_node_fs4.appendFileSync)(
+          options.cssFile,
+          `
+/* tailwind utilities\uFF08pactor module build \u9884\u7F16\u8BD1\uFF09 */
+${css}`,
+          "utf8"
+        );
+        return { compiled: true, warnings };
+      }
+    }
+    warnings.push("tailwind \u9884\u7F16\u8BD1\u4EA7\u7269\u4E3A\u7A7A\uFF0C\u5DF2\u8DF3\u8FC7");
+    return { compiled: false, warnings };
+  } catch (error) {
+    const firstLine = error.message.split("\n")[0] ?? "\u672A\u77E5\u9519\u8BEF";
+    warnings.push(`tailwind \u4E0D\u53EF\u7528\u6216\u7F16\u8BD1\u5931\u8D25\uFF0C\u5DF2\u964D\u7EA7\u8DF3\u8FC7\u9884\u7F16\u8BD1\uFF08${firstLine}\uFF09`);
+    return { compiled: false, warnings };
+  } finally {
+    (0, import_node_fs4.rmSync)(work, { recursive: true, force: true });
+  }
+}
+
+// src/config.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+
+// src/profiles/innospots-web-shell.ts
+var base = {
+  name: "innospots-web-shell",
+  inlineStringLayouts: true,
+  stripMenuPaths: true,
+  rewriteNavigation: { basePath: true, excludeApiUrls: true },
+  rewriteAssetUrls: (id, version) => `/modules/${id}/${version}/`,
+  forbidRootBasePath: true,
+  moduleServerApi: false
+};
+var innospotsWebShellV1 = {
+  ...base,
+  version: 1,
+  forceInlinePages: true
+};
+var innospotsWebShellV2 = {
+  ...base,
+  version: 2,
+  forceInlinePages: false
+};
+var innospotsWebShellV3 = {
+  ...base,
+  version: 3,
+  forceInlinePages: false,
+  moduleServerApi: true
+};
+
+// src/profiles/index.ts
+var ProfileError = class extends Error {
+};
+var registry = /* @__PURE__ */ new Map([
+  [`${innospotsWebShellV1.name}@${innospotsWebShellV1.version}`, innospotsWebShellV1],
+  [`${innospotsWebShellV2.name}@${innospotsWebShellV2.version}`, innospotsWebShellV2],
+  [`${innospotsWebShellV3.name}@${innospotsWebShellV3.version}`, innospotsWebShellV3]
+]);
+var DEFAULT_TARGET = `${innospotsWebShellV3.name}@${innospotsWebShellV3.version}`;
+function listProfiles() {
+  return [...registry.keys()];
+}
+function getProfile(id) {
+  const profile = registry.get(id);
+  if (!profile) {
+    throw new ProfileError(`\u672A\u77E5 target profile: ${id}\uFF08\u53EF\u7528: ${listProfiles().join(", ")}\uFF09`);
+  }
+  return profile;
+}
+
+// src/config.ts
+var ConfigError = class extends Error {
+};
+var CONFIG_FILE = "pactor.module.json";
+var CONFIG_DEFAULTS = {
+  yamlRoot: "src/server/yaml",
+  clientEntry: "module/client.ts",
+  publicDir: "public",
+  target: DEFAULT_TARGET,
+  outDir: "dist-module"
+};
+function loadModuleConfig(projectDir, configPath) {
+  const file = configPath ? (0, import_node_path5.resolve)(projectDir, configPath) : (0, import_node_path5.join)(projectDir, CONFIG_FILE);
+  if (!(0, import_node_fs5.existsSync)(file)) {
+    throw new ConfigError(`\u7F3A\u5C11\u914D\u7F6E\u6587\u4EF6: ${file}\uFF08\u53EF\u5148\u6267\u884C pactor module init \u751F\u6210\uFF09`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse((0, import_node_fs5.readFileSync)(file, "utf8"));
+  } catch (error) {
+    throw new ConfigError(`\u914D\u7F6E\u89E3\u6790\u5931\u8D25: ${file}: ${error.message}`);
+  }
+  if (!isRecord(raw)) {
+    throw new ConfigError(`${file}: \u914D\u7F6E\u5FC5\u987B\u662F JSON \u5BF9\u8C61`);
+  }
+  const id = readString(raw, "id", file);
+  if (!id) {
+    throw new ConfigError(`${file}: \u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5 id\uFF08\u6A21\u5757 id\uFF0C\u8FDB\u5165 globalPageId \u524D\u7F00\uFF09`);
+  }
+  const name = readString(raw, "name", file) ?? id;
+  let basePath = readString(raw, "basePath", file) ?? `/${id}`;
+  if (!basePath.startsWith("/")) basePath = `/${basePath}`;
+  if (basePath.length > 1 && basePath.endsWith("/")) basePath = basePath.slice(0, -1);
+  const actions = raw.actions === void 0 ? [] : readStringArray(raw.actions, "actions", file);
+  if (raw.demo !== void 0) {
+    throw new ConfigError(
+      `${file}: demo.public \u5DF2\u79FB\u9664\uFF0C\u8BF7\u6539\u7528 "access": { "default": "public" }\uFF08\u7F3A\u7701\u586B\u5145\u8BED\u4E49\uFF0C\u4E0D\u8986\u76D6\u663E\u5F0F permission\uFF09`
+    );
+  }
+  const access = isRecord(raw.access) ? raw.access : {};
+  const accessDefault = readString(access, "default", file, "access") ?? "authenticated";
+  if (accessDefault !== "public" && accessDefault !== "authenticated") {
+    throw new ConfigError(`${file}: access.default \u53EA\u652F\u6301 "public" | "authenticated"`);
+  }
+  const tailwind = isRecord(raw.tailwind) ? raw.tailwind : {};
+  const rewrite = isRecord(raw.rewrite) ? raw.rewrite : {};
+  const serverEntry = readString(raw, "serverEntry", file);
+  const apiPrefixes = raw.apiPrefixes === void 0 ? void 0 : readStringArray(raw.apiPrefixes, "apiPrefixes", file);
+  validateServerConfig({ id, serverEntry, apiPrefixes, file });
+  return {
+    id,
+    name,
+    basePath,
+    yamlRoot: readString(raw, "yamlRoot", file) ?? CONFIG_DEFAULTS.yamlRoot,
+    clientEntry: readString(raw, "clientEntry", file) ?? CONFIG_DEFAULTS.clientEntry,
+    ...serverEntry !== void 0 ? { serverEntry, apiPrefixes } : {},
+    actions,
+    publicDir: readString(raw, "publicDir", file) ?? CONFIG_DEFAULTS.publicDir,
+    target: readString(raw, "target", file) ?? CONFIG_DEFAULTS.target,
+    access: { default: accessDefault },
+    tailwind: {
+      enabled: readBoolean(tailwind, "enabled", file, "tailwind") ?? false,
+      input: readString(tailwind, "input", file, "tailwind"),
+      scan: tailwind.scan === void 0 ? void 0 : readStringArray(tailwind.scan, "tailwind.scan", file)
+    },
+    rewrite: {
+      absoluteApiToRelative: readBoolean(rewrite, "absoluteApiToRelative", file, "rewrite") ?? true
+    },
+    outDir: readString(raw, "outDir", file) ?? CONFIG_DEFAULTS.outDir
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readString(record, key, file, parent) {
+  const value = record[key];
+  if (value === void 0) return void 0;
+  const label = parent ? `${parent}.${key}` : key;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ConfigError(`${file}: ${label} \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+  }
+  return value;
+}
+function readBoolean(record, key, file, parent) {
+  const value = record[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new ConfigError(`${file}: ${parent}.${key} \u5FC5\u987B\u662F\u5E03\u5C14\u503C`);
+  }
+  return value;
+}
+function readStringArray(value, label, file) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new ConfigError(`${file}: ${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4`);
+  }
+  return value;
+}
+var URL_SAFE_MODULE_ID_RE = /^[A-Za-z0-9._~-]+$/;
+var API_PREFIX_RE = /^\/api\/[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)*$/;
+var RESERVED_API_PREFIXES = ["/api/modules", "/api/runtime"];
+function validateServerConfig(input) {
+  const { id, serverEntry, apiPrefixes, file } = input;
+  if (serverEntry === void 0 && apiPrefixes === void 0) return;
+  if (serverEntry === void 0 || apiPrefixes === void 0) {
+    throw new ConfigError(`${file}: serverEntry \u4E0E apiPrefixes \u5FC5\u987B\u540C\u65F6\u914D\u7F6E\uFF08\u7F3A\u4E00\u4E0D\u53EF\uFF09`);
+  }
+  if (apiPrefixes.length === 0) {
+    throw new ConfigError(`${file}: \u914D\u7F6E serverEntry \u65F6 apiPrefixes \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4`);
+  }
+  if (!URL_SAFE_MODULE_ID_RE.test(id)) {
+    throw new ConfigError(
+      `${file}: \u542F\u7528 serverEntry \u65F6 id \u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001. _ ~ -\uFF08\u5F53\u524D: ${JSON.stringify(id)}\uFF09`
+    );
+  }
+  for (const prefix of apiPrefixes) {
+    if (!API_PREFIX_RE.test(prefix)) {
+      throw new ConfigError(
+        `${file}: apiPrefixes \u542B\u975E\u6CD5\u524D\u7F00 ${JSON.stringify(prefix)}\uFF08\u8981\u6C42\u5F62\u5982 /api/risk-analysis\uFF0C\u4E0D\u80FD\u542B query / hash / \u5C3E\u659C\u6760 / \u901A\u914D / :param\uFF09`
+      );
+    }
+    const reserved = RESERVED_API_PREFIXES.find(
+      (item) => prefix === item || prefix.startsWith(`${item}/`)
+    );
+    if (reserved) {
+      throw new ConfigError(
+        `${file}: apiPrefixes \u4E0D\u80FD\u4F7F\u7528\u4FDD\u7559\u524D\u7F00 ${reserved}\uFF08Shell \u81EA\u5E26\u8DEF\u7531\uFF09: ${prefix}`
+      );
+    }
+  }
+  for (let i = 0; i < apiPrefixes.length; i += 1) {
+    for (let j = i + 1; j < apiPrefixes.length; j += 1) {
+      const a = apiPrefixes[i];
+      const b = apiPrefixes[j];
+      if (a === b) {
+        throw new ConfigError(`${file}: apiPrefixes \u5B58\u5728\u91CD\u590D\u524D\u7F00: ${a}`);
+      }
+      if (a.startsWith(`${b}/`) || b.startsWith(`${a}/`)) {
+        throw new ConfigError(
+          `${file}: apiPrefixes \u524D\u7F00\u4E92\u76F8\u5305\u542B\uFF08\u540C\u4E00\u6A21\u5757\u5185\u65E0\u6CD5\u786E\u5B9A\u5F52\u5C5E\uFF09: ${a} / ${b}`
+        );
+      }
+    }
+  }
+}
+
+// src/emit-manifest.ts
+var import_node_crypto = require("crypto");
+var import_node_fs6 = require("fs");
+var import_node_module = require("module");
+var import_node_path6 = require("path");
+var import_yaml = require("yaml");
+function emitModule(input) {
+  const dslResult = emitDsl(input);
+  const manifest = writeManifest(input);
+  return { ...dslResult, manifest };
+}
+function emitDsl(input) {
+  const { config, projectDir, outDir, site, pages } = input;
+  const dslDir = (0, import_node_path6.join)(outDir, "dsl");
+  (0, import_node_fs6.mkdirSync)(dslDir, { recursive: true });
+  (0, import_node_fs6.writeFileSync)((0, import_node_path6.join)(dslDir, "sitemap.yaml"), (0, import_yaml.stringify)(site, { lineWidth: 0 }), "utf8");
+  for (const [id, dsl] of pages) {
+    (0, import_node_fs6.writeFileSync)((0, import_node_path6.join)(dslDir, `${id}.yaml`), (0, import_yaml.stringify)(dsl, { lineWidth: 0 }), "utf8");
+  }
+  const publicDir = (0, import_node_path6.join)(projectDir, config.publicDir);
+  const assetsDir = (0, import_node_path6.join)(outDir, "assets");
+  if ((0, import_node_fs6.existsSync)(publicDir)) {
+    (0, import_node_fs6.cpSync)(publicDir, assetsDir, { recursive: true });
+  } else {
+    (0, import_node_fs6.mkdirSync)(assetsDir, { recursive: true });
+  }
+  const assets = hashAssets(assetsDir, assetsDir);
+  (0, import_node_fs6.writeFileSync)(
+    (0, import_node_path6.join)(outDir, "module-assets.json"),
+    `${JSON.stringify({ module: config.id, assets }, null, 2)}
+`,
+    "utf8"
+  );
+  return { assetCount: assets.length };
+}
+function writeManifest(input) {
+  const { config, projectDir, outDir } = input;
+  const version = readProjectVersion(projectDir);
+  const manifest = {
+    schemaVersion: "1",
+    id: config.id,
+    name: config.name,
+    version,
+    pactorVersionRange: resolvePactorVersionRange(projectDir, input.warnings),
+    basePath: config.basePath,
+    sitemap: "dsl/sitemap.yaml",
+    dslRoot: "dsl",
+    assetsRoot: "assets",
+    ...input.clientEntry ? { clientEntry: input.clientEntry } : {},
+    ...input.styles ? { styles: input.styles } : {},
+    ...input.serverEntry ? { serverEntry: input.serverEntry } : {},
+    ...input.apiPrefixes && input.apiPrefixes.length > 0 ? { apiPrefixes: input.apiPrefixes } : {}
+  };
+  (0, import_node_fs6.writeFileSync)(
+    (0, import_node_path6.join)(outDir, "manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  return manifest;
+}
+function readProjectVersion(projectDir) {
+  const pkgFile = (0, import_node_path6.join)(projectDir, "package.json");
+  if (!(0, import_node_fs6.existsSync)(pkgFile)) return "0.0.0";
+  try {
+    const pkg = JSON.parse((0, import_node_fs6.readFileSync)(pkgFile, "utf8"));
+    return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function resolvePactorVersionRange(projectDir, warnings) {
+  try {
+    const require2 = (0, import_node_module.createRequire)((0, import_node_path6.join)(projectDir, "package.json"));
+    for (const name of ["pactor-app/package.json", "@pactor-app/app/package.json"]) {
+      try {
+        const pkgFile = require2.resolve(name);
+        const pkg2 = JSON.parse((0, import_node_fs6.readFileSync)(pkgFile, "utf8"));
+        if (typeof pkg2.version === "string" && pkg2.version.length > 0) {
+          return `^${pkg2.version}`;
+        }
+      } catch {
+      }
+    }
+    const pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path6.join)(projectDir, "package.json"), "utf8"));
+    for (const section of ["dependencies", "peerDependencies", "devDependencies"]) {
+      const range = pkg[section]?.["pactor-app"];
+      if (typeof range === "string" && range.length > 0) {
+        return range;
+      }
+    }
+  } catch {
+  }
+  warnings.push("\u672A\u80FD\u63A8\u5BFC\u76EE\u6807\u5DE5\u7A0B\u7684 pactor-app \u7248\u672C\uFF0CpactorVersionRange \u56DE\u9000\u4E3A ^1.54.0");
+  return "^1.54.0";
+}
+function hashAssets(dir, root) {
+  const entries = [];
+  if (!(0, import_node_fs6.existsSync)(dir)) return entries;
+  for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true }).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    const full = (0, import_node_path6.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      entries.push(...hashAssets(full, root));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const content = (0, import_node_fs6.readFileSync)(full);
+    entries.push({
+      path: full.slice(root.length + 1).split("\\").join("/"),
+      sha256: (0, import_node_crypto.createHash)("sha256").update(content).digest("hex"),
+      size: (0, import_node_fs6.statSync)(full).size
+    });
+  }
+  return entries;
+}
+
+// src/expand-include.ts
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
+var import_yaml2 = require("yaml");
+var INCLUDE_KEY = "$include";
+var IncludeError = class extends Error {
+};
+function parseYamlFile(file) {
+  const doc = (0, import_yaml2.parseDocument)((0, import_node_fs7.readFileSync)(file, "utf8"));
+  if (doc.errors.length > 0) {
+    throw new IncludeError(
+      `${file}: ${doc.errors.map((error) => error.message).join("; ")}`
+    );
+  }
+  return doc.toJS();
+}
+function loadYamlExpanded(yamlRoot, relPath, stack = []) {
+  if (stack.includes(relPath)) {
+    throw new IncludeError(`\u5FAA\u73AF\u5F15\u7528: ${[...stack, relPath].join(" -> ")}`);
+  }
+  const value = parseYamlFile((0, import_node_path7.join)(yamlRoot, relPath));
+  return expandIncludes(value, { yamlRoot, current: relPath, stack: [...stack, relPath] });
+}
+function expandIncludes(value, ctx) {
+  if (Array.isArray(value)) {
+    return value.map((item) => expandIncludes(item, ctx));
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  if (INCLUDE_KEY in record) {
+    if (Object.keys(record).length > 1) {
+      throw new IncludeError(`${ctx.current}: $include \u4E0D\u80FD\u4E0E\u5176\u4ED6\u5B57\u6BB5\u5E76\u5217`);
+    }
+    const target = record[INCLUDE_KEY];
+    if (typeof target !== "string") {
+      throw new IncludeError(`${ctx.current}: $include \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+    }
+    return loadYamlExpanded(ctx.yamlRoot, target, ctx.stack);
+  }
+  return Object.fromEntries(
+    Object.entries(record).map(([key, item]) => [key, expandIncludes(item, ctx)])
+  );
+}
+
+// src/rewrite-urls.ts
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
+var NAVIGATION_ACTIONS = /* @__PURE__ */ new Set(["navigate", "app.reload"]);
+var ABSOLUTE_API_RE = /^https?:\/\/[^/]+(\/api\/.+)$/;
+function rewriteDslUrls(value, ctx) {
+  const warnings = [];
+  const walk = (node) => {
+    if (typeof node === "string") {
+      return rewriteString(node, ctx, warnings);
+    }
+    if (Array.isArray(node)) {
+      return node.map((item) => walk(item));
+    }
+    if (node === null || typeof node !== "object") {
+      return node;
+    }
+    const record = node;
+    const next = {};
+    for (const [key, item] of Object.entries(record)) {
+      next[key] = walk(item);
+    }
+    if (ctx.rewriteNavigation && isNavigationAction(record)) {
+      const params = next.params;
+      if (isRecord2(params) && typeof params.to === "string") {
+        const rewritten = rewriteNavigationTo(params.to, ctx);
+        if (rewritten !== void 0) {
+          params.to = rewritten;
+        }
+      }
+    }
+    return next;
+  };
+  return { value: walk(value), warnings };
+}
+function isNavigationAction(record) {
+  return typeof record.action === "string" && NAVIGATION_ACTIONS.has(record.action);
+}
+function rewriteNavigationTo(to, ctx) {
+  if (!to.startsWith("/") || to.startsWith("//")) return void 0;
+  if (to.startsWith("/api/")) return void 0;
+  if (to === ctx.basePath || to.startsWith(`${ctx.basePath}/`)) return void 0;
+  const hit = [ctx.loginPath, ...ctx.pagePaths].some(
+    (pattern) => pattern.length > 0 && matchPathPattern(pattern, to)
+  );
+  if (!hit) return void 0;
+  return `${ctx.basePath}${to}`;
+}
+function matchPathPattern(pattern, value) {
+  const patternSegs = pattern.split("?")[0].split("/").filter(Boolean);
+  const valueSegs = value.split("?")[0].split("/").filter(Boolean);
+  if (patternSegs.length !== valueSegs.length) return false;
+  return patternSegs.every((seg, index) => seg.startsWith(":") || seg === valueSegs[index]);
+}
+function rewriteString(value, ctx, warnings) {
+  const absoluteApi = ABSOLUTE_API_RE.exec(value);
+  if (absoluteApi) {
+    const relative3 = absoluteApi[1];
+    const namespaced2 = ctx.absoluteApiToRelative ? namespaceModuleApi(relative3, ctx) : void 0;
+    const action = ctx.absoluteApiToRelative ? namespaced2 !== void 0 ? "\uFF08\u5DF2\u91CD\u5199\u4E3A\u6A21\u5757 API \u76F8\u5BF9\u8DEF\u5F84\uFF09" : "\uFF08\u5DF2\u91CD\u5199\u4E3A\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u9700\u5E95\u5EA7 BFF/\u4EE3\u7406\u627F\u63A5\uFF09" : "\uFF08absoluteApiToRelative=false\uFF0C\u4FDD\u6301\u7EDD\u5BF9\u5730\u5740\uFF0C\u4E0D\u4F1A\u8D70\u6A21\u5757 API \u8DEF\u7531\uFF09";
+    warnings.push(`\u7EDD\u5BF9 API \u5730\u5740: ${value}${action}`);
+    return ctx.absoluteApiToRelative ? namespaced2 ?? relative3 : value;
+  }
+  const namespaced = namespaceModuleApi(value, ctx);
+  if (namespaced !== void 0) return namespaced;
+  if (!ctx.rewriteAssets) return value;
+  if (!value.startsWith("/") || value.startsWith("//")) return value;
+  if (value.startsWith("/api/")) return value;
+  if (value === ctx.basePath || value.startsWith(`${ctx.basePath}/`)) return value;
+  const isPagePath = [ctx.loginPath, ...ctx.pagePaths].some(
+    (pattern) => pattern.length > 0 && matchPathPattern(pattern, value)
+  );
+  if (isPagePath) return value;
+  if (!isPublicFile(ctx.publicDir, value)) return value;
+  return `${ctx.assetPrefix}${value}`;
+}
+function namespaceModuleApi(value, ctx) {
+  const { moduleId, apiPrefixes } = ctx;
+  if (!moduleId || !apiPrefixes || apiPrefixes.length === 0) return void 0;
+  const pathOnly = value.split(/[?#]/, 1)[0];
+  const hit = [...apiPrefixes].sort((a, b) => b.length - a.length).some((prefix) => pathOnly === prefix || pathOnly.startsWith(`${prefix}/`));
+  if (!hit) return void 0;
+  return `/api/modules/${encodeURIComponent(moduleId)}${value.slice("/api".length)}`;
+}
+function isPublicFile(publicDir, urlPath) {
+  const file = (0, import_node_path8.join)(publicDir, urlPath);
+  try {
+    return (0, import_node_fs8.existsSync)(file) && (0, import_node_fs8.statSync)(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/transform-sitemap.ts
+function transformSitemap(site, options) {
+  const { profile, accessDefault, loadLayout } = options;
+  const fillPublic = accessDefault === "public";
+  const next = { ...site };
+  const rawLayouts = isRecord3(site.layouts) ? site.layouts : {};
+  const layouts = {};
+  for (const [name, def] of Object.entries(rawLayouts)) {
+    layouts[name] = typeof def === "string" && profile.inlineStringLayouts ? loadLayout(def) : def;
+  }
+  next.layouts = layouts;
+  const rawPages = Array.isArray(site.pages) ? site.pages : [];
+  next.pages = rawPages.map((page) => {
+    const nextPage = { ...page };
+    if (profile.forceInlinePages) {
+      delete nextPage.lazy;
+    }
+    if (fillPublic && isAccessUndeclared(nextPage)) {
+      nextPage.public = true;
+    }
+    return nextPage;
+  });
+  const rawMenus = Array.isArray(site.menus) ? site.menus : [];
+  const transformMenu = (menu) => {
+    const nextMenu = { ...menu };
+    if (profile.stripMenuPaths) {
+      delete nextMenu.path;
+    }
+    if (fillPublic && isAccessUndeclared(nextMenu)) {
+      nextMenu.public = true;
+    }
+    if (Array.isArray(nextMenu.children)) {
+      nextMenu.children = nextMenu.children.map(
+        (child) => isRecord3(child) ? transformMenu(child) : child
+      );
+    }
+    return nextMenu;
+  };
+  next.menus = rawMenus.map((menu) => isRecord3(menu) ? transformMenu(menu) : menu);
+  return {
+    site: next,
+    layoutCount: Object.keys(layouts).length,
+    pageCount: rawPages.length,
+    menuCount: rawMenus.length
+  };
+}
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isAccessUndeclared(entry) {
+  return entry.public === void 0 && entry.permission === void 0;
+}
+
+// src/validate.ts
+var import_node_fs9 = require("fs");
+var import_node_path9 = require("path");
+var import_yaml3 = require("yaml");
+var REQUIRED_MANIFEST_FIELDS = [
+  "schemaVersion",
+  "id",
+  "name",
+  "version",
+  "pactorVersionRange",
+  "basePath",
+  "sitemap",
+  "dslRoot",
+  "assetsRoot"
+];
+function validateModule(options = {}) {
+  const projectDir = (0, import_node_path9.resolve)(options.dir ?? process.cwd());
+  const errors = [];
+  const warnings = [];
+  let config;
+  if (options.moduleDir === void 0) {
+    try {
+      config = loadModuleConfig(projectDir, options.config);
+    } catch (error) {
+      errors.push(error.message);
+      return { ok: false, errors, warnings };
+    }
+  } else {
+    try {
+      config = loadModuleConfig(projectDir, options.config);
+    } catch {
+      config = void 0;
+    }
+  }
+  const moduleDir = options.moduleDir ?? (0, import_node_path9.join)(projectDir, config?.outDir ?? CONFIG_DEFAULTS.outDir);
+  const manifestFile = (0, import_node_path9.join)(moduleDir, "manifest.json");
+  if (!(0, import_node_fs9.existsSync)(manifestFile)) {
+    errors.push(`\u4EA7\u7269\u4E0D\u5B58\u5728: ${manifestFile}\uFF08\u5148\u6267\u884C pactor module build\uFF09`);
+    return { ok: false, errors, warnings };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse((0, import_node_fs9.readFileSync)(manifestFile, "utf8"));
+  } catch (error) {
+    errors.push(`manifest.json \u89E3\u6790\u5931\u8D25: ${error.message}`);
+    return { ok: false, errors, warnings };
+  }
+  for (const field of REQUIRED_MANIFEST_FIELDS) {
+    if (!(field in manifest)) {
+      errors.push(`manifest \u7F3A\u5C11\u5B57\u6BB5: ${field}`);
+    }
+  }
+  if (manifest.schemaVersion !== "1") {
+    errors.push(`manifest.schemaVersion \u5FC5\u987B\u4E3A "1"\uFF08\u5F53\u524D: ${JSON.stringify(manifest.schemaVersion)}\uFF09`);
+  }
+  const dslRoot = typeof manifest.dslRoot === "string" ? manifest.dslRoot : "dsl";
+  const sitemapRel = typeof manifest.sitemap === "string" ? manifest.sitemap : "dsl/sitemap.yaml";
+  const sitemapFile = (0, import_node_path9.join)(moduleDir, sitemapRel);
+  if (!(0, import_node_fs9.existsSync)(sitemapFile)) {
+    errors.push(`sitemap \u4E0D\u5B58\u5728: ${sitemapRel}`);
+  } else {
+    const doc = (0, import_yaml3.parseDocument)((0, import_node_fs9.readFileSync)(sitemapFile, "utf8"));
+    if (doc.errors.length > 0) {
+      errors.push(`sitemap YAML \u89E3\u6790\u5931\u8D25: ${doc.errors.map((e) => e.message).join("; ")}`);
+    } else {
+      const site = doc.toJS();
+      const pages = Array.isArray(site.pages) ? site.pages : [];
+      for (const page of pages) {
+        const id = page.id;
+        if (typeof id !== "string") {
+          errors.push("sitemap.pages \u5B58\u5728\u7F3A\u5C11 id \u7684\u9875\u9762\u9879");
+          continue;
+        }
+        if (findPageDslFile((0, import_node_path9.join)(moduleDir, dslRoot), id) === null) {
+          errors.push(`\u9875\u9762 ${id} \u7F3A\u5C11 DSL \u6587\u4EF6\uFF08${dslRoot}/ \u4E0B\u672A\u627E\u5230 ${id}.yaml\uFF09`);
+        }
+      }
+      const layouts = site.layouts;
+      if (layouts !== null && typeof layouts === "object" && !Array.isArray(layouts)) {
+        for (const [name, def] of Object.entries(layouts)) {
+          if (typeof def === "string") {
+            errors.push(`\u5E03\u5C40 ${name} \u4ECD\u662F\u5B57\u7B26\u4E32\u5F15\u7528\uFF08target \u8981\u6C42\u5185\u8054\u4E3A\u5BF9\u8C61\uFF09`);
+          }
+        }
+      }
+    }
+  }
+  const dslDir = (0, import_node_path9.join)(moduleDir, dslRoot);
+  for (const file of listFiles(dslDir)) {
+    if ((0, import_node_fs9.readFileSync)(file, "utf8").includes(INCLUDE_KEY)) {
+      errors.push(`$include \u6B8B\u7559: ${(0, import_node_path9.relative)(moduleDir, file)}`);
+    }
+  }
+  if (typeof manifest.clientEntry === "string") {
+    const clientFile = (0, import_node_path9.join)(moduleDir, manifest.clientEntry);
+    if (!(0, import_node_fs9.existsSync)(clientFile)) {
+      errors.push(`client bundle \u4E0D\u5B58\u5728: ${manifest.clientEntry}`);
+    } else {
+      const text = (0, import_node_fs9.readFileSync)(clientFile, "utf8");
+      if (/\bvar React\b|react\.production\.min|__REACT_DEVTOOLS_GLOBAL_HOOK__/.test(text)) {
+        errors.push("client bundle \u7591\u4F3C\u5185\u5D4C react\uFF08react \u5FC5\u987B\u4FDD\u6301 external\uFF0C\u907F\u514D\u53CC\u5B9E\u4F8B\uFF09");
+      }
+      if (/node_modules\/@pactor-app\//.test(text) || /node_modules\/pactor-app\//.test(text)) {
+        errors.push("client bundle \u7591\u4F3C\u5185\u5D4C pactor \u8FD0\u884C\u65F6\u4EE3\u7801\uFF08@pactor-app/* \u5FC5\u987B\u4FDD\u6301 external\uFF09");
+      }
+      const sizeKb = Math.round((0, import_node_fs9.statSync)(clientFile).size / 1024);
+      if (sizeKb > 512) {
+        warnings.push(`client bundle \u4F53\u79EF\u8F83\u5927\uFF08${sizeKb}KB\uFF09\uFF0C\u8BF7\u786E\u8BA4 react / pactor \u5DF2 external`);
+      }
+    }
+  }
+  const hasServerEntry = typeof manifest.serverEntry === "string";
+  const hasApiPrefixes = Array.isArray(manifest.apiPrefixes);
+  if (hasServerEntry !== hasApiPrefixes) {
+    errors.push("manifest.serverEntry \u4E0E apiPrefixes \u5FC5\u987B\u6210\u5BF9\u51FA\u73B0");
+  }
+  if (hasServerEntry) {
+    const serverRel = manifest.serverEntry;
+    const serverFile = (0, import_node_path9.resolve)(moduleDir, serverRel);
+    if (!isInsideDir(moduleDir, serverFile)) {
+      errors.push(`server bundle \u8DEF\u5F84\u8D8A\u754C: ${serverRel}`);
+    } else if (!(0, import_node_fs9.existsSync)(serverFile)) {
+      errors.push(`server bundle \u4E0D\u5B58\u5728: ${serverRel}`);
+    } else {
+      const text = (0, import_node_fs9.readFileSync)(serverFile, "utf8");
+      if (/node_modules\/(?:next|react|react-dom|@pactor-app|pactor-app)\//.test(text)) {
+        warnings.push(
+          "server bundle \u7591\u4F3C\u5185\u5D4C next / react / pactor\uFF08\u5E94\u4FDD\u6301 external\uFF0C\u7531\u5BBF\u4E3B\u63D0\u4F9B\uFF09"
+        );
+      }
+    }
+    if (!Array.isArray(manifest.apiPrefixes) || manifest.apiPrefixes.length === 0) {
+      errors.push("manifest.apiPrefixes \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+    } else if (manifest.apiPrefixes.some((prefix) => typeof prefix !== "string")) {
+      errors.push("manifest.apiPrefixes \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4");
+    }
+  }
+  const pkgFile = (0, import_node_path9.join)(projectDir, "package.json");
+  if ((0, import_node_fs9.existsSync)(pkgFile)) {
+    try {
+      const pkg = JSON.parse((0, import_node_fs9.readFileSync)(pkgFile, "utf8"));
+      const exportsMap = pkg.exports ?? {};
+      if (exportsMap["./manifest"] === void 0) {
+        errors.push('package.json exports \u7F3A\u5C11 "./manifest"\uFF08Shell \u88C5\u914D\u5668\u7ECF require.resolve("<pkg>/manifest") \u5B9A\u4F4D\uFF09');
+      }
+      if (typeof manifest.clientEntry === "string" && exportsMap["./client"] === void 0) {
+        errors.push('package.json exports \u7F3A\u5C11 "./client"\uFF08client-registry \u9759\u6001 import "<pkg>/client"\uFF09');
+      }
+      if (typeof manifest.serverEntry === "string" && exportsMap["./server"] === void 0) {
+        errors.push('package.json exports \u7F3A\u5C11 "./server"\uFF08Shell \u88C5\u914D\u5668\u7ECF require.resolve("<pkg>/server") \u5B9A\u4F4D\uFF09');
+      }
+      if (typeof pkg.version === "string" && typeof manifest.version === "string" && pkg.version !== manifest.version) {
+        warnings.push(
+          `manifest.version (${manifest.version}) \u4E0E package.json version (${pkg.version}) \u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0 build`
+        );
+      }
+    } catch {
+      warnings.push("package.json \u89E3\u6790\u5931\u8D25\uFF0C\u8DF3\u8FC7 exports \u68C0\u67E5");
+    }
+  } else {
+    warnings.push("\u672A\u627E\u5230 package.json\uFF0C\u8DF3\u8FC7 exports \u68C0\u67E5");
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function isInsideDir(dir, file) {
+  const root = (0, import_node_path9.resolve)(dir);
+  return file.startsWith(`${root}${import_node_path9.sep}`);
+}
+function findPageDslFile(dslRootDir, pageId) {
+  if (!(0, import_node_fs9.existsSync)(dslRootDir)) return null;
+  const queue = [dslRootDir];
+  while (queue.length > 0) {
+    const dir = queue.pop();
+    for (const entry of (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true })) {
+      const full = (0, import_node_path9.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(full);
+        continue;
+      }
+      if (entry.name === `${pageId}.yaml`) return full;
+    }
+  }
+  return null;
+}
+function listFiles(dir) {
+  if (!(0, import_node_fs9.existsSync)(dir)) return [];
+  const files = [];
+  const walk = (target) => {
+    for (const entry of (0, import_node_fs9.readdirSync)(target, { withFileTypes: true })) {
+      const full = (0, import_node_path9.join)(target, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        files.push(full);
+      }
+    }
+  };
+  walk(dir);
+  return files;
+}
+
+// src/build.ts
+var ModuleBuildError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+  }
+};
+function buildModule(options = {}) {
+  const projectDir = (0, import_node_path10.resolve)(options.dir ?? process.cwd());
+  const config = loadModuleConfig(projectDir, options.config);
+  const profile = getProfile(config.target);
+  if (profile.forbidRootBasePath && config.basePath === "/") {
+    throw new ModuleBuildError(
+      `target ${config.target} \u7981\u6B62 basePath: "/"\uFF08Shell joinPublicPath \u4F1A\u4EA7\u751F "//login" \u8FD9\u7C7B\u574F\u8DEF\u5F84\uFF09`,
+      [`basePath: "/" \u4E0E profile ${config.target} \u7684 forbidRootBasePath \u51B2\u7A81\uFF0C\u8BF7\u6539\u7528\u5982 /${config.id} \u7684\u524D\u7F00`]
+    );
+  }
+  if (config.serverEntry !== void 0 && !profile.moduleServerApi) {
+    throw new ModuleBuildError(
+      `target ${config.target} \u4E0D\u652F\u6301\u6A21\u5757 server entry\uFF08\u9700\u8981 innospots-web-shell@3\uFF09`,
+      [
+        `\u914D\u7F6E\u4E86 serverEntry / apiPrefixes\uFF0C\u4F46 profile ${config.target} \u7684 moduleServerApi=false`,
+        '\u8BF7\u628A pactor.module.json \u7684 target \u5347\u5230 "innospots-web-shell@3" \u540E\u91CD\u65B0\u6784\u5EFA'
+      ]
+    );
+  }
+  const yamlRoot = (0, import_node_path10.join)(projectDir, config.yamlRoot);
+  if (!(0, import_node_fs10.existsSync)(yamlRoot)) {
+    throw new ModuleBuildError(`yamlRoot \u4E0D\u5B58\u5728: ${config.yamlRoot}`, [
+      `yamlRoot \u4E0D\u5B58\u5728: ${yamlRoot}`
+    ]);
+  }
+  const warnings = [];
+  const collected = collectModuleSource(yamlRoot);
+  warnings.push(...collected.warnings);
+  let site;
+  try {
+    site = loadYamlExpanded(yamlRoot, "sitemap.yaml");
+  } catch (error) {
+    const message = `sitemap \u5C55\u5F00\u5931\u8D25: ${error.message}`;
+    throw new ModuleBuildError(message, [message]);
+  }
+  const sitePages = Array.isArray(site.pages) ? site.pages : [];
+  const errors = [];
+  const pageDsls = /* @__PURE__ */ new Map();
+  for (const page of sitePages) {
+    const id = page.id;
+    if (typeof id !== "string") {
+      errors.push("sitemap.pages \u5B58\u5728\u7F3A\u5C11 id \u7684\u9875\u9762\u9879");
+      continue;
+    }
+    const rel = collected.pages.get(id);
+    if (rel === void 0) {
+      errors.push(`\u9875\u9762 DSL \u7F3A\u5931: ${id}\uFF08${config.yamlRoot} \u4E0B\u672A\u627E\u5230 ${id}.yaml / ${id}.page.yaml\uFF09`);
+      continue;
+    }
+    try {
+      pageDsls.set(id, loadYamlExpanded(yamlRoot, rel));
+    } catch (error) {
+      errors.push(`\u9875\u9762 ${id} \u5C55\u5F00\u5931\u8D25: ${error.message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new ModuleBuildError(`\u6A21\u5757\u6784\u5EFA\u5931\u8D25\uFF08${errors.length} \u4E2A\u9519\u8BEF\uFF09`, errors);
+  }
+  const transformed = transformSitemap(site, {
+    profile,
+    accessDefault: config.access.default,
+    loadLayout: (rel) => loadYamlExpanded(yamlRoot, rel)
+  });
+  const version = readProjectVersion(projectDir);
+  const siteAuth = site.auth !== null && typeof site.auth === "object" && !Array.isArray(site.auth) ? site.auth : {};
+  const rewriteCtx = {
+    basePath: config.basePath,
+    pagePaths: sitePages.map((page) => page.path).filter((path) => typeof path === "string"),
+    loginPath: typeof siteAuth.loginPath === "string" ? siteAuth.loginPath : "/login",
+    publicDir: (0, import_node_path10.join)(projectDir, config.publicDir),
+    rewriteNavigation: profile.rewriteNavigation.basePath,
+    rewriteAssets: true,
+    assetPrefix: profile.rewriteAssetUrls(config.id, version).replace(/\/+$/, ""),
+    absoluteApiToRelative: config.rewrite.absoluteApiToRelative,
+    moduleId: config.id,
+    apiPrefixes: config.apiPrefixes
+  };
+  const sitemapRewrite = rewriteDslUrls(transformed.site, rewriteCtx);
+  warnings.push(...sitemapRewrite.warnings);
+  const rewrittenPages = /* @__PURE__ */ new Map();
+  for (const [id, dsl] of pageDsls) {
+    const result = rewriteDslUrls(dsl, rewriteCtx);
+    warnings.push(...result.warnings.map((warning) => `${id}: ${warning}`));
+    rewrittenPages.set(id, result.value);
+  }
+  const outDir = (0, import_node_path10.join)(projectDir, config.outDir);
+  const temp = (0, import_node_fs10.mkdtempSync)((0, import_node_path10.join)(projectDir, ".module-pack-"));
+  try {
+    const bundle = bundleClient({
+      projectDir,
+      clientEntry: config.clientEntry,
+      outDir: (0, import_node_path10.join)(temp, "client")
+    });
+    if (bundle.message !== void 0) {
+      warnings.push(bundle.message);
+    }
+    const server = config.serverEntry ? bundleServer({
+      projectDir,
+      serverEntry: config.serverEntry,
+      outDir: (0, import_node_path10.join)(temp, "server")
+    }) : void 0;
+    const emitted = emitDsl({
+      config,
+      projectDir,
+      outDir: temp,
+      site: sitemapRewrite.value,
+      pages: rewrittenPages
+    });
+    if (bundle.bundled && config.tailwind.enabled) {
+      const tailwind = compileTailwind({
+        projectDir,
+        tailwind: config.tailwind,
+        scanDirs: [(0, import_node_path10.join)(temp, "dsl"), (0, import_node_path10.dirname)((0, import_node_path10.join)(projectDir, config.clientEntry))],
+        cssFile: (0, import_node_path10.join)(temp, "client", "index.css")
+      });
+      warnings.push(...tailwind.warnings);
+    }
+    const hasCss = (0, import_node_fs10.existsSync)((0, import_node_path10.join)(temp, "client", "index.css"));
+    writeManifest({
+      config,
+      projectDir,
+      outDir: temp,
+      clientEntry: bundle.bundled ? "client/index.js" : void 0,
+      styles: bundle.bundled && hasCss ? ["client/index.css"] : void 0,
+      serverEntry: server ? "server/index.mjs" : void 0,
+      apiPrefixes: server ? config.apiPrefixes : void 0,
+      warnings
+    });
+    const validation = validateModule({ dir: projectDir, config: options.config, moduleDir: temp });
+    warnings.push(...validation.warnings);
+    if (!validation.ok) {
+      throw new ModuleBuildError(
+        `\u4EA7\u7269\u6821\u9A8C\u5931\u8D25\uFF08${validation.errors.length} \u4E2A\u9519\u8BEF\uFF09`,
+        validation.errors
+      );
+    }
+    (0, import_node_fs10.rmSync)(outDir, { recursive: true, force: true });
+    (0, import_node_fs10.mkdirSync)((0, import_node_path10.dirname)(outDir), { recursive: true });
+    (0, import_node_fs10.renameSync)(temp, outDir);
+    return {
+      outDir,
+      stats: {
+        pages: transformed.pageCount,
+        menus: transformed.menuCount,
+        layouts: transformed.layoutCount,
+        assets: emitted.assetCount
+      },
+      clientBundled: bundle.bundled,
+      serverBundled: server !== void 0,
+      warnings
+    };
+  } catch (error) {
+    (0, import_node_fs10.rmSync)(temp, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/init.ts
+var import_node_fs11 = require("fs");
+var import_node_path11 = require("path");
+var CLIENT_STYLES_ENTRY = "module/module.css";
+var SERVER_ENTRY = "module/server.ts";
+function initModule(options = {}) {
+  const projectDir = (0, import_node_path11.resolve)(options.dir ?? process.cwd());
+  const overwrite = options.overwrite ?? false;
+  const server = options.server ?? false;
+  const result = { created: [], overwritten: [], skipped: [], warnings: [] };
+  const pkgFile = (0, import_node_path11.join)(projectDir, "package.json");
+  if (!(0, import_node_fs11.existsSync)(pkgFile)) {
+    throw new Error(`\u672A\u627E\u5230 package.json: ${projectDir}\uFF08\u8BF7\u5728\u76EE\u6807\u5DE5\u7A0B\u6839\u6267\u884C\uFF09`);
+  }
+  const pkg = JSON.parse((0, import_node_fs11.readFileSync)(pkgFile, "utf8"));
+  const id = deriveModuleId(pkg.name);
+  const actions = discoverActions(projectDir);
+  const hasComponents = discoverComponents(projectDir);
+  const configFile = (0, import_node_path11.join)(projectDir, CONFIG_FILE);
+  const renderConfig = () => ({
+    id,
+    name: typeof pkg.name === "string" ? pkg.name : id,
+    basePath: `/${id}`,
+    yamlRoot: CONFIG_DEFAULTS.yamlRoot,
+    clientEntry: CONFIG_DEFAULTS.clientEntry,
+    // 只有显式 --server 才写入，避免纯 DSL 模块被迫启用 server entry
+    ...server ? { serverEntry: SERVER_ENTRY, apiPrefixes: [deriveApiPrefix(id)] } : {},
+    actions: actions.map((action) => action.specifier.replace(/^\.\.\//, "")),
+    publicDir: CONFIG_DEFAULTS.publicDir,
+    target: DEFAULT_TARGET
+  });
+  const configExisted = (0, import_node_fs11.existsSync)(configFile);
+  if (configExisted && !overwrite) {
+    result.skipped.push(`${CONFIG_FILE}\uFF08\u5DF2\u5B58\u5728\uFF09`);
+  } else {
+    (0, import_node_fs11.writeFileSync)(configFile, `${JSON.stringify(renderConfig(), null, 2)}
+`, "utf8");
+    if (configExisted) {
+      result.overwritten.push(CONFIG_FILE);
+    } else {
+      result.created.push(CONFIG_FILE);
+    }
+  }
+  const clientFile = (0, import_node_path11.join)(projectDir, CONFIG_DEFAULTS.clientEntry);
+  if ((0, import_node_fs11.existsSync)(clientFile) && !overwrite) {
+    result.skipped.push(`${CONFIG_DEFAULTS.clientEntry}\uFF08\u5DF2\u5B58\u5728\uFF09`);
+  } else {
+    const clientExisted = (0, import_node_fs11.existsSync)(clientFile);
+    (0, import_node_fs11.mkdirSync)((0, import_node_path11.dirname)(clientFile), { recursive: true });
+    (0, import_node_fs11.writeFileSync)(clientFile, renderClientEntry(hasComponents, actions), "utf8");
+    if (clientExisted) {
+      result.overwritten.push(CONFIG_DEFAULTS.clientEntry);
+    } else {
+      result.created.push(CONFIG_DEFAULTS.clientEntry);
+    }
+  }
+  const stylesFile = (0, import_node_path11.join)(projectDir, CLIENT_STYLES_ENTRY);
+  if ((0, import_node_fs11.existsSync)(stylesFile) && !overwrite) {
+    result.skipped.push(`${CLIENT_STYLES_ENTRY}\uFF08\u5DF2\u5B58\u5728\uFF09`);
+  } else {
+    const stylesExisted = (0, import_node_fs11.existsSync)(stylesFile);
+    (0, import_node_fs11.mkdirSync)((0, import_node_path11.dirname)(stylesFile), { recursive: true });
+    (0, import_node_fs11.writeFileSync)(stylesFile, renderModuleStyles(), "utf8");
+    if (stylesExisted) {
+      result.overwritten.push(CLIENT_STYLES_ENTRY);
+    } else {
+      result.created.push(CLIENT_STYLES_ENTRY);
+    }
+  }
+  if (server) {
+    const serverFile = (0, import_node_path11.join)(projectDir, SERVER_ENTRY);
+    if ((0, import_node_fs11.existsSync)(serverFile) && !overwrite) {
+      result.skipped.push(`${SERVER_ENTRY}\uFF08\u5DF2\u5B58\u5728\uFF09`);
+    } else {
+      const serverExisted = (0, import_node_fs11.existsSync)(serverFile);
+      (0, import_node_fs11.mkdirSync)((0, import_node_path11.dirname)(serverFile), { recursive: true });
+      (0, import_node_fs11.writeFileSync)(serverFile, renderServerEntry(id), "utf8");
+      if (serverExisted) {
+        result.overwritten.push(SERVER_ENTRY);
+      } else {
+        result.created.push(SERVER_ENTRY);
+      }
+    }
+  }
+  const hasServerEntry = (0, import_node_fs11.existsSync)((0, import_node_path11.join)(projectDir, SERVER_ENTRY));
+  injectPackageJson(pkg, result, hasServerEntry);
+  if (hasServerEntry && !configDeclaresServerEntry(configFile)) {
+    result.warnings.push(
+      '\u68C0\u6D4B\u5230 module/server.ts\uFF1A\u5DF2\u6CE8\u5165 "./server" export\uFF1B\u8BF7\u5728 pactor.module.json \u4E2D\u540C\u65F6\u914D\u7F6E serverEntry \u4E0E apiPrefixes \u540E\u518D\u6784\u5EFA\uFF08\u7F3A\u4E00\u6784\u5EFA\u4F1A\u5931\u8D25\uFF09'
+    );
+  }
+  (0, import_node_fs11.writeFileSync)(pkgFile, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  result.created.push("package.json\uFF08\u6CE8\u5165 files / exports / scripts / peerDependencies\uFF09");
+  return result;
+}
+function configDeclaresServerEntry(configFile) {
+  if (!(0, import_node_fs11.existsSync)(configFile)) return false;
+  try {
+    const raw = JSON.parse((0, import_node_fs11.readFileSync)(configFile, "utf8"));
+    return raw.serverEntry === SERVER_ENTRY;
+  } catch {
+    return false;
+  }
+}
+var MODULE_ID_PREFIX = "pactor-app-";
+function deriveModuleId(name) {
+  const base2 = typeof name === "string" && name.length > 0 ? name : "module";
+  const withoutScope = base2.startsWith("@") ? base2.slice(base2.indexOf("/") + 1) : base2;
+  const kebab = withoutScope.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const id = kebab.length > 0 ? kebab : "module";
+  return id.startsWith(MODULE_ID_PREFIX) ? id : `${MODULE_ID_PREFIX}${id}`;
+}
+function deriveApiPrefix(moduleId) {
+  const slug = moduleId.startsWith(MODULE_ID_PREFIX) ? moduleId.slice(MODULE_ID_PREFIX.length) : moduleId;
+  return `/api/${slug.length > 0 ? slug : "module"}`;
+}
+function discoverActions(projectDir) {
+  const dir = (0, import_node_path11.join)(projectDir, "src/pactor");
+  if (!(0, import_node_fs11.existsSync)(dir)) return [];
+  const sources = [];
+  for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true }).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (!entry.isFile() || !entry.name.endsWith("-actions.ts")) continue;
+    const file = (0, import_node_path11.join)(dir, entry.name);
+    const content = (0, import_node_fs11.readFileSync)(file, "utf8");
+    const exports2 = [...content.matchAll(/export\s+const\s+([A-Za-z_$][\w$]*)/g)].map(
+      (match) => match[1]
+    );
+    if (exports2.length === 0) continue;
+    sources.push({
+      specifier: `../src/pactor/${entry.name.replace(/\.ts$/, "")}`,
+      exports: exports2
+    });
+  }
+  return sources;
+}
+function discoverComponents(projectDir) {
+  const file = (0, import_node_path11.join)(projectDir, "src/pactor/components/index.ts");
+  if (!(0, import_node_fs11.existsSync)(file)) return false;
+  return /export\s+(const|\{[^}]*)\s*pactorComponents/.test((0, import_node_fs11.readFileSync)(file, "utf8"));
+}
+function renderClientEntry(hasComponents, actions) {
+  const imports = [];
+  const spreads = [];
+  if (hasComponents) {
+    imports.push("import { pactorComponents } from '../src/pactor/components';");
+  }
+  for (const action of actions) {
+    imports.push(
+      `import { ${action.exports.join(", ")} } from '${action.specifier}';`
+    );
+    spreads.push(...action.exports.map((name) => `...${name}`));
+  }
+  const components = hasComponents ? "pactorComponents" : "{}";
+  const actionsExpr = spreads.length > 0 ? `{ ${spreads.join(", ")} }` : "{}";
+  const importsBlock = imports.length > 0 ? `${imports.join("\n")}
+` : "";
+  return `// \u7531 \`pactor module init\` \u751F\u6210\uFF1A\u6A21\u5757 client \u5165\u53E3\u3002
+// Shell \u88C5\u914D\u5668\u751F\u6210 client-registry.ts \u65F6\u9759\u6001 import "<pkg>/client"\uFF0C
+// \u8981\u6C42\u6B64\u5904\u5177\u540D\u5BFC\u51FA extensions\uFF08components / actions \u6CE8\u518C\u8868\uFF09\u3002
+// module.css \u7531 esbuild \u62BD\u6210 client/index.css\uFF0CShell \u6309 manifest.styles \u52A0\u8F7D\u3002
+import './module.css';
+${importsBlock}
+export const extensions = {
+  components: ${components},
+  actions: ${actionsExpr},
+};
+`;
+}
+function renderModuleStyles() {
+  return `/**
+ * \u6A21\u5757\u81EA\u5E26\u6837\u5F0F\uFF08\u7531 \`pactor module init\` \u751F\u6210\uFF09\u3002
+ *
+ * \u672C\u6587\u4EF6\u7531 module/client.ts import\uFF1Aesbuild \u6253\u5305\u65F6\u4F1A\u62BD\u53D6\u4E3A
+ * dist-module/client/index.css \u5E76\u5199\u5165 manifest.styles\uFF0CShell \u636E\u6B64\u81EA\u52A8\u52A0\u8F7D\u3002
+ * Tailwind \u57FA\u7840\u6837\u5F0F\u3001pactor-app \u805A\u5408\u6837\u5F0F\u4E0E\u4E3B\u9898\u53D8\u91CF\u7531 Shell \u7EDF\u4E00\u63D0\u4F9B\uFF0C
+ * \u6A21\u5757\u5185\u4E0D\u8981\u91CD\u590D\u5F15\u5165\uFF0C\u907F\u514D\u4EA7\u751F\u7B2C\u4E8C\u4EFD reset / \u4EE4\u724C\u3002
+ */
+
+/* \u6A21\u5757\u7EA7\u6837\u5F0F\u5199\u5728\u8FD9\u91CC\uFF1A\u5EFA\u8BAE\u4F7F\u7528\u5E26\u6A21\u5757\u524D\u7F00\u7684\u7C7B\u540D\uFF0C\u907F\u514D\u4E0E Shell \u5168\u5C40\u6837\u5F0F\u51B2\u7A81\u3002 */
+`;
+}
+function renderServerEntry(moduleId) {
+  const prefix = deriveApiPrefix(moduleId);
+  return `// \u7531 \`pactor module init --server\` \u751F\u6210\uFF1A\u6A21\u5757\u670D\u52A1\u7AEF\u5165\u53E3\u3002
+// \u5BFC\u51FA\u300C\u903B\u8F91\u8DEF\u5F84 \u2192 \u65B9\u6CD5\u5904\u7406\u51FD\u6570\u300D\u6620\u5C04\uFF1A\u8DEF\u5F84\u952E\u4F7F\u7528\u539F\u59CB /api/... \u903B\u8F91\u8DEF\u5F84\uFF0C
+// Shell \u901A\u8FC7 /api/modules/<moduleId>/* \u7EDF\u4E00\u5206\u53D1\uFF08\u89C1 pactor.module.json \u7684 apiPrefixes\uFF09\u3002
+// handler \u53EA\u4F9D\u8D56 Web \u6807\u51C6 Request / Response\uFF0Ccontext.url \u4E3A\u903B\u8F91 URL\uFF08\u542B query\uFF09\u3002
+
+export const handlers = {
+  // '${prefix}/hello': {
+  //   GET: () => Response.json({ code: 0, data: { ok: true }, message: 'ok' }),
+  // },
+};
+`;
+}
+function injectPackageJson(pkg, result, hasServerEntry) {
+  const outDir = CONFIG_DEFAULTS.outDir;
+  const files = Array.isArray(pkg.files) ? pkg.files : [];
+  if (!files.includes(outDir)) {
+    pkg.files = [...files, outDir];
+  }
+  const exportsMap = isRecord4(pkg.exports) ? { ...pkg.exports } : {};
+  const wantedExports = {
+    "./manifest": `./${outDir}/manifest.json`,
+    "./client": `./${outDir}/client/index.js`,
+    "./styles.css": `./${outDir}/client/index.css`,
+    ...hasServerEntry ? { "./server": `./${outDir}/server/index.mjs` } : {}
+  };
+  for (const [key, value] of Object.entries(wantedExports)) {
+    if (exportsMap[key] === void 0) {
+      exportsMap[key] = value;
+    } else if (exportsMap[key] !== value) {
+      result.warnings.push(`package.json exports["${key}"] \u5DF2\u5B58\u5728\u4E14\u4E0E\u5EFA\u8BAE\u503C\u4E0D\u540C\uFF0C\u672A\u8986\u76D6\uFF08\u5F53\u524D: ${JSON.stringify(exportsMap[key])}\uFF09`);
+    }
+  }
+  pkg.exports = exportsMap;
+  const scripts = isRecord4(pkg.scripts) ? { ...pkg.scripts } : {};
+  const wantedScripts = {
+    "build:module": "pactor module build",
+    "pack:module": "pactor module pack",
+    "publish:module": "pactor module publish"
+  };
+  for (const [key, value] of Object.entries(wantedScripts)) {
+    if (scripts[key] === void 0) {
+      scripts[key] = value;
+    } else if (scripts[key] !== value) {
+      result.warnings.push(`package.json scripts["${key}"] \u5DF2\u5B58\u5728\uFF0C\u672A\u8986\u76D6\uFF08\u5F53\u524D: ${JSON.stringify(scripts[key])}\uFF09`);
+    }
+  }
+  pkg.scripts = scripts;
+  const peers = isRecord4(pkg.peerDependencies) ? { ...pkg.peerDependencies } : {};
+  const dependencies = isRecord4(pkg.dependencies) ? pkg.dependencies : {};
+  const defaults = {
+    react: "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0",
+    next: "^14.0.0 || ^15.0.0",
+    "pactor-app": "^1.54.0"
+  };
+  for (const [name, fallback] of Object.entries(defaults)) {
+    if (peers[name] !== void 0) continue;
+    const declared = dependencies[name];
+    peers[name] = typeof declared === "string" && declared.length > 0 ? declared : fallback;
+  }
+  pkg.peerDependencies = peers;
+}
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/version.ts
+var import_node_fs12 = require("fs");
+var import_node_path12 = require("path");
+var SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?$/;
+function bumpVersion(current, release) {
+  if (release === "major" || release === "minor" || release === "patch") {
+    const match = SEMVER_RE.exec(current);
+    if (!match) {
+      throw new ConfigError(`package.json \u7248\u672C\u53F7\u975E\u6CD5: ${current}\uFF08\u671F\u671B x.y.z\uFF09`);
+    }
+    const [, major, minor, patch] = match;
+    if (release === "major") return `${Number(major) + 1}.0.0`;
+    if (release === "minor") return `${major}.${Number(minor) + 1}.0`;
+    return `${major}.${minor}.${Number(patch) + 1}`;
+  }
+  if (!SEMVER_RE.test(release)) {
+    throw new ConfigError(
+      `--bump \u53D6\u503C\u975E\u6CD5: ${release}\uFF08\u652F\u6301 patch | minor | major | \u663E\u5F0F\u7248\u672C\u53F7 x.y.z\uFF09`
+    );
+  }
+  return release;
+}
+function bumpPackageVersion(options) {
+  const dir = (0, import_node_path12.resolve)(options.dir ?? process.cwd());
+  const pkgFile = (0, import_node_path12.resolve)(dir, "package.json");
+  if (!(0, import_node_fs12.existsSync)(pkgFile)) {
+    throw new ConfigError(`\u672A\u627E\u5230 package.json: ${dir}\uFF08\u8BF7\u5728\u76EE\u6807\u5DE5\u7A0B\u6839\u6267\u884C\uFF09`);
+  }
+  const pkg = JSON.parse((0, import_node_fs12.readFileSync)(pkgFile, "utf8"));
+  const name = typeof pkg.name === "string" ? pkg.name : "(\u672A\u547D\u540D)";
+  if (typeof pkg.version !== "string" || pkg.version === "") {
+    throw new ConfigError(`package.json \u7F3A\u5C11 version \u5B57\u6BB5: ${pkgFile}`);
+  }
+  const from = pkg.version;
+  const to = bumpVersion(from, options.release);
+  pkg.version = to;
+  (0, import_node_fs12.writeFileSync)(pkgFile, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  return { name, from, to };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLIENT_EXTERNALS,
+  CLIENT_STYLES_ENTRY,
+  CONFIG_DEFAULTS,
+  CONFIG_FILE,
+  ConfigError,
+  DEFAULT_TARGET,
+  INCLUDE_KEY,
+  IncludeError,
+  MODULE_ID_PREFIX,
+  ModuleBuildError,
+  ProfileError,
+  SERVER_BUNDLE_FILE,
+  SERVER_ENTRY,
+  SERVER_EXTERNALS,
+  ServerBundleError,
+  buildModule,
+  bumpPackageVersion,
+  bumpVersion,
+  bundleClient,
+  bundleServer,
+  collectModuleSource,
+  compileTailwind,
+  deriveApiPrefix,
+  deriveModuleId,
+  discoverActions,
+  discoverComponents,
+  emitDsl,
+  emitModule,
+  expandIncludes,
+  getProfile,
+  initModule,
+  innospotsWebShellV1,
+  innospotsWebShellV2,
+  innospotsWebShellV3,
+  listProfiles,
+  loadModuleConfig,
+  loadYamlExpanded,
+  matchPathPattern,
+  parseJsonc,
+  parseYamlFile,
+  readProjectVersion,
+  renderClientEntry,
+  renderModuleStyles,
+  renderServerEntry,
+  resolvePactorVersionRange,
+  rewriteDslUrls,
+  rewriteNavigationTo,
+  transformSitemap,
+  tsconfigAliases,
+  validateModule,
+  writeManifest
+});