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

package/dist/index.js

@@ -0,0 +1,1169 @@
+// src/build.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, renameSync, rmSync as rmSync2 } from "fs";
+import { dirname as dirname3, join as join9, resolve as resolve4 } from "path";
+
+// src/bundle-client.ts
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { buildSync } from "esbuild";
+var CLIENT_EXTERNALS = [
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "next",
+  "next/*",
+  "pactor-app",
+  "pactor-app/*",
+  "@pactor-app/*"
+];
+function bundleClient(options) {
+  const entry = join(options.projectDir, options.clientEntry);
+  if (!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`
+    };
+  }
+  mkdirSync(options.outDir, { recursive: true });
+  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: existsSync(join(options.outDir, "index.css"))
+  };
+}
+function tsconfigAliases(projectDir) {
+  const file = join(projectDir, "tsconfig.json");
+  if (!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] = resolve(dirname(file), baseUrl, rel);
+  }
+  return alias;
+}
+function readTsconfig(file, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(file) || !existsSync(file)) return {};
+  seen.add(file);
+  let raw;
+  try {
+    raw = parseJsonc(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+  let base2 = {};
+  if (typeof raw.extends === "string" && raw.extends.startsWith(".")) {
+    base2 = readTsconfig(resolve(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/collect.ts
+import { readdirSync } from "fs";
+import { join as join2, relative } from "path";
+function collectModuleSource(yamlRoot) {
+  const pages = /* @__PURE__ */ new Map();
+  const layouts = [];
+  const fragments = [];
+  const warnings = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.name.endsWith(".yaml") || entry.name === "sitemap.yaml") {
+        continue;
+      }
+      const rel = 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
+import { execFileSync } from "child_process";
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+function compileTailwind(options) {
+  const warnings = [];
+  if (!options.tailwind.enabled) {
+    return { compiled: false, warnings };
+  }
+  const work = mkdtempSync(join3(tmpdir(), "pactor-tailwind-"));
+  try {
+    let input;
+    if (options.tailwind.input !== void 0) {
+      input = join3(options.projectDir, options.tailwind.input);
+      if (!existsSync2(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 = join3(work, "input.css");
+      writeFileSync(input, `@import "tailwindcss";
+${scan.join("\n")}
+`, "utf8");
+    }
+    const out = join3(work, "tailwind.css");
+    execFileSync(
+      "npx",
+      ["--no-install", "tailwindcss", "--input", input, "--output", out],
+      { cwd: options.projectDir, stdio: "pipe" }
+    );
+    if (existsSync2(out)) {
+      const css = readFileSync2(out, "utf8");
+      if (css.trim().length > 0) {
+        mkdirSync2(dirname2(options.cssFile), { recursive: true });
+        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 {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+// src/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join4, resolve as resolve2 } from "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
+};
+var innospotsWebShellV1 = {
+  ...base,
+  version: 1,
+  forceInlinePages: true
+};
+var innospotsWebShellV2 = {
+  ...base,
+  version: 2,
+  forceInlinePages: false
+};
+
+// src/profiles/index.ts
+var ProfileError = class extends Error {
+};
+var registry = /* @__PURE__ */ new Map([
+  [`${innospotsWebShellV1.name}@${innospotsWebShellV1.version}`, innospotsWebShellV1],
+  [`${innospotsWebShellV2.name}@${innospotsWebShellV2.version}`, innospotsWebShellV2]
+]);
+var DEFAULT_TARGET = `${innospotsWebShellV2.name}@${innospotsWebShellV2.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 ? resolve2(projectDir, configPath) : join4(projectDir, CONFIG_FILE);
+  if (!existsSync3(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(readFileSync3(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);
+  const demo = isRecord(raw.demo) ? raw.demo : {};
+  const tailwind = isRecord(raw.tailwind) ? raw.tailwind : {};
+  const rewrite = isRecord(raw.rewrite) ? raw.rewrite : {};
+  return {
+    id,
+    name,
+    basePath,
+    yamlRoot: readString(raw, "yamlRoot", file) ?? CONFIG_DEFAULTS.yamlRoot,
+    clientEntry: readString(raw, "clientEntry", file) ?? CONFIG_DEFAULTS.clientEntry,
+    actions,
+    publicDir: readString(raw, "publicDir", file) ?? CONFIG_DEFAULTS.publicDir,
+    target: readString(raw, "target", file) ?? CONFIG_DEFAULTS.target,
+    demo: { public: readBoolean(demo, "public", file, "demo") ?? false },
+    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;
+}
+
+// src/emit-manifest.ts
+import { createHash } from "crypto";
+import {
+  cpSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { createRequire } from "module";
+import { join as join5 } from "path";
+import { stringify } from "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 = join5(outDir, "dsl");
+  mkdirSync3(dslDir, { recursive: true });
+  writeFileSync2(join5(dslDir, "sitemap.yaml"), stringify(site, { lineWidth: 0 }), "utf8");
+  for (const [id, dsl] of pages) {
+    writeFileSync2(join5(dslDir, `${id}.yaml`), stringify(dsl, { lineWidth: 0 }), "utf8");
+  }
+  const publicDir = join5(projectDir, config.publicDir);
+  const assetsDir = join5(outDir, "assets");
+  if (existsSync4(publicDir)) {
+    cpSync(publicDir, assetsDir, { recursive: true });
+  } else {
+    mkdirSync3(assetsDir, { recursive: true });
+  }
+  const assets = hashAssets(assetsDir, assetsDir);
+  writeFileSync2(
+    join5(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 } : {}
+  };
+  writeFileSync2(
+    join5(outDir, "manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  return manifest;
+}
+function readProjectVersion(projectDir) {
+  const pkgFile = join5(projectDir, "package.json");
+  if (!existsSync4(pkgFile)) return "0.0.0";
+  try {
+    const pkg = JSON.parse(readFileSync4(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 = createRequire(join5(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(readFileSync4(pkgFile, "utf8"));
+        if (typeof pkg2.version === "string" && pkg2.version.length > 0) {
+          return `^${pkg2.version}`;
+        }
+      } catch {
+      }
+    }
+    const pkg = JSON.parse(readFileSync4(join5(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 (!existsSync4(dir)) return entries;
+  for (const entry of readdirSync2(dir, { withFileTypes: true }).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    const full = join5(dir, entry.name);
+    if (entry.isDirectory()) {
+      entries.push(...hashAssets(full, root));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const content = readFileSync4(full);
+    entries.push({
+      path: full.slice(root.length + 1).split("\\").join("/"),
+      sha256: createHash("sha256").update(content).digest("hex"),
+      size: statSync(full).size
+    });
+  }
+  return entries;
+}
+
+// src/expand-include.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
+import { parseDocument } from "yaml";
+var INCLUDE_KEY = "$include";
+var IncludeError = class extends Error {
+};
+function parseYamlFile(file) {
+  const doc = parseDocument(readFileSync5(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(join6(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
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { join as join7 } from "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) {
+    warnings.push(
+      `\u7EDD\u5BF9 API \u5730\u5740: ${value}${ctx.absoluteApiToRelative ? "\uFF08\u5DF2\u91CD\u5199\u4E3A\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u9700\u5E95\u5EA7 BFF/\u4EE3\u7406\u627F\u63A5\uFF09" : ""}`
+    );
+    return ctx.absoluteApiToRelative ? absoluteApi[1] : value;
+  }
+  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 isPublicFile(publicDir, urlPath) {
+  const file = join7(publicDir, urlPath);
+  try {
+    return existsSync5(file) && statSync2(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, demoPublic, loadLayout } = options;
+  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 (demoPublic) {
+      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 (demoPublic) {
+      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);
+}
+
+// src/validate.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { join as join8, relative as relative2, resolve as resolve3 } from "path";
+import { parseDocument as parseDocument2 } from "yaml";
+var REQUIRED_MANIFEST_FIELDS = [
+  "schemaVersion",
+  "id",
+  "name",
+  "version",
+  "pactorVersionRange",
+  "basePath",
+  "sitemap",
+  "dslRoot",
+  "assetsRoot"
+];
+function validateModule(options = {}) {
+  const projectDir = resolve3(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 ?? join8(projectDir, config?.outDir ?? CONFIG_DEFAULTS.outDir);
+  const manifestFile = join8(moduleDir, "manifest.json");
+  if (!existsSync6(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(readFileSync6(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 = join8(moduleDir, sitemapRel);
+  if (!existsSync6(sitemapFile)) {
+    errors.push(`sitemap \u4E0D\u5B58\u5728: ${sitemapRel}`);
+  } else {
+    const doc = parseDocument2(readFileSync6(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(join8(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 = join8(moduleDir, dslRoot);
+  for (const file of listFiles(dslDir)) {
+    if (readFileSync6(file, "utf8").includes(INCLUDE_KEY)) {
+      errors.push(`$include \u6B8B\u7559: ${relative2(moduleDir, file)}`);
+    }
+  }
+  if (typeof manifest.clientEntry === "string") {
+    const clientFile = join8(moduleDir, manifest.clientEntry);
+    if (!existsSync6(clientFile)) {
+      errors.push(`client bundle \u4E0D\u5B58\u5728: ${manifest.clientEntry}`);
+    } else {
+      const text = readFileSync6(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(statSync3(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 pkgFile = join8(projectDir, "package.json");
+  if (existsSync6(pkgFile)) {
+    try {
+      const pkg = JSON.parse(readFileSync6(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 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 findPageDslFile(dslRootDir, pageId) {
+  if (!existsSync6(dslRootDir)) return null;
+  const queue = [dslRootDir];
+  while (queue.length > 0) {
+    const dir = queue.pop();
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const full = join8(dir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(full);
+        continue;
+      }
+      if (entry.name === `${pageId}.yaml`) return full;
+    }
+  }
+  return null;
+}
+function listFiles(dir) {
+  if (!existsSync6(dir)) return [];
+  const files = [];
+  const walk = (target) => {
+    for (const entry of readdirSync3(target, { withFileTypes: true })) {
+      const full = join8(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 = resolve4(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`]
+    );
+  }
+  const yamlRoot = join9(projectDir, config.yamlRoot);
+  if (!existsSync7(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,
+    demoPublic: config.demo.public,
+    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: join9(projectDir, config.publicDir),
+    rewriteNavigation: profile.rewriteNavigation.basePath,
+    rewriteAssets: true,
+    assetPrefix: profile.rewriteAssetUrls(config.id, version).replace(/\/+$/, ""),
+    absoluteApiToRelative: config.rewrite.absoluteApiToRelative
+  };
+  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 = join9(projectDir, config.outDir);
+  const temp = mkdtempSync2(join9(projectDir, ".module-pack-"));
+  try {
+    const bundle = bundleClient({
+      projectDir,
+      clientEntry: config.clientEntry,
+      outDir: join9(temp, "client")
+    });
+    if (bundle.message !== void 0) {
+      warnings.push(bundle.message);
+    }
+    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: [join9(temp, "dsl"), dirname3(join9(projectDir, config.clientEntry))],
+        cssFile: join9(temp, "client", "index.css")
+      });
+      warnings.push(...tailwind.warnings);
+    }
+    const hasCss = existsSync7(join9(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,
+      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
+      );
+    }
+    rmSync2(outDir, { recursive: true, force: true });
+    mkdirSync4(dirname3(outDir), { recursive: true });
+    renameSync(temp, outDir);
+    return {
+      outDir,
+      stats: {
+        pages: transformed.pageCount,
+        menus: transformed.menuCount,
+        layouts: transformed.layoutCount,
+        assets: emitted.assetCount
+      },
+      clientBundled: bundle.bundled,
+      warnings
+    };
+  } catch (error) {
+    rmSync2(temp, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/init.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10, resolve as resolve5 } from "path";
+function initModule(options = {}) {
+  const projectDir = resolve5(options.dir ?? process.cwd());
+  const result = { created: [], skipped: [], warnings: [] };
+  const pkgFile = join10(projectDir, "package.json");
+  if (!existsSync8(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(readFileSync7(pkgFile, "utf8"));
+  const id = deriveModuleId(pkg.name);
+  const actions = discoverActions(projectDir);
+  const hasComponents = discoverComponents(projectDir);
+  const configFile = join10(projectDir, CONFIG_FILE);
+  if (existsSync8(configFile)) {
+    result.skipped.push(`${CONFIG_FILE}\uFF08\u5DF2\u5B58\u5728\uFF09`);
+  } else {
+    const config = {
+      id,
+      name: typeof pkg.name === "string" ? pkg.name : id,
+      basePath: `/${id}`,
+      yamlRoot: CONFIG_DEFAULTS.yamlRoot,
+      clientEntry: CONFIG_DEFAULTS.clientEntry,
+      actions: actions.map((action) => action.specifier.replace(/^\.\.\//, "")),
+      publicDir: CONFIG_DEFAULTS.publicDir,
+      target: DEFAULT_TARGET,
+      demo: { public: false }
+    };
+    writeFileSync3(configFile, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    result.created.push(CONFIG_FILE);
+  }
+  const clientFile = join10(projectDir, CONFIG_DEFAULTS.clientEntry);
+  if (existsSync8(clientFile)) {
+    result.skipped.push(`${CONFIG_DEFAULTS.clientEntry}\uFF08\u5DF2\u5B58\u5728\uFF09`);
+  } else {
+    mkdirSync5(join10(projectDir, "module"), { recursive: true });
+    writeFileSync3(clientFile, renderClientEntry(hasComponents, actions), "utf8");
+    result.created.push(CONFIG_DEFAULTS.clientEntry);
+  }
+  injectPackageJson(pkg, result);
+  writeFileSync3(pkgFile, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  result.created.push("package.json\uFF08\u6CE8\u5165 files / exports / scripts / peerDependencies\uFF09");
+  return result;
+}
+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, "");
+  return kebab.length > 0 ? kebab : "module";
+}
+function discoverActions(projectDir) {
+  const dir = join10(projectDir, "src/pactor");
+  if (!existsSync8(dir)) return [];
+  const sources = [];
+  for (const entry of readdirSync4(dir, { withFileTypes: true }).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (!entry.isFile() || !entry.name.endsWith("-actions.ts")) continue;
+    const file = join10(dir, entry.name);
+    const content = readFileSync7(file, "utf8");
+    const exports = [...content.matchAll(/export\s+const\s+([A-Za-z_$][\w$]*)/g)].map(
+      (match) => match[1]
+    );
+    if (exports.length === 0) continue;
+    sources.push({
+      specifier: `../src/pactor/${entry.name.replace(/\.ts$/, "")}`,
+      exports
+    });
+  }
+  return sources;
+}
+function discoverComponents(projectDir) {
+  const file = join10(projectDir, "src/pactor/components/index.ts");
+  if (!existsSync8(file)) return false;
+  return /export\s+(const|\{[^}]*)\s*pactorComponents/.test(readFileSync7(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(", ")} }` : "{}";
+  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
+${imports.join("\n")}
+
+export const extensions = {
+  components: ${components},
+  actions: ${actionsExpr},
+};
+`;
+}
+function injectPackageJson(pkg, result) {
+  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`
+  };
+  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"
+  };
+  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);
+}
+export {
+  CLIENT_EXTERNALS,
+  CONFIG_DEFAULTS,
+  CONFIG_FILE,
+  ConfigError,
+  DEFAULT_TARGET,
+  INCLUDE_KEY,
+  IncludeError,
+  ModuleBuildError,
+  ProfileError,
+  buildModule,
+  bundleClient,
+  collectModuleSource,
+  compileTailwind,
+  deriveModuleId,
+  discoverActions,
+  discoverComponents,
+  emitDsl,
+  emitModule,
+  expandIncludes,
+  getProfile,
+  initModule,
+  innospotsWebShellV1,
+  innospotsWebShellV2,
+  listProfiles,
+  loadModuleConfig,
+  loadYamlExpanded,
+  matchPathPattern,
+  parseJsonc,
+  parseYamlFile,
+  readProjectVersion,
+  renderClientEntry,
+  resolvePactorVersionRange,
+  rewriteDslUrls,
+  rewriteNavigationTo,
+  transformSitemap,
+  tsconfigAliases,
+  validateModule,
+  writeManifest
+};