@pactor-app/i18n 0.0.0-stage → 1.55.0

package/dist/node.cjs

@@ -0,0 +1,1354 @@
+"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/node.ts
+var node_exports = {};
+__export(node_exports, {
+  ApiMessageProvider: () => ApiMessageProvider,
+  I18nError: () => I18nError,
+  MISSING_TRANSLATION_TEXT: () => MISSING_TRANSLATION_TEXT,
+  TranslatableFieldRegistry: () => TranslatableFieldRegistry,
+  YamlMessageProvider: () => YamlMessageProvider,
+  assertMessages: () => assertMessages,
+  assertNoCrossNamespaceKeyConflicts: () => assertNoCrossNamespaceKeyConflicts,
+  createDefaultTranslatableFieldRegistry: () => createDefaultTranslatableFieldRegistry,
+  escapeJsonPointerSegment: () => escapeJsonPointerSegment,
+  getDefaultTranslatableFieldRegistry: () => getDefaultTranslatableFieldRegistry,
+  isI18nError: () => isI18nError,
+  isValidMessageKey: () => isValidMessageKey,
+  localizePageDsl: () => localizePageDsl,
+  localizeYamlResource: () => localizeYamlResource,
+  normalizeLocaleTag: () => normalizeLocaleTag,
+  parseAcceptLanguage: () => parseAcceptLanguage,
+  parseJsonPointer: () => parseJsonPointer,
+  parsePageYamlStrict: () => parsePageYamlStrict,
+  resolveJsonPointer: () => resolveJsonPointer,
+  resolveRequestLocale: () => resolveRequestLocale,
+  validateBundleSetEnvelope: () => validateBundleSetEnvelope,
+  validateManifest: () => validateManifest
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/errors.ts
+var I18nError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "I18nError";
+  }
+};
+function isI18nError(error, code) {
+  return error instanceof I18nError && (code === void 0 || error.code === code);
+}
+
+// src/locale-resolver.ts
+var LOCALE_TAG_RE = /^[a-zA-Z]{2,3}(?:-[a-zA-Z]{4})?(?:-(?:[a-zA-Z]{2}|\d{3}))?$/;
+function normalizeLocaleTag(value) {
+  const trimmed = value.trim().replace(/_/g, "-");
+  if (!LOCALE_TAG_RE.test(trimmed)) {
+    return void 0;
+  }
+  const parts = trimmed.split("-");
+  let result = parts[0].toLowerCase();
+  for (let i = 1; i < parts.length; i += 1) {
+    const part = parts[i];
+    result += "-" + (part.length === 4 ? part[0].toUpperCase() + part.slice(1).toLowerCase() : part.toUpperCase());
+  }
+  return result;
+}
+function parseAcceptLanguage(header) {
+  if (header === void 0) {
+    return [];
+  }
+  const entries = [];
+  const parts = header.split(",");
+  for (let order = 0; order < parts.length; order += 1) {
+    const segments = parts[order].split(";");
+    const rawTag = segments[0].trim();
+    if (rawTag === "") {
+      continue;
+    }
+    let q = 1;
+    let validQ = true;
+    for (const segment of segments.slice(1)) {
+      const [name, rawValue] = segment.split("=");
+      if (name?.trim().toLowerCase() !== "q") {
+        continue;
+      }
+      const parsed = Number(rawValue?.trim());
+      if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        validQ = false;
+      } else {
+        q = parsed;
+      }
+    }
+    if (!validQ || q === 0) {
+      continue;
+    }
+    if (rawTag === "*") {
+      entries.push({ tag: "*", q, order });
+      continue;
+    }
+    const tag = normalizeLocaleTag(rawTag);
+    if (tag === void 0) {
+      continue;
+    }
+    entries.push({ tag, q, order });
+  }
+  entries.sort((a, b) => b.q - a.q || a.order - b.order);
+  return entries.map(({ tag, q }) => ({ tag, q }));
+}
+function configError(message) {
+  throw new I18nError("INVALID_LOCALE_CONFIG", message);
+}
+function prepareConfig(config) {
+  if (!Array.isArray(config.supportedLocales) || config.supportedLocales.length === 0) {
+    configError("supportedLocales \u5FC5\u987B\u4E3A\u975E\u7A7A\u6570\u7EC4");
+  }
+  const supported = /* @__PURE__ */ new Map();
+  for (const raw of config.supportedLocales) {
+    const normalized = typeof raw === "string" ? normalizeLocaleTag(raw) : void 0;
+    if (normalized === void 0) {
+      configError(`supportedLocales \u542B\u975E\u6CD5\u8BED\u8A00\u6807\u8BC6: ${String(raw)}`);
+    }
+    if (supported.has(normalized)) {
+      configError(`supportedLocales \u542B\u91CD\u590D\u8BED\u8A00\uFF08\u89C4\u8303\u5316\u540E\uFF09: ${normalized}`);
+    }
+    supported.set(normalized, normalized);
+  }
+  const defaultNormalized = typeof config.defaultLocale === "string" ? normalizeLocaleTag(config.defaultLocale) : void 0;
+  if (defaultNormalized === void 0 || !supported.has(defaultNormalized)) {
+    configError(`defaultLocale \u5FC5\u987B\u5C5E\u4E8E supportedLocales: ${String(config.defaultLocale)}`);
+  }
+  const defaultLocale = supported.get(defaultNormalized);
+  const strategy = config.defaultStrategy ?? "system";
+  if (strategy !== "system" && strategy !== "application") {
+    configError(`\u975E\u6CD5 defaultStrategy: ${String(config.defaultStrategy)}`);
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  for (const [rawFrom, rawTo] of Object.entries(config.aliases ?? {})) {
+    const from = normalizeLocaleTag(rawFrom);
+    const to = normalizeLocaleTag(rawTo);
+    if (from === void 0 || to === void 0) {
+      configError(`\u522B\u540D\u542B\u975E\u6CD5\u8BED\u8A00\u6807\u8BC6: ${rawFrom} \u2192 ${rawTo}`);
+    }
+    if (supported.has(from)) {
+      configError(`\u522B\u540D\u4E0E\u5DF2\u652F\u6301\u8BED\u8A00\u51B2\u7A81: ${from}`);
+    }
+    if (aliases.has(from)) {
+      configError(`\u522B\u540D\u91CD\u590D\u5B9A\u4E49\uFF08\u89C4\u8303\u5316\u540E\uFF09: ${from}`);
+    }
+    if (from === to) {
+      configError(`\u522B\u540D\u81EA\u6620\u5C04: ${from}`);
+    }
+    aliases.set(from, to);
+  }
+  for (const from of aliases.keys()) {
+    if (applyAliases(from, aliases) === void 0) {
+      configError(`\u522B\u540D\u76EE\u6807\u65E0\u6CD5\u89E3\u6790\u5230\u652F\u6301\u8BED\u8A00\u6216\u5B58\u5728\u73AF: ${from}`);
+    }
+  }
+  const resolveAliasTarget = (value) => {
+    const terminal = applyAliases(value, aliases);
+    return terminal !== void 0 && supported.has(terminal) ? terminal : void 0;
+  };
+  for (const [from, to] of aliases) {
+    if (resolveAliasTarget(to) === void 0) {
+      configError(`\u522B\u540D\u76EE\u6807\u4E0D\u5728\u652F\u6301\u5217\u8868: ${from} \u2192 ${to}`);
+    }
+  }
+  const fallbackLocales = /* @__PURE__ */ new Map();
+  for (const [rawFrom, rawList] of Object.entries(config.fallbackLocales ?? {})) {
+    const from = normalizeLocaleTag(rawFrom);
+    if (from === void 0 || !Array.isArray(rawList)) {
+      configError(`fallbackLocales \u542B\u975E\u6CD5\u914D\u7F6E: ${rawFrom}`);
+    }
+    const list = rawList.map((item) => {
+      const normalized = typeof item === "string" ? normalizeLocaleTag(item) : void 0;
+      if (normalized === void 0) {
+        configError(`fallbackLocales \u542B\u975E\u6CD5\u8BED\u8A00\u6807\u8BC6: ${String(item)}`);
+      }
+      return normalized;
+    });
+    fallbackLocales.set(from, list);
+  }
+  return { supported, defaultLocale, strategy, aliases, fallbackLocales };
+}
+function applyAliases(tag, aliases) {
+  const visited = /* @__PURE__ */ new Set([tag]);
+  let current = tag;
+  while (aliases.has(current)) {
+    const next = aliases.get(current);
+    if (visited.has(next)) {
+      return void 0;
+    }
+    visited.add(next);
+    current = next;
+  }
+  return current;
+}
+function matchExactOrAlias(tag, config) {
+  const terminal = applyAliases(tag, config.aliases);
+  if (terminal === void 0) {
+    return void 0;
+  }
+  return config.supported.get(terminal);
+}
+function matchForNegotiation(tag, config) {
+  const direct = matchExactOrAlias(tag, config);
+  if (direct !== void 0) {
+    return direct;
+  }
+  for (const fallback of config.fallbackLocales.get(tag) ?? []) {
+    const matched = matchExactOrAlias(fallback, config);
+    if (matched !== void 0) {
+      return matched;
+    }
+  }
+  return void 0;
+}
+function invalidLocale(value, source) {
+  throw new I18nError("INVALID_LOCALE", `${source} \u8BED\u8A00\u6807\u8BC6\u975E\u6CD5: ${value}`, {
+    value,
+    source
+  });
+}
+function resolveRequestLocale(input, config) {
+  const cfg = prepareConfig(config);
+  let queryValue;
+  if (Array.isArray(input.queryLocale)) {
+    if (input.queryLocale.length > 1) {
+      throw new I18nError("DUPLICATE_LOCALE_PARAM", "locale \u67E5\u8BE2\u53C2\u6570\u91CD\u590D", {
+        values: [...input.queryLocale]
+      });
+    }
+    queryValue = input.queryLocale[0];
+  } else {
+    queryValue = input.queryLocale;
+  }
+  const pathNorm = input.pathLocale !== void 0 ? normalizeLocaleTag(input.pathLocale) ?? invalidLocale(input.pathLocale, "url-path") : void 0;
+  const queryNorm = queryValue !== void 0 ? normalizeLocaleTag(queryValue) ?? invalidLocale(queryValue, "url-query") : void 0;
+  if (pathNorm !== void 0 && queryNorm !== void 0) {
+    const pathResolved = applyAliases(pathNorm, cfg.aliases);
+    const queryResolved = applyAliases(queryNorm, cfg.aliases);
+    if (pathResolved !== queryResolved) {
+      throw new I18nError("LOCALE_CONFLICT", "\u8DEF\u5F84\u4E0E\u67E5\u8BE2\u53C2\u6570\u6307\u5B9A\u7684\u8BED\u8A00\u51B2\u7A81", {
+        pathLocale: pathNorm,
+        queryLocale: queryNorm
+      });
+    }
+  }
+  const explicit = pathNorm ?? queryNorm;
+  if (explicit !== void 0) {
+    const matched = matchExactOrAlias(explicit, cfg);
+    if (matched === void 0) {
+      throw new I18nError("UNSUPPORTED_LOCALE", `\u4E0D\u652F\u6301\u7684\u8BED\u8A00: ${explicit}`, {
+        value: explicit,
+        supportedLocales: [...cfg.supported.values()]
+      });
+    }
+    return {
+      locale: matched,
+      source: pathNorm !== void 0 ? "url-path" : "url-query",
+      explicit: true
+    };
+  }
+  if (input.cookieLocale !== void 0) {
+    const cookieNorm = normalizeLocaleTag(input.cookieLocale);
+    if (cookieNorm !== void 0) {
+      const matched = matchExactOrAlias(cookieNorm, cfg);
+      if (matched !== void 0) {
+        return { locale: matched, source: "cookie", explicit: true };
+      }
+    }
+  }
+  if (cfg.strategy === "system") {
+    for (const entry of parseAcceptLanguage(input.acceptLanguage)) {
+      if (entry.tag === "*") {
+        return { locale: cfg.defaultLocale, source: "accept-language", explicit: false };
+      }
+      const matched = matchForNegotiation(entry.tag, cfg);
+      if (matched !== void 0) {
+        return { locale: matched, source: "accept-language", explicit: false };
+      }
+    }
+  }
+  return { locale: cfg.defaultLocale, source: "application-default", explicit: false };
+}
+
+// src/bundle-validation.ts
+var MESSAGE_KEY_RE = /^[^\s.]+(?:\.[^\s.]+)*$/;
+function isValidMessageKey(key) {
+  return MESSAGE_KEY_RE.test(key);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertMessages(value, context, code) {
+  if (!isPlainObject(value)) {
+    throw new I18nError(code, `${context}: \u8BED\u8A00\u5305\u5FC5\u987B\u662F\u6241\u5E73\u952E\u503C\u5BF9\u8C61`);
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    if (!isValidMessageKey(key)) {
+      throw new I18nError(code, `${context}: \u975E\u6CD5\u8BCD\u6761\u952E\u540D: ${key}`, { key });
+    }
+    if (typeof entry !== "string") {
+      throw new I18nError(code, `${context}: \u8BCD\u6761\u503C\u5FC5\u987B\u662F\u5B57\u7B26\u4E32: ${key}`, {
+        key,
+        valueType: Array.isArray(entry) ? "array" : typeof entry
+      });
+    }
+  }
+  return value;
+}
+function assertNoCrossNamespaceKeyConflicts(bundles, code) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const [namespace, messages] of Object.entries(bundles)) {
+    for (const key of Object.keys(messages)) {
+      const list = owners.get(key);
+      if (list === void 0) {
+        owners.set(key, [namespace]);
+      } else {
+        list.push(namespace);
+      }
+    }
+  }
+  const conflicts = [...owners.entries()].filter(([, list]) => list.length > 1);
+  if (conflicts.length > 0) {
+    const [key, namespaces] = conflicts[0];
+    throw new I18nError(
+      code,
+      `\u4E0D\u540C namespace \u5B9A\u4E49\u4E86\u76F8\u540C\u5B8C\u6574 key: ${key}\uFF08${[...namespaces].sort().join(", ")}\uFF09`,
+      { key, namespaces: [...namespaces].sort() }
+    );
+  }
+}
+function validateBundleSetEnvelope(data, expected) {
+  if (!isPlainObject(data)) {
+    throw new I18nError("MESSAGE_PROTOCOL_ERROR", "\u8BED\u8A00\u5305\u54CD\u5E94\u5FC5\u987B\u662F JSON \u5BF9\u8C61 envelope");
+  }
+  for (const field of ["appId", "locale", "release"]) {
+    if (typeof data[field] !== "string" || data[field] === "") {
+      throw new I18nError("MESSAGE_PROTOCOL_ERROR", `envelope \u7F3A\u5C11\u5B57\u6BB5 ${field}`);
+    }
+    if (data[field] !== expected[field]) {
+      throw new I18nError(
+        "MESSAGE_PROTOCOL_ERROR",
+        `envelope.${field} \u4E0E\u8BF7\u6C42\u4E0D\u4E00\u81F4: ${String(data[field])} !== ${expected[field]}`,
+        { field, actual: data[field], expected: expected[field] }
+      );
+    }
+  }
+  if (data["format"] !== "simple-v1") {
+    throw new I18nError("MESSAGE_PROTOCOL_ERROR", `\u4E0D\u652F\u6301\u7684\u8BED\u8A00\u5305 format: ${String(data["format"])}`, {
+      format: data["format"]
+    });
+  }
+  const rawBundles = data["bundles"];
+  if (!isPlainObject(rawBundles)) {
+    throw new I18nError("MESSAGE_PROTOCOL_ERROR", "envelope.bundles \u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  const bundles = {};
+  for (const [namespace, rawBundle] of Object.entries(rawBundles)) {
+    if (!isPlainObject(rawBundle)) {
+      throw new I18nError(
+        "MESSAGE_PROTOCOL_ERROR",
+        `envelope.bundles.${namespace} \u5FC5\u987B\u662F\u5BF9\u8C61\uFF08\u8BED\u8A00\u5305 API \u4E0D\u8FD4\u56DE YAML \u5B57\u7B26\u4E32\uFF09`,
+        { namespace }
+      );
+    }
+    if (typeof rawBundle["version"] !== "string" || rawBundle["version"] === "") {
+      throw new I18nError("MESSAGE_PROTOCOL_ERROR", `envelope.bundles.${namespace} \u7F3A\u5C11 version`, {
+        namespace
+      });
+    }
+    bundles[namespace] = {
+      version: rawBundle["version"],
+      messages: assertMessages(
+        rawBundle["messages"],
+        `envelope.bundles.${namespace}`,
+        "MESSAGE_PROTOCOL_ERROR"
+      )
+    };
+  }
+  for (const namespace of expected.namespaces) {
+    if (!(namespace in bundles)) {
+      throw new I18nError("NAMESPACE_NOT_FOUND", `\u8BED\u8A00\u5305\u54CD\u5E94\u7F3A\u5931 namespace: ${namespace}`, {
+        namespace
+      });
+    }
+  }
+  assertNoCrossNamespaceKeyConflicts(
+    Object.fromEntries(Object.entries(bundles).map(([ns, b]) => [ns, b.messages])),
+    "MESSAGE_PROTOCOL_ERROR"
+  );
+  return {
+    appId: expected.appId,
+    locale: expected.locale,
+    release: expected.release,
+    format: "simple-v1",
+    bundles
+  };
+}
+
+// src/api-message-provider.ts
+function cacheKeyOf(input) {
+  return [
+    input.appId,
+    input.tenantId ?? "",
+    input.locale,
+    [...input.namespaces].sort().join(","),
+    input.release
+  ].join("\n");
+}
+function buildUrl(endpoint, input) {
+  const params = [
+    ["appId", input.appId],
+    ["locale", input.locale],
+    ["namespaces", input.namespaces.join(",")],
+    ["release", input.release]
+  ];
+  if (input.tenantId !== void 0) {
+    params.push(["tenantId", input.tenantId]);
+  }
+  const query = params.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+  return `${endpoint}${endpoint.includes("?") ? "&" : "?"}${query}`;
+}
+var JSON_CONTENT_TYPE_RE = /^\s*application\/json\s*(?:;|$)/i;
+var ApiMessageProvider = class {
+  constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.options = options;
+  }
+  /** MessageProvider 契约实现 */
+  async load(input) {
+    const result = await this.loadWithCacheInfo(input);
+    return result.bundleSet;
+  }
+  /** 加载并返回缓存信息（ETag / notModified） */
+  async loadWithCacheInfo(input) {
+    const key = cacheKeyOf(input);
+    const cached = this.cache.get(key);
+    const etag = input.etag ?? cached?.etag;
+    const headers = { ...this.options.headers };
+    if (etag !== void 0) {
+      headers["If-None-Match"] = etag;
+    }
+    let response;
+    try {
+      response = await this.options.fetch(buildUrl(this.options.endpoint, input), { headers });
+    } catch (error) {
+      throw new I18nError("MESSAGE_FETCH_FAILED", "\u8BED\u8A00\u5305\u8BF7\u6C42\u5931\u8D25", {
+        cause: error instanceof Error ? error.message : String(error)
+      });
+    }
+    if (response.status === 304) {
+      if (cached !== void 0) {
+        return { bundleSet: cached.bundleSet, etag: cached.etag, notModified: true };
+      }
+      throw new I18nError("MESSAGE_PROTOCOL_ERROR", "\u6536\u5230 304 \u4F46\u6CA1\u6709\u53EF\u590D\u7528\u7684\u5DF2\u6821\u9A8C\u7F13\u5B58\u5305");
+    }
+    if (response.status !== 200) {
+      throw new I18nError("MESSAGE_FETCH_FAILED", `\u8BED\u8A00\u5305\u63A5\u53E3\u8FD4\u56DE HTTP ${response.status}`, {
+        status: response.status
+      });
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType === null || !JSON_CONTENT_TYPE_RE.test(contentType)) {
+      throw new I18nError(
+        "MESSAGE_PROTOCOL_ERROR",
+        `\u8BED\u8A00\u5305\u63A5\u53E3 Content-Type \u5FC5\u987B\u662F application/json\uFF0C\u5B9E\u9645: ${contentType ?? "(\u7F3A\u5931)"}`,
+        { contentType }
+      );
+    }
+    const text = await response.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new I18nError(
+        "MESSAGE_PROTOCOL_ERROR",
+        "\u8BED\u8A00\u5305\u54CD\u5E94\u4E0D\u662F\u5408\u6CD5 JSON\uFF08\u534F\u8BAE\u4E0D\u8FD4\u56DE YAML \u539F\u6587\u6216\u5185\u5D4C YAML \u5B57\u7B26\u4E32\uFF09"
+      );
+    }
+    const bundleSet = validateBundleSetEnvelope(data, input);
+    const newEtag = response.headers.get("etag") ?? void 0;
+    this.cache.set(key, { etag: newEtag, bundleSet });
+    return { bundleSet, etag: newEtag, notModified: false };
+  }
+};
+
+// src/translatable-field-registry.ts
+var SEGMENT_RE = /^[^.[\]]+(?:\[\*\])?$/;
+function assertValidFieldPath(path, root) {
+  const segments = typeof path === "string" ? path.split(".") : [];
+  if (segments[0] !== root || segments.length < 2) {
+    throw new I18nError(
+      "INVALID_FIELD_PATH",
+      `\u53EF\u7FFB\u8BD1\u5B57\u6BB5\u8DEF\u5F84\u5FC5\u987B\u4EE5 ${root}.<field> \u5F00\u5934: ${String(path)}`,
+      { path }
+    );
+  }
+  for (const segment of segments) {
+    if (!SEGMENT_RE.test(segment)) {
+      throw new I18nError("INVALID_FIELD_PATH", `\u975E\u6CD5\u53EF\u7FFB\u8BD1\u5B57\u6BB5\u8DEF\u5F84: ${path}`, { path });
+    }
+  }
+}
+function assertName(name, kind) {
+  if (typeof name !== "string" || name === "") {
+    throw new I18nError("INVALID_FIELD_PATH", `${kind}\u540D\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`, { name });
+  }
+}
+var TranslatableFieldRegistry = class {
+  constructor() {
+    this.componentFields = /* @__PURE__ */ new Map();
+    this.actionFields = /* @__PURE__ */ new Map();
+  }
+  /** 注册组件 type 的可翻译字段路径（可重复调用，累积合并） */
+  register(componentType, fields) {
+    assertName(componentType, "\u7EC4\u4EF6 type");
+    const list = typeof fields === "string" ? [fields] : fields;
+    let set = this.componentFields.get(componentType);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      this.componentFields.set(componentType, set);
+    }
+    for (const field of list) {
+      assertValidFieldPath(field, "props");
+      set.add(field);
+    }
+    return this;
+  }
+  /** 注册动作名的可翻译参数字段路径（如 message 动作的 `params.text`） */
+  registerAction(actionName, fields) {
+    assertName(actionName, "\u52A8\u4F5C");
+    const list = typeof fields === "string" ? [fields] : fields;
+    let set = this.actionFields.get(actionName);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      this.actionFields.set(actionName, set);
+    }
+    for (const field of list) {
+      assertValidFieldPath(field, "params");
+      set.add(field);
+    }
+    return this;
+  }
+  /**
+   * 判断组件字段是否已注册。`canonicalPath` 为规范化路径
+   * （数组下标段写作 `[*]`，如 `props.columns[*].title`）。
+   */
+  isTranslatable(componentType, canonicalPath) {
+    if (componentType === void 0) {
+      return false;
+    }
+    return this.componentFields.get(componentType)?.has(canonicalPath) ?? false;
+  }
+  /** 判断动作参数字段是否已注册 */
+  isTranslatableActionField(actionName, canonicalPath) {
+    return this.actionFields.get(actionName)?.has(canonicalPath) ?? false;
+  }
+  /** 已注册组件 type 列表（诊断/调试用） */
+  registeredComponents() {
+    return [...this.componentFields.keys()];
+  }
+  /** 已注册动作名列表（诊断/调试用） */
+  registeredActions() {
+    return [...this.actionFields.keys()];
+  }
+};
+function createDefaultTranslatableFieldRegistry() {
+  return new TranslatableFieldRegistry().register("Button", ["props.text", "props.label", "props.description", "props.ariaLabel"]).register("Text", ["props.text", "props.description", "props.ariaLabel"]).register("Input", [
+    "props.text",
+    "props.label",
+    "props.placeholder",
+    "props.description",
+    "props.ariaLabel"
+  ]).register("Table", [
+    "props.label",
+    "props.description",
+    "props.ariaLabel",
+    "props.columns[*].title"
+  ]).register("Select", [
+    "props.label",
+    "props.placeholder",
+    "props.description",
+    "props.ariaLabel",
+    "props.options[*].label"
+  ]).registerAction("message", ["params.text"]).registerAction("confirm", ["params.title", "params.content"]);
+}
+var defaultRegistry;
+function getDefaultTranslatableFieldRegistry() {
+  defaultRegistry ?? (defaultRegistry = createDefaultTranslatableFieldRegistry());
+  return defaultRegistry;
+}
+
+// src/json-pointer.ts
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var ARRAY_INDEX_RE = /^(0|[1-9]\d*)$/;
+function escapeJsonPointerSegment(segment) {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function parseJsonPointer(pointer) {
+  if (pointer === "") {
+    return [];
+  }
+  if (typeof pointer !== "string" || !pointer.startsWith("/")) {
+    throw new I18nError("BINDING_INVALID", `bindings \u952E\u5FC5\u987B\u662F JSON Pointer\uFF08/ \u5F00\u5934\u6216\u7A7A\u4E32\uFF09: ${String(pointer)}`, {
+      pointer
+    });
+  }
+  return pointer.slice(1).split("/").map((raw) => {
+    if (/~(?![01])/.test(raw)) {
+      throw new I18nError("BINDING_INVALID", `JSON Pointer \u542B\u975E\u6CD5\u8F6C\u4E49: ${pointer}`, { pointer });
+    }
+    return raw.replace(/~1/g, "/").replace(/~0/g, "~");
+  });
+}
+function missing(pointer) {
+  throw new I18nError("BINDING_INVALID", `bindings \u76EE\u6807\u4E0D\u5B58\u5728: ${pointer}`, { pointer });
+}
+function parseArrayIndex(segment, pointer) {
+  if (!ARRAY_INDEX_RE.test(segment)) {
+    throw new I18nError(
+      "BINDING_INVALID",
+      `bindings \u6570\u7EC4\u8DEF\u5F84\u5FC5\u987B\u662F\u5177\u4F53\u4E0B\u6807\uFF08\u4E0D\u652F\u6301\u901A\u914D\u7B26\u4E0E -\uFF09: ${pointer}`,
+      { pointer, segment }
+    );
+  }
+  return Number(segment);
+}
+function childAt(container, segment, pointer) {
+  if (Array.isArray(container)) {
+    const index = parseArrayIndex(segment, pointer);
+    if (index >= container.length) {
+      missing(pointer);
+    }
+    return container[index];
+  }
+  if (isPlainObject2(container)) {
+    if (!Object.prototype.hasOwnProperty.call(container, segment)) {
+      missing(pointer);
+    }
+    return container[segment];
+  }
+  missing(pointer);
+}
+function resolveJsonPointer(root, segments, pointer) {
+  if (segments.length === 0) {
+    throw new I18nError("BINDING_INVALID", "bindings \u4E0D\u80FD\u6307\u5411\u6574\u4E2A\u6587\u6863\uFF08\u76EE\u6807\u5FC5\u987B\u4E3A\u5B57\u7B26\u4E32\u5B57\u6BB5\uFF09", {
+      pointer
+    });
+  }
+  let current = root;
+  for (let i = 0; i < segments.length - 1; i += 1) {
+    current = childAt(current, segments[i], pointer);
+  }
+  const last = segments[segments.length - 1];
+  if (Array.isArray(current)) {
+    const index = parseArrayIndex(last, pointer);
+    if (index >= current.length) {
+      missing(pointer);
+    }
+    return { parent: current, key: index, value: current[index] };
+  }
+  if (isPlainObject2(current)) {
+    if (!Object.prototype.hasOwnProperty.call(current, last)) {
+      missing(pointer);
+    }
+    return { parent: current, key: last, value: current[last] };
+  }
+  missing(pointer);
+}
+
+// src/dsl-localizer.ts
+var import_core = require("@pactor-app/core");
+var MISSING_TRANSLATION_TEXT = "[missing translation]";
+var FORBIDDEN_BINDING_ROOTS = /* @__PURE__ */ new Set(["state", "dataSources", "requires", "meta", "i18n"]);
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepClone(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  if (isPlainObject3(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = deepClone(child);
+    }
+    return out;
+  }
+  return value;
+}
+function lookupKey(ctx, key) {
+  for (let i = 0; i < ctx.bundleChain.length; i += 1) {
+    const set = ctx.bundleChain[i];
+    for (const bundle of Object.values(set.bundles)) {
+      const value = bundle.messages[key];
+      if (typeof value === "string") {
+        const resolution = i === 0 ? "current" : set.locale === ctx.defaultLocale ? "default-locale" : "fallback-locale";
+        return { found: true, value, resolution };
+      }
+    }
+  }
+  return { found: false };
+}
+function lookupInline(ctx, messages) {
+  for (const loc of ctx.localeChain) {
+    const value = messages[loc];
+    if (typeof value === "string") {
+      const resolution = loc === ctx.locale ? "current" : loc === ctx.defaultLocale ? "default-locale" : "fallback-locale";
+      return { found: true, value, resolution };
+    }
+  }
+  return { found: false };
+}
+function assertDescriptor(value, path) {
+  if (!isPlainObject3(value)) {
+    throw new I18nError("I18N_DESCRIPTOR_INVALID", `\u7FFB\u8BD1\u63CF\u8FF0\u5FC5\u987B\u662F\u5BF9\u8C61: ${path}`, { path });
+  }
+  const hasKey = typeof value["key"] === "string";
+  const messages = value["messages"];
+  const hasMessages = isPlainObject3(messages) && Object.values(messages).every((v) => typeof v === "string");
+  if (hasKey === hasMessages) {
+    throw new I18nError(
+      "I18N_DESCRIPTOR_INVALID",
+      `\u7FFB\u8BD1\u63CF\u8FF0\u5FC5\u987B\u4E14\u53EA\u80FD\u5305\u542B key \u6216 messages \u4E4B\u4E00: ${path}`,
+      { path }
+    );
+  }
+  if (value["params"] !== void 0 && !isPlainObject3(value["params"])) {
+    throw new I18nError("I18N_DESCRIPTOR_INVALID", `\u7FFB\u8BD1\u63CF\u8FF0 params \u5FC5\u987B\u662F\u5BF9\u8C61: ${path}`, { path });
+  }
+  if (value["fallback"] !== void 0 && typeof value["fallback"] !== "string") {
+    throw new I18nError("I18N_DESCRIPTOR_INVALID", `\u7FFB\u8BD1\u63CF\u8FF0 fallback \u5FC5\u987B\u662F\u5B57\u7B26\u4E32: ${path}`, {
+      path
+    });
+  }
+  return value;
+}
+function assertSafeTemplate(template, path) {
+  if (template.includes("${")) {
+    throw new I18nError("UNSAFE_MESSAGE", `\u8BCD\u6761\u6216 fallback \u542B\u5B57\u9762\u91CF \${\uFF0C\u62D2\u7EDD\u8F6C\u6362: ${path}`, {
+      path
+    });
+  }
+}
+var PARAM_PLACEHOLDER_RE = /\{\{(\w+)\}\}/g;
+function interpolateTemplate(ctx, template, params, path) {
+  return template.replace(PARAM_PLACEHOLDER_RE, (raw, name) => {
+    if (Object.prototype.hasOwnProperty.call(params, name)) {
+      const value = params[name];
+      return value === void 0 || value === null ? "" : String(value);
+    }
+    ctx.onDiagnostic?.({
+      type: "missing-param",
+      path,
+      locale: ctx.locale,
+      param: name,
+      resolution: "placeholder"
+    });
+    return raw;
+  });
+}
+function convertDescriptor(ctx, desc, implicitFallback, path) {
+  const key = "key" in desc ? desc.key : void 0;
+  const hit = key !== void 0 ? lookupKey(ctx, key) : lookupInline(ctx, desc.messages);
+  let template;
+  if (hit.found) {
+    template = hit.value;
+    if (hit.resolution !== "current") {
+      ctx.onDiagnostic?.({
+        type: "missing-translation",
+        path,
+        locale: ctx.locale,
+        key,
+        resolution: hit.resolution
+      });
+    }
+  } else if (typeof desc.fallback === "string") {
+    template = desc.fallback;
+    ctx.onDiagnostic?.({
+      type: "missing-translation",
+      path,
+      locale: ctx.locale,
+      key,
+      resolution: "fallback"
+    });
+  } else if (implicitFallback !== void 0) {
+    template = implicitFallback;
+    ctx.onDiagnostic?.({
+      type: "missing-translation",
+      path,
+      locale: ctx.locale,
+      key,
+      resolution: "implicit-fallback"
+    });
+  } else if (key !== void 0) {
+    template = key;
+    ctx.onDiagnostic?.({
+      type: "missing-translation",
+      path,
+      locale: ctx.locale,
+      key,
+      resolution: "key"
+    });
+  } else {
+    template = MISSING_TRANSLATION_TEXT;
+    ctx.onDiagnostic?.({
+      type: "missing-translation",
+      path,
+      locale: ctx.locale,
+      resolution: "missing-text"
+    });
+  }
+  assertSafeTemplate(template, path);
+  const params = desc.params;
+  if (params !== void 0) {
+    const hasRuntimeParam = Object.values(params).some(
+      (value) => typeof value === "string" && value.includes("${")
+    );
+    if (hasRuntimeParam) {
+      return { $localizedText: { template, params: { ...params } } };
+    }
+    const result = interpolateTemplate(ctx, template, params, path);
+    assertSafeTemplate(result, path);
+    return result;
+  }
+  return template;
+}
+function walkValue(ctx, value, canonical, display, isTranslatable) {
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i += 1) {
+      value[i] = walkValue(ctx, value[i], `${canonical}[*]`, `${display}/${i}`, isTranslatable);
+    }
+    return value;
+  }
+  if (isPlainObject3(value)) {
+    if ("$i18n" in value) {
+      if (!isTranslatable(canonical)) {
+        throw new I18nError(
+          "UNREGISTERED_I18N_FIELD",
+          `\u672A\u6CE8\u518C\u7684\u53EF\u7FFB\u8BD1\u5B57\u6BB5\u51FA\u73B0 $i18n\uFF08\u4E0D\u9759\u9ED8\u5FFD\u7565\uFF09: ${display}`,
+          { path: display, field: canonical }
+        );
+      }
+      return convertDescriptor(ctx, assertDescriptor(value["$i18n"], display), void 0, display);
+    }
+    for (const key of Object.keys(value)) {
+      value[key] = walkValue(
+        ctx,
+        value[key],
+        `${canonical}.${key}`,
+        `${display}/${escapeJsonPointerSegment(key)}`,
+        isTranslatable
+      );
+    }
+    return value;
+  }
+  return value;
+}
+function walkAction(ctx, action, display) {
+  if (!isPlainObject3(action)) {
+    return;
+  }
+  const name = typeof action["action"] === "string" ? action["action"] : void 0;
+  if (action["params"] !== void 0) {
+    action["params"] = walkValue(
+      ctx,
+      action["params"],
+      "params",
+      `${display}/params`,
+      (p) => name !== void 0 ? ctx.registry.isTranslatableActionField(name, p) : false
+    );
+  }
+}
+function walkActions(ctx, value, display) {
+  if (Array.isArray(value)) {
+    value.forEach((action, index) => walkAction(ctx, action, `${display}/${index}`));
+  } else {
+    walkAction(ctx, value, display);
+  }
+}
+function resolveNodeType(ctx, node) {
+  if (typeof node["type"] === "string") {
+    return node["type"];
+  }
+  if (typeof node["component"] === "string") {
+    const def = ctx.namedComponents?.[node["component"]];
+    if (isPlainObject3(def) && !(0, import_core.isDslSourceRef)(def) && typeof def["type"] === "string") {
+      return def["type"];
+    }
+  }
+  return void 0;
+}
+function walkNode(ctx, node, display) {
+  if (!isPlainObject3(node)) {
+    return;
+  }
+  if ((0, import_core.isDslSourceRef)(node)) {
+    if (node.placeholder !== void 0) {
+      walkNode(ctx, node.placeholder, `${display}/placeholder`);
+    }
+    return;
+  }
+  const type = resolveNodeType(ctx, node);
+  if (node["props"] !== void 0) {
+    node["props"] = walkValue(
+      ctx,
+      node["props"],
+      "props",
+      `${display}/props`,
+      (p) => ctx.registry.isTranslatable(type, p)
+    );
+  }
+  if (isPlainObject3(node["events"])) {
+    for (const [event, actions] of Object.entries(node["events"])) {
+      walkActions(ctx, actions, `${display}/events/${escapeJsonPointerSegment(event)}`);
+    }
+  }
+  if (Array.isArray(node["children"])) {
+    node["children"].forEach((child, index) => walkNode(ctx, child, `${display}/children/${index}`));
+  } else if (node["children"] !== void 0) {
+    walkNode(ctx, node["children"], `${display}/children`);
+  }
+}
+function assertBindingAllowed(segments, pointer) {
+  const root = segments[0];
+  if (root !== void 0 && FORBIDDEN_BINDING_ROOTS.has(root)) {
+    throw new I18nError("BINDING_INVALID", `bindings \u7981\u6B62\u7ED1\u5B9A\u8BE5\u5B57\u6BB5: ${pointer}`, { pointer });
+  }
+  if (root === "page" && segments[1] === "id") {
+    throw new I18nError("BINDING_INVALID", `bindings \u7981\u6B62\u7ED1\u5B9A\u9875\u9762\u6807\u8BC6: ${pointer}`, { pointer });
+  }
+  if (segments[segments.length - 1] === "permission") {
+    throw new I18nError("BINDING_INVALID", `bindings \u7981\u6B62\u7ED1\u5B9A\u6743\u9650\u5B57\u6BB5: ${pointer}`, { pointer });
+  }
+}
+function applyBindings(ctx, root, bindings) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [pointer, rawDesc] of Object.entries(bindings)) {
+    const segments = parseJsonPointer(pointer);
+    const canonical = segments.map(escapeJsonPointerSegment).join("/");
+    const previous = seen.get(canonical);
+    if (previous !== void 0) {
+      throw new I18nError("BINDING_INVALID", `bindings \u8DEF\u5F84\u91CD\u590D: ${previous} \u4E0E ${pointer}`, {
+        pointer,
+        previous
+      });
+    }
+    seen.set(canonical, pointer);
+    assertBindingAllowed(segments, pointer);
+    const desc = assertDescriptor(rawDesc, pointer);
+    const resolved = resolveJsonPointer(root, segments, pointer);
+    if (isPlainObject3(resolved.value) && "$i18n" in resolved.value) {
+      throw new I18nError(
+        "BINDING_CONFLICT",
+        `\u540C\u4E00\u5B57\u6BB5\u88AB $i18n \u4E0E bindings \u91CD\u590D\u58F0\u660E: ${pointer}`,
+        { pointer }
+      );
+    }
+    if (typeof resolved.value !== "string") {
+      throw new I18nError("BINDING_INVALID", `bindings \u76EE\u6807\u5FC5\u987B\u662F\u5B57\u7B26\u4E32: ${pointer}`, {
+        pointer,
+        valueType: Array.isArray(resolved.value) ? "array" : typeof resolved.value
+      });
+    }
+    const converted = convertDescriptor(ctx, desc, resolved.value, pointer);
+    resolved.parent[resolved.key] = converted;
+  }
+}
+function dedupeLocales(locales) {
+  return [...new Set(locales)];
+}
+function assertNoResidualI18n(value, display) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoResidualI18n(item, `${display}/${index}`));
+    return;
+  }
+  if (isPlainObject3(value)) {
+    if ("$i18n" in value) {
+      throw new I18nError(
+        "UNREGISTERED_I18N_FIELD",
+        `$i18n \u51FA\u73B0\u5728\u4E0D\u53EF\u7FFB\u8BD1\u7684\u4F4D\u7F6E\uFF08\u4E0D\u9759\u9ED8\u900F\u4F20\uFF09: ${display}`,
+        { path: display }
+      );
+    }
+    for (const [key, child] of Object.entries(value)) {
+      assertNoResidualI18n(child, `${display}/${escapeJsonPointerSegment(key)}`);
+    }
+  }
+}
+function localizePageDsl(input) {
+  const { locale, defaultLocale } = input;
+  if (typeof locale !== "string" || locale === "") {
+    throw new I18nError("INVALID_LOCALE", "localizePageDsl \u7F3A\u5C11\u6709\u6548 locale");
+  }
+  if (typeof defaultLocale !== "string" || defaultLocale === "") {
+    throw new I18nError("INVALID_LOCALE", "localizePageDsl \u7F3A\u5C11\u6709\u6548 defaultLocale");
+  }
+  const page = deepClone(input.page);
+  const fallbacks = input.languageBundles.fallbacks ?? [];
+  const bundleChain = [input.languageBundles.current, ...fallbacks];
+  const localeChain = dedupeLocales([locale, ...fallbacks.map((set) => set.locale), defaultLocale]);
+  const ctx = {
+    locale,
+    defaultLocale,
+    localeChain,
+    bundleChain,
+    registry: input.registry ?? getDefaultTranslatableFieldRegistry(),
+    namedComponents: isPlainObject3(page.components) ? page.components : void 0,
+    onDiagnostic: input.onDiagnostic
+  };
+  const authorI18n = page.i18n;
+  if (authorI18n !== void 0) {
+    if (isPlainObject3(authorI18n.bindings)) {
+      applyBindings(ctx, page, authorI18n.bindings);
+    }
+    delete page.i18n;
+  }
+  if (page.body !== void 0) {
+    walkNode(ctx, page.body, "/body");
+  }
+  if (page.children !== void 0) {
+    if (Array.isArray(page.children)) {
+      page.children.forEach((child, index) => walkNode(ctx, child, `/children/${index}`));
+    } else {
+      walkNode(ctx, page.children, "/children");
+    }
+  }
+  if (isPlainObject3(page.components)) {
+    for (const [name, def] of Object.entries(page.components)) {
+      walkNode(ctx, def, `/components/${escapeJsonPointerSegment(name)}`);
+    }
+  }
+  if (isPlainObject3(page.actions)) {
+    for (const [name, actions] of Object.entries(page.actions)) {
+      walkActions(ctx, actions, `/actions/${escapeJsonPointerSegment(name)}`);
+    }
+  }
+  if (isPlainObject3(page.lifecycle)) {
+    for (const [event, actions] of Object.entries(page.lifecycle)) {
+      walkActions(ctx, actions, `/lifecycle/${escapeJsonPointerSegment(event)}`);
+    }
+  }
+  assertNoResidualI18n(page, "");
+  return page;
+}
+
+// src/yaml-message-provider.ts
+var import_yaml = require("yaml");
+var DEFAULT_MAX_FILE_BYTES = 1e6;
+var DEFAULT_MAX_ALIAS_COUNT = 100;
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeRelativePath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  return normalized !== "" && !normalized.startsWith("/") && !/^[A-Za-z]:\//.test(normalized) && !normalized.split("/").includes("..");
+}
+function validateManifest(manifest) {
+  if (!isPlainObject4(manifest)) {
+    throw new I18nError("MANIFEST_INVALID", "\u8BED\u8A00\u5305\u6E05\u5355\u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  if (typeof manifest["appId"] !== "string" || manifest["appId"] === "") {
+    throw new I18nError("MANIFEST_INVALID", "\u6E05\u5355\u7F3A\u5C11 appId");
+  }
+  if (typeof manifest["release"] !== "string" || manifest["release"] === "") {
+    throw new I18nError("MANIFEST_INVALID", "\u6E05\u5355\u7F3A\u5C11 release");
+  }
+  const locales = manifest["locales"];
+  if (!isPlainObject4(locales)) {
+    throw new I18nError("MANIFEST_INVALID", "\u6E05\u5355\u7F3A\u5C11 locales");
+  }
+  for (const [locale, namespaces] of Object.entries(locales)) {
+    if (!isPlainObject4(namespaces)) {
+      throw new I18nError("MANIFEST_INVALID", `\u6E05\u5355 locales.${locale} \u5FC5\u987B\u662F\u5BF9\u8C61`);
+    }
+    for (const [namespace, entry] of Object.entries(namespaces)) {
+      if (!isPlainObject4(entry) || typeof entry["path"] !== "string" || typeof entry["version"] !== "string") {
+        throw new I18nError("MANIFEST_INVALID", `\u6E05\u5355\u6761\u76EE\u7F3A\u5C11 path/version: ${locale}/${namespace}`);
+      }
+      if (!isSafeRelativePath(entry["path"])) {
+        throw new I18nError("MANIFEST_INVALID", `\u6E05\u5355\u6761\u76EE\u8DEF\u5F84\u5FC5\u987B\u662F\u5B89\u5168\u76F8\u5BF9\u8DEF\u5F84: ${entry["path"]}`, {
+          locale,
+          namespace
+        });
+      }
+    }
+  }
+  return manifest;
+}
+function byteLength(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code < 128) {
+      bytes += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
+      bytes += 4;
+      i += 1;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function hasExplicitTag(node) {
+  if ((0, import_yaml.isPair)(node)) {
+    return hasExplicitTag(node.key) || hasExplicitTag(node.value);
+  }
+  if ((0, import_yaml.isMap)(node) || (0, import_yaml.isSeq)(node)) {
+    return node.tag !== void 0 || node.items.some(hasExplicitTag);
+  }
+  if ((0, import_yaml.isScalar)(node)) {
+    return node.tag !== void 0;
+  }
+  return false;
+}
+var YamlMessageProvider = class {
+  constructor(options) {
+    this.manifest = validateManifest(options.manifest);
+    this.readFile = options.readFile;
+    this.maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    this.maxAliasCount = options.maxAliasCount ?? DEFAULT_MAX_ALIAS_COUNT;
+  }
+  async load(input) {
+    if (input.appId !== this.manifest.appId || input.release !== this.manifest.release) {
+      throw new I18nError("MANIFEST_MISMATCH", "\u8BF7\u6C42 appId/release \u4E0E\u8BED\u8A00\u5305\u6E05\u5355\u4E0D\u4E00\u81F4", {
+        appId: input.appId,
+        release: input.release,
+        manifestAppId: this.manifest.appId,
+        manifestRelease: this.manifest.release
+      });
+    }
+    const localeEntries = this.manifest.locales[input.locale];
+    if (localeEntries === void 0) {
+      throw new I18nError("NAMESPACE_NOT_FOUND", `\u6E05\u5355\u4E0D\u542B\u8BED\u8A00: ${input.locale}`, {
+        locale: input.locale
+      });
+    }
+    const bundles = {};
+    for (const namespace of input.namespaces) {
+      const entry = localeEntries[namespace];
+      if (entry === void 0) {
+        throw new I18nError(
+          "NAMESPACE_NOT_FOUND",
+          `\u6E05\u5355\u4E0D\u542B namespace: ${input.locale}/${namespace}`,
+          { locale: input.locale, namespace }
+        );
+      }
+      bundles[namespace] = {
+        version: entry.version,
+        messages: await this.loadBundle(entry.path, namespace)
+      };
+    }
+    assertNoCrossNamespaceKeyConflicts(
+      Object.fromEntries(Object.entries(bundles).map(([ns, b]) => [ns, b.messages])),
+      "MESSAGE_BUNDLE_INVALID"
+    );
+    return {
+      appId: this.manifest.appId,
+      locale: input.locale,
+      release: this.manifest.release,
+      format: "simple-v1",
+      bundles
+    };
+  }
+  /** 读取并严格解析单个语言包 YAML 文件 */
+  async loadBundle(path, namespace) {
+    let text;
+    try {
+      text = await this.readFile(path);
+    } catch (error) {
+      throw new I18nError("MESSAGE_FETCH_FAILED", `\u8BED\u8A00\u5305\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${path}`, {
+        path,
+        cause: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const context = `\u8BED\u8A00\u5305 ${namespace}\uFF08${path}\uFF09`;
+    if (byteLength(text) > this.maxFileBytes) {
+      throw new I18nError("MESSAGE_BUNDLE_INVALID", `${context}: \u8D85\u51FA\u5927\u5C0F\u9650\u5236 ${this.maxFileBytes} \u5B57\u8282`, {
+        path,
+        maxFileBytes: this.maxFileBytes
+      });
+    }
+    const doc = (0, import_yaml.parseDocument)(text, {
+      schema: "core",
+      uniqueKeys: true,
+      strict: true
+    });
+    if (doc.errors.length > 0) {
+      throw new I18nError(
+        "MESSAGE_BUNDLE_INVALID",
+        `${context}: YAML \u89E3\u6790\u5931\u8D25: ${doc.errors.map((e) => e.message).join("; ")}`,
+        { path }
+      );
+    }
+    if (hasExplicitTag(doc.contents)) {
+      throw new I18nError("MESSAGE_BUNDLE_INVALID", `${context}: \u4E0D\u5141\u8BB8\u81EA\u5B9A\u4E49\u6807\u7B7E`, { path });
+    }
+    let data;
+    try {
+      data = doc.toJS({ maxAliasCount: this.maxAliasCount });
+    } catch (error) {
+      throw new I18nError(
+        "MESSAGE_BUNDLE_INVALID",
+        `${context}: ${error instanceof Error ? error.message : String(error)}`,
+        { path }
+      );
+    }
+    return assertMessages(data, context, "MESSAGE_BUNDLE_INVALID");
+  }
+};
+
+// src/localize-yaml-resource.ts
+var import_yaml2 = require("yaml");
+var import_schema = require("@pactor-app/schema");
+function parsePageYamlStrict(text, options) {
+  const doc = (0, import_yaml2.parseDocument)(text, {
+    schema: "core",
+    uniqueKeys: true,
+    strict: true
+  });
+  if (doc.errors.length > 0) {
+    throw new I18nError(
+      "PAGE_YAML_INVALID",
+      `\u9875\u9762 YAML \u89E3\u6790\u5931\u8D25: ${doc.errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  if (hasExplicitTag(doc.contents)) {
+    throw new I18nError("PAGE_YAML_INVALID", "\u9875\u9762 YAML \u4E0D\u5141\u8BB8\u81EA\u5B9A\u4E49\u6807\u7B7E");
+  }
+  try {
+    return doc.toJS({ maxAliasCount: options?.maxAliasCount ?? 100 });
+  } catch (error) {
+    throw new I18nError(
+      "PAGE_YAML_INVALID",
+      `\u9875\u9762 YAML \u65E0\u6548: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function emptyBundleSet(appId, locale, release) {
+  return { appId, locale, release, format: "simple-v1", bundles: {} };
+}
+async function localizeYamlResource(input) {
+  let text;
+  try {
+    text = await input.loadText();
+  } catch (error) {
+    throw new I18nError("PAGE_LOAD_FAILED", "\u9875\u9762\u8D44\u6E90\u52A0\u8F7D\u5931\u8D25", {
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const parse = input.parseYaml ?? ((value) => parsePageYamlStrict(value));
+  let document;
+  try {
+    document = parse(text);
+  } catch (error) {
+    if (isI18nError(error)) {
+      throw error;
+    }
+    throw new I18nError(
+      "PAGE_YAML_INVALID",
+      `\u9875\u9762 YAML \u89E3\u6790\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const author = (0, import_schema.validateAuthorPageDsl)(document);
+  if (!author.valid) {
+    throw new I18nError("PAGE_DSL_INVALID", "\u4F5C\u8005\u6001\u9875\u9762\u6821\u9A8C\u5931\u8D25", { errors: author.errors });
+  }
+  const pruned = input.prune ? input.prune(document) : document;
+  const namespaces = pruned.i18n?.namespaces ?? [];
+  const chain = [.../* @__PURE__ */ new Set([input.locale, ...input.fallbackLocales ?? [], input.defaultLocale])];
+  let current;
+  let fallbacks;
+  if (namespaces.length === 0) {
+    [current, ...fallbacks] = chain.map((loc) => emptyBundleSet(input.appId, loc, input.release));
+  } else {
+    const loaded = await Promise.all(
+      chain.map(
+        (loc) => input.provider.load({
+          appId: input.appId,
+          tenantId: input.tenantId,
+          locale: loc,
+          namespaces,
+          release: input.release
+        })
+      )
+    );
+    [current, ...fallbacks] = loaded;
+  }
+  const schema = localizePageDsl({
+    page: pruned,
+    locale: input.locale,
+    defaultLocale: input.defaultLocale,
+    languageBundles: { current, fallbacks },
+    registry: input.registry,
+    onDiagnostic: input.onDiagnostic
+  });
+  const localized = (0, import_schema.validateLocalizedPageDsl)(schema);
+  if (!localized.valid) {
+    throw new I18nError("PAGE_DSL_INVALID", "\u4E0B\u53D1\u6001\u9875\u9762\u6821\u9A8C\u5931\u8D25", { errors: localized.errors });
+  }
+  const bundleVersions = Object.fromEntries(
+    Object.entries(current.bundles).map(([namespace, bundle]) => [namespace, bundle.version])
+  );
+  const localization = {
+    locale: input.locale,
+    defaultLocale: input.defaultLocale,
+    release: input.release,
+    bundleVersions,
+    ...input.source !== void 0 ? { source: input.source } : {},
+    ...input.explicit !== void 0 ? { explicit: input.explicit } : {}
+  };
+  return { schema, localization };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiMessageProvider,
+  I18nError,
+  MISSING_TRANSLATION_TEXT,
+  TranslatableFieldRegistry,
+  YamlMessageProvider,
+  assertMessages,
+  assertNoCrossNamespaceKeyConflicts,
+  createDefaultTranslatableFieldRegistry,
+  escapeJsonPointerSegment,
+  getDefaultTranslatableFieldRegistry,
+  isI18nError,
+  isValidMessageKey,
+  localizePageDsl,
+  localizeYamlResource,
+  normalizeLocaleTag,
+  parseAcceptLanguage,
+  parseJsonPointer,
+  parsePageYamlStrict,
+  resolveJsonPointer,
+  resolveRequestLocale,
+  validateBundleSetEnvelope,
+  validateManifest
+});