@xndrjs/i18n 0.7.0 → 0.8.0

package/dist/index.js

@@ -1,102 +1,57 @@
 import { IntlMessageFormat } from 'intl-messageformat';
-import { parse } from '@formatjs/icu-messageformat-parser';
 
 // src/builder-loaders.ts
-async function invokeNamespaceLoader(loader, partition) {
-  if (partition === void 0) {
-    return await loader();
-  }
-  return await loader(partition);
+async function invokeNamespaceLoader(loader, partition, context) {
+  return await loader(partition, context);
 }
 
-// src/builder-multi.ts
-var I18nBuilderMultiInitialImpl = class {
+// src/i18n-handle.ts
+var I18nHandleImpl = class {
   constructor(engine, options) {
     this.engine = engine;
     this.options = options;
+    this.partitionForLocale = options?.partitionForLocale ?? ((locale) => locale);
   }
   engine;
   options;
-  withNamespaces(namespaces) {
-    return new I18nBuilderMultiReadyImpl(this.engine, this.options, { namespaces });
-  }
-};
-var I18nBuilderMultiReadyImpl = class _I18nBuilderMultiReadyImpl {
-  constructor(engine, options, state) {
-    this.engine = engine;
-    this.options = options;
-    this.state = state;
-  }
-  engine;
-  options;
-  state;
-  clone() {
-    return {
-      namespaces: this.state.namespaces,
-      ...this.state.locale !== void 0 ? { locale: this.state.locale } : {},
-      ...this.state.deliveryArea !== void 0 ? { deliveryArea: this.state.deliveryArea } : {}
-    };
-  }
-  withNamespaces(namespaces) {
-    return new _I18nBuilderMultiReadyImpl(this.engine, this.options, {
-      ...this.clone(),
-      namespaces
-    });
-  }
-  withLocale(locale) {
-    const { deliveryArea: _deliveryArea, ...rest } = this.clone();
-    return new I18nBuilderMultiForLocaleImpl(this.engine, this.options, { ...rest, locale });
-  }
-  withDeliveryArea(area) {
-    const { locale: _locale, ...rest } = this.clone();
-    return new I18nBuilderMultiPartitionedImpl(this.engine, this.options, { ...rest, deliveryArea: area });
-  }
-  async load() {
-    await applyMultiBuilderLoad(this.engine, this.options, this.state);
-    return this.engine.toScope({ namespaces: this.state.namespaces });
-  }
-};
-var I18nBuilderMultiPartitionedImpl = class _I18nBuilderMultiPartitionedImpl {
-  constructor(engine, options, state) {
-    this.engine = engine;
-    this.options = options;
-    this.state = state;
+  partitionForLocale;
+  async load(input) {
+    await applyHandleLoad(this.engine, this.options, input, this.partitionForLocale);
+    return this.engine.toScope({ namespaces: input.namespaces }).forLocale(input.locale);
   }
-  engine;
-  options;
-  state;
-  withNamespaces(namespaces) {
-    return new _I18nBuilderMultiPartitionedImpl(this.engine, this.options, {
-      ...this.state,
-      namespaces
-    });
+  peek(input) {
+    if (!areHandleResourcesReady(this.engine, this.options, input, this.partitionForLocale)) {
+      return null;
+    }
+    return this.engine.toScope({ namespaces: input.namespaces }).forLocale(input.locale);
   }
-  async load() {
-    await applyMultiBuilderLoad(this.engine, this.options, this.state);
-    return this.engine.toScope({ namespaces: this.state.namespaces });
+  serialize() {
+    return this.engine.serialize();
   }
 };
-var I18nBuilderMultiForLocaleImpl = class {
-  constructor(engine, options, state) {
-    this.engine = engine;
-    this.options = options;
-    this.state = state;
-  }
-  engine;
-  options;
-  state;
-  async load() {
-    await applyMultiBuilderLoad(this.engine, this.options, this.state);
-    return this.engine.toScope({ namespaces: this.state.namespaces }).forLocale(this.state.locale);
+function createI18nHandle(engine, options) {
+  return new I18nHandleImpl(engine, options);
+}
+function areHandleResourcesReady(engine, options, input, partitionForLocale) {
+  if (input.namespaces.length === 0) {
+    return false;
   }
-};
-async function applyMultiBuilderLoad(engine, options, state) {
-  if (state.namespaces.length === 0) {
-    throw new Error("[i18n] withNamespaces(...) is required before load().");
+  const partition = partitionForLocale(input.locale);
+  return input.namespaces.every((namespace) => {
+    const loader = options?.namespaceLoaders?.[namespace];
+    if (loader === void 0) {
+      return true;
+    }
+    return engine.hasBuilderResourceLoaded(namespace, partition);
+  });
+}
+async function applyHandleLoad(engine, options, input, partitionForLocale) {
+  if (input.namespaces.length === 0) {
+    throw new Error("[i18n] load() requires a non-empty namespaces array.");
   }
-  const partition = state.locale ?? state.deliveryArea;
+  const partition = partitionForLocale(input.locale);
   await Promise.all(
-    state.namespaces.map(async (namespace) => {
+    input.namespaces.map(async (namespace) => {
       const loader = options?.namespaceLoaders?.[namespace];
       if (loader === void 0) {
         return;
@@ -104,127 +59,25 @@ async function applyMultiBuilderLoad(engine, options, state) {
       if (engine.hasBuilderResourceLoaded(namespace, partition)) {
         return;
       }
-      const data = await invokeNamespaceLoader(loader, partition);
+      const data = await invokeNamespaceLoader(loader, partition, { locale: input.locale });
       engine.applyLoadMergeNamespace(namespace, data);
       engine.markBuilderResourceLoaded(namespace, partition);
     })
   );
 }
 
-// src/single-builder.ts
-var I18nBuilderSingleImpl = class _I18nBuilderSingleImpl {
-  constructor(engine, options, state) {
-    this.engine = engine;
-    this.options = options;
-    if (state !== void 0) {
-      this.state = {
-        ...state.locale !== void 0 ? { locale: state.locale } : {},
-        ...state.deliveryArea !== void 0 ? { deliveryArea: state.deliveryArea } : {}
-      };
-    }
-  }
-  engine;
-  options;
-  state = {};
-  clone() {
-    return {
-      ...this.state.locale !== void 0 ? { locale: this.state.locale } : {},
-      ...this.state.deliveryArea !== void 0 ? { deliveryArea: this.state.deliveryArea } : {}
-    };
-  }
-  withLocale(locale) {
-    const { deliveryArea: _deliveryArea, ...rest } = this.clone();
-    return new I18nBuilderSingleForLocaleImpl(
-      this.engine,
-      this.options,
-      { ...rest, locale }
-    );
-  }
-  withDeliveryArea(_area) {
-    const { locale: _locale, ...rest } = this.clone();
-    return new _I18nBuilderSingleImpl(this.engine, this.options, {
-      ...rest,
-      deliveryArea: _area
-    });
-  }
-  async load() {
-    await applySingleBuilderLoad(this.engine, this.options, this.state);
-    return this.engine.toScope();
-  }
-};
-var I18nBuilderSingleForLocaleImpl = class {
-  constructor(engine, options, state) {
-    this.engine = engine;
-    this.options = options;
-    this.state = state;
-  }
-  engine;
-  options;
-  state;
-  async load() {
-    await applySingleBuilderLoad(this.engine, this.options, this.state);
-    return this.engine.toScope({ locale: this.state.locale });
-  }
-};
-async function applySingleBuilderLoad(engine, options, state) {
-  const partition = state.locale ?? state.deliveryArea;
-  const loader = options?.dictionaryLoader;
-  if (loader !== void 0) {
-    if (engine.hasBuilderResourceLoaded(partition)) {
-      return;
-    }
-    const data = await invokeNamespaceLoader(loader, partition);
-    engine.applyLoadMergeSingle(data);
-    engine.markBuilderResourceLoaded(partition);
-  }
-}
-
-// src/builder.ts
-function isMultiEngine(engine) {
-  return engine.__i18nEngineMode === "multi";
-}
-function createI18nSingleBuilder(engine, options) {
-  return new I18nBuilderSingleImpl(engine, options);
-}
-function createI18nMultiBuilder(engine, options) {
-  return new I18nBuilderMultiInitialImpl(engine, options);
-}
-function createI18nBuilder(engine, options) {
-  if (isMultiEngine(engine)) {
-    return createI18nMultiBuilder(
-      engine,
-      options
-    );
-  }
-  return createI18nSingleBuilder(
-    engine,
-    options
-  );
-}
-
-// src/deep-freeze.ts
-function deepFreeze(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Object.isFrozen(value)) {
-    return value;
-  }
-  Object.freeze(value);
-  for (const child of Object.values(value)) {
-    deepFreeze(child);
-  }
-  return value;
-}
-function cloneAndFreeze(value) {
-  return deepFreeze(structuredClone(value));
+// src/serialized-state.ts
+function normalizeI18nCreateInput(value) {
+  return {
+    dictionary: value?.dictionary ?? {},
+    resources: value?.resources ?? []
+  };
 }
 
 // src/builder-load-registry.ts
 function formatBuilderResourceKey(namespace, partition) {
-  return `${namespace}\0${partition ?? ""}`;
+  return `${namespace}\0${partition}`;
 }
-var SINGLE_BUILDER_RESOURCE = "__dictionary__";
 var BuilderLoadRegistry = class {
   loaded = /* @__PURE__ */ new Set();
   has(namespace, partition) {
@@ -233,6 +86,20 @@ var BuilderLoadRegistry = class {
   mark(namespace, partition) {
     this.loaded.add(formatBuilderResourceKey(namespace, partition));
   }
+  /** Snapshot of loaded resources as `[namespace, partition]` tuples. */
+  entries() {
+    const out = [];
+    for (const key of this.loaded) {
+      const sep = key.indexOf("\0");
+      out.push([key.slice(0, sep), key.slice(sep + 1)]);
+    }
+    return out;
+  }
+  seed(resources) {
+    for (const [namespace, partition] of resources) {
+      this.mark(namespace, partition);
+    }
+  }
 };
 
 // src/resolve-locale.ts
@@ -360,328 +227,7 @@ function resolveAndFormat(options) {
   }
 }
 
-// src/icu/extract-variables.ts
-function isPluralOrOrdinalNode(node) {
-  return node.type === 6 && "pluralType" in node && Boolean(node.pluralType);
-}
-function hasVariableName(node) {
-  return "value" in node && typeof node.value === "string";
-}
-function addVariableMeta(variables, name, type, role) {
-  const existing = variables[name];
-  if (!existing) {
-    variables[name] = { type, roles: /* @__PURE__ */ new Set([role]) };
-    return;
-  }
-  existing.roles.add(role);
-  existing.type = mergeVariableTypes(existing.type, type);
-}
-function mergeVariableTypes(left, right) {
-  if (left === right) {
-    return left;
-  }
-  if (left === "string" && right === "number" || left === "number" && right === "string") {
-    return "number";
-  }
-  return right;
-}
-function extractVariableMeta(nodes) {
-  const variables = {};
-  const walk = (walkNodes) => {
-    for (const node of walkNodes) {
-      if (node.type === 1 && hasVariableName(node)) {
-        addVariableMeta(variables, node.value, "string", "simple");
-      } else if (node.type === 2 && hasVariableName(node)) {
-        addVariableMeta(variables, node.value, "number", "number");
-      } else if (isPluralOrOrdinalNode(node) && hasVariableName(node)) {
-        const role = node.pluralType === "ordinal" ? "selectordinal" : "plural";
-        addVariableMeta(variables, node.value, "number", role);
-      } else if (node.type === 3 && hasVariableName(node)) {
-        addVariableMeta(variables, node.value, "date", "date");
-      } else if (node.type === 4 && hasVariableName(node)) {
-        addVariableMeta(variables, node.value, "date", "time");
-      } else if (node.type === 5 && hasVariableName(node)) {
-        addVariableMeta(variables, node.value, "string", "select");
-      }
-      if ("options" in node && node.options) {
-        for (const option of Object.values(node.options)) {
-          walk(option.value);
-        }
-      }
-      if ("children" in node && Array.isArray(node.children)) {
-        walk(node.children);
-      }
-    }
-  };
-  walk(nodes);
-  return variables;
-}
-function variableMetaToSpec(meta) {
-  return Object.fromEntries(Object.entries(meta).map(([name, entry]) => [name, entry.type]));
-}
-function inferMergedVariableType(roles) {
-  const hasPlural = roles.has("plural");
-  const hasSelectordinal = roles.has("selectordinal");
-  const hasSelect = roles.has("select");
-  const hasSimple = roles.has("simple");
-  const hasNumber = roles.has("number");
-  const hasDate = roles.has("date");
-  const hasTime = roles.has("time");
-  if (hasPlural && hasSelectordinal) {
-    return "CONFLICT";
-  }
-  if (hasSelect && (hasPlural || hasSelectordinal || hasNumber)) {
-    return "CONFLICT";
-  }
-  if (hasPlural && hasSelect) {
-    return "CONFLICT";
-  }
-  if (hasSelectordinal && hasSelect) {
-    return "CONFLICT";
-  }
-  if (hasDate || hasTime) {
-    if (hasPlural || hasSelect || hasSelectordinal || hasSimple || hasNumber) {
-      return "CONFLICT";
-    }
-    return "date";
-  }
-  if (hasPlural || hasSelectordinal || hasNumber) {
-    return "number";
-  }
-  if (hasSelect || hasSimple) {
-    return "string";
-  }
-  return "string";
-}
-function mergeVariableMetaAcrossLocales(localeMetas) {
-  const keySignatures = localeMetas.map((meta) => Object.keys(meta).sort().join(","));
-  if (new Set(keySignatures).size > 1) {
-    return {
-      ok: false,
-      message: `Inconsistent ICU variable names across locales (keys: ${keySignatures.join(" vs ")})`
-    };
-  }
-  const merged = {};
-  const variableNames = new Set(localeMetas.flatMap((meta) => Object.keys(meta)));
-  for (const variableName of variableNames) {
-    const combinedRoles = /* @__PURE__ */ new Set();
-    for (const meta of localeMetas) {
-      for (const role of meta[variableName]?.roles ?? []) {
-        combinedRoles.add(role);
-      }
-    }
-    const mergedType = inferMergedVariableType(combinedRoles);
-    if (mergedType === "CONFLICT") {
-      const rolesByLocale = localeMetas.map((meta) => {
-        const entry = meta[variableName];
-        if (!entry) {
-          return null;
-        }
-        return [...entry.roles].sort().join("|");
-      }).filter((value) => value !== null);
-      return {
-        ok: false,
-        message: `Incompatible ICU variable "${variableName}" across locales (roles: ${rolesByLocale.join(" vs ")})`
-      };
-    }
-    merged[variableName] = mergedType;
-  }
-  return { ok: true, merged };
-}
-function parseTemplate(template) {
-  try {
-    const ast = parse(template);
-    const meta = extractVariableMeta(ast);
-    return { ok: true, args: variableMetaToSpec(meta), meta };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { ok: false, message };
-  }
-}
-
-// src/patch-key.ts
-function preloadKeySingle(key, locale) {
-  return `${key}:${locale}`;
-}
-function preloadKeyMulti(namespace, key, locale) {
-  return `${namespace}:${key}:${locale}`;
-}
-function seedPreloadedKeysSingle(dictionary, preloadedKeys) {
-  for (const [key, localeByKey] of Object.entries(dictionary)) {
-    if (localeByKey === void 0 || typeof localeByKey !== "object") {
-      continue;
-    }
-    for (const locale of Object.keys(localeByKey)) {
-      preloadedKeys.add(preloadKeySingle(key, locale));
-    }
-  }
-}
-function seedPreloadedKeysMulti(dictionary, preloadedKeys) {
-  for (const [namespace, keyDictionary] of Object.entries(dictionary)) {
-    if (keyDictionary === void 0 || typeof keyDictionary !== "object") {
-      continue;
-    }
-    for (const [key, localeByKey] of Object.entries(keyDictionary)) {
-      if (localeByKey === void 0 || typeof localeByKey !== "object") {
-        continue;
-      }
-      for (const locale of Object.keys(localeByKey)) {
-        preloadedKeys.add(preloadKeyMulti(namespace, key, locale));
-      }
-    }
-  }
-}
-function recordPreloadedKeysSingle(partial, preloadedKeys) {
-  for (const [key, incomingLocales] of Object.entries(partial)) {
-    if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
-      continue;
-    }
-    for (const locale of Object.keys(incomingLocales)) {
-      preloadedKeys.add(preloadKeySingle(key, locale));
-    }
-  }
-}
-function recordPreloadedKeysMulti(namespace, partial, preloadedKeys) {
-  for (const [key, incomingLocales] of Object.entries(partial)) {
-    if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
-      continue;
-    }
-    for (const locale of Object.keys(incomingLocales)) {
-      preloadedKeys.add(preloadKeyMulti(namespace, key, locale));
-    }
-  }
-}
-function collectLocaleMetasForKey(localeByKey, patchedLocale, patchedMeta) {
-  const localeMetas = [patchedMeta];
-  for (const [locale, template] of Object.entries(localeByKey)) {
-    if (locale === patchedLocale) {
-      continue;
-    }
-    const parsed = parseTemplate(template);
-    if (parsed.ok) {
-      localeMetas.push(parsed.meta);
-    }
-  }
-  return localeMetas;
-}
-function assertPatchKeySingle(key, locale, template, preloadedKeys, localeByKey) {
-  if (!preloadedKeys.has(preloadKeySingle(key, locale))) {
-    throw new Error(`[i18n] Key not preloaded: ${key} (${locale})`);
-  }
-  const parsed = parseTemplate(template);
-  if (!parsed.ok) {
-    throw new Error(`[i18n] ICU syntax error on patch: ${parsed.message}`);
-  }
-  const localeMetas = collectLocaleMetasForKey(localeByKey ?? {}, locale, parsed.meta);
-  const merged = mergeVariableMetaAcrossLocales(localeMetas);
-  if (!merged.ok) {
-    throw new Error(`[i18n] ICU args mismatch on patch: ${merged.message}`);
-  }
-}
-function assertPatchKeyMulti(namespace, key, locale, template, preloadedKeys, localeByKey) {
-  if (!preloadedKeys.has(preloadKeyMulti(namespace, key, locale))) {
-    throw new Error(`[i18n] Key not preloaded: ${namespace}.${key} (${locale})`);
-  }
-  const parsed = parseTemplate(template);
-  if (!parsed.ok) {
-    throw new Error(`[i18n] ICU syntax error on patch: ${parsed.message}`);
-  }
-  const localeMetas = collectLocaleMetasForKey(localeByKey ?? {}, locale, parsed.meta);
-  const merged = mergeVariableMetaAcrossLocales(localeMetas);
-  if (!merged.ok) {
-    throw new Error(`[i18n] ICU args mismatch on patch: ${merged.message}`);
-  }
-}
-
 // src/project-locales.ts
-function classifyAreaLocales(areaLocales, localeFallback) {
-  const areaSet = new Set(areaLocales);
-  const full = [];
-  const preserve = [];
-  for (const locale of areaLocales) {
-    const fallback = localeFallback?.[locale];
-    if (fallback !== null && fallback !== void 0 && areaSet.has(fallback)) {
-      preserve.push(locale);
-    } else {
-      full.push(locale);
-    }
-  }
-  return { full, preserve };
-}
-function projectKeyDictionary(dictionary, locales, localeFallback) {
-  const targetLocales = [...new Set(locales)];
-  const result = {};
-  for (const [key, localesByKey] of Object.entries(dictionary)) {
-    const projected = {};
-    for (const locale of targetLocales) {
-      const resolved = resolveLocaleTemplate(localesByKey, locale, localeFallback);
-      if (resolved !== void 0) {
-        projected[locale] = resolved.template;
-      }
-    }
-    if (Object.keys(projected).length > 0) {
-      result[key] = projected;
-    }
-  }
-  return result;
-}
-function projectNamespaceLocalesCore(dictionary, locales, localeFallback) {
-  return projectKeyDictionary(dictionary, locales, localeFallback);
-}
-function projectNamespaceForDeliveryAreaCore(dictionary, areaLocales, localeFallback) {
-  const { full, preserve } = classifyAreaLocales(areaLocales, localeFallback);
-  const fullProjection = full.length > 0 ? projectKeyDictionary(dictionary, full, localeFallback) : void 0;
-  const result = {};
-  for (const [key, localesByKey] of Object.entries(dictionary)) {
-    const projected = {};
-    if (fullProjection !== void 0) {
-      const fullEntry = fullProjection[key];
-      if (fullEntry !== void 0) {
-        Object.assign(projected, fullEntry);
-      }
-    }
-    for (const locale of preserve) {
-      const template = localesByKey[locale];
-      if (template !== void 0) {
-        projected[locale] = template;
-      }
-    }
-    if (Object.keys(projected).length > 0) {
-      result[key] = projected;
-    }
-  }
-  return result;
-}
-function projectDictionaryForDeliveryAreaCore(dictionary, areaLocales, localeFallback) {
-  const result = {};
-  for (const namespace of Object.keys(dictionary)) {
-    const namespaceDictionary = dictionary[namespace];
-    if (namespaceDictionary === void 0) {
-      continue;
-    }
-    result[namespace] = projectNamespaceForDeliveryAreaCore(
-      namespaceDictionary,
-      areaLocales,
-      localeFallback
-    );
-  }
-  return result;
-}
-function projectDictionaryLocalesCore(dictionary, locales, localeFallback) {
-  const result = {};
-  for (const namespace of Object.keys(dictionary)) {
-    const namespaceDictionary = dictionary[namespace];
-    if (namespaceDictionary === void 0) {
-      continue;
-    }
-    result[namespace] = projectKeyDictionary(
-      namespaceDictionary,
-      locales,
-      localeFallback
-    );
-  }
-  return result;
-}
 function mergeNamespaceLocalesCore(existing, incoming) {
   const merged = structuredClone(existing);
   for (const [key, incomingLocales] of Object.entries(incoming)) {
@@ -710,112 +256,6 @@ function mergeDictionaryLocalesCore(existing, incoming) {
   return merged;
 }
 
-// src/scope-single.ts
-var I18nScopeSingleImpl = class {
-  constructor(engine) {
-    this.engine = engine;
-  }
-  engine;
-  t = (key, locale, ...args) => {
-    const params = args[0];
-    return this.engine.getWithLocale(String(key), locale, params);
-  };
-  forLocale = (locale) => {
-    return new I18nScopeSingleForLocaleImpl(this.engine, locale);
-  };
-};
-var I18nScopeSingleForLocaleImpl = class _I18nScopeSingleForLocaleImpl {
-  constructor(engine, locale) {
-    this.engine = engine;
-    this.locale = locale;
-  }
-  engine;
-  locale;
-  t = (key, ...args) => {
-    const params = args[0];
-    return this.engine.getWithLocale(String(key), this.locale, params);
-  };
-  set = (key, template) => {
-    this.engine.patchKey(String(key), this.locale, template);
-  };
-  forLocale = (locale) => {
-    return new _I18nScopeSingleForLocaleImpl(this.engine, locale);
-  };
-};
-
-// src/IcuTranslationProviderSingle.ts
-var IcuTranslationProviderSingle = class {
-  __i18nEngineMode = "single";
-  dictionary;
-  compiledCache = {};
-  preloadedKeys = /* @__PURE__ */ new Set();
-  builderLoadRegistry = new BuilderLoadRegistry();
-  localeFallback;
-  onMissing;
-  constructor(dictionary, options) {
-    this.dictionary = structuredClone(dictionary);
-    seedPreloadedKeysSingle(this.dictionary, this.preloadedKeys);
-    if (options?.localeFallback) {
-      validateLocaleFallback(options.localeFallback);
-      this.localeFallback = options.localeFallback;
-    }
-    this.onMissing = options?.onMissing ?? "throw";
-  }
-  getWithLocale(key, locale, params) {
-    return resolveAndFormat({
-      localeByKey: this.dictionary[key],
-      locale,
-      params,
-      getCache: (resolvedLocale) => {
-        if (!this.compiledCache[resolvedLocale]) {
-          this.compiledCache[resolvedLocale] = {};
-        }
-        return this.compiledCache[resolvedLocale];
-      },
-      context: {
-        key,
-        locale,
-        localeFallback: this.localeFallback,
-        onMissing: this.onMissing
-      }
-    });
-  }
-  toScope(options) {
-    if (options?.locale !== void 0) {
-      return new I18nScopeSingleForLocaleImpl(this, options.locale);
-    }
-    return new I18nScopeSingleImpl(this);
-  }
-  getAll() {
-    return cloneAndFreeze(this.dictionary);
-  }
-  hasBuilderResourceLoaded(partition) {
-    return this.builderLoadRegistry.has(SINGLE_BUILDER_RESOURCE, partition);
-  }
-  markBuilderResourceLoaded(partition) {
-    this.builderLoadRegistry.mark(SINGLE_BUILDER_RESOURCE, partition);
-  }
-  applyLoadMergeSingle(values) {
-    this.dictionary = mergeNamespaceLocalesCore(this.dictionary, values);
-    recordPreloadedKeysSingle(values, this.preloadedKeys);
-    for (const [key, incomingLocales] of Object.entries(values)) {
-      if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
-        continue;
-      }
-      for (const locale of Object.keys(incomingLocales)) {
-        delete this.compiledCache[locale]?.[key];
-      }
-    }
-  }
-  patchKey(key, locale, template) {
-    assertPatchKeySingle(key, locale, template, this.preloadedKeys, this.dictionary[key]);
-    this.dictionary = mergeNamespaceLocalesCore(this.dictionary, {
-      [key]: { [locale]: template }
-    });
-    delete this.compiledCache[locale]?.[key];
-  }
-};
-
 // src/scope-multi.ts
 var I18nScopeMultiImpl = class {
   constructor(engine) {
@@ -841,9 +281,6 @@ var I18nScopeMultiForLocaleImpl = class _I18nScopeMultiForLocaleImpl {
     const params = args[0];
     return this.engine.getWithLocale(String(namespace), String(key), this.locale, params);
   };
-  set = (namespace, key, template) => {
-    this.engine.patchKeyMulti(String(namespace), String(key), this.locale, template);
-  };
   forLocale = (locale) => {
     return new _I18nScopeMultiForLocaleImpl(this.engine, locale);
   };
@@ -852,15 +289,14 @@ var I18nScopeMultiForLocaleImpl = class _I18nScopeMultiForLocaleImpl {
 // src/IcuTranslationProviderMulti.ts
 var IcuTranslationProviderMulti = class {
   __i18nEngineMode = "multi";
+  /** Loaded namespaces only — cold start is `{}`; never claim full Schema until loaded. */
   dictionary;
   compiledCache = {};
-  preloadedKeys = /* @__PURE__ */ new Set();
   builderLoadRegistry = new BuilderLoadRegistry();
   localeFallback;
   onMissing;
-  constructor(dictionary, options) {
+  constructor(dictionary = {}, options) {
     this.dictionary = structuredClone(dictionary);
-    seedPreloadedKeysMulti(this.dictionary, this.preloadedKeys);
     if (options?.localeFallback) {
       validateLocaleFallback(options.localeFallback);
       this.localeFallback = options.localeFallback;
@@ -897,8 +333,9 @@ var IcuTranslationProviderMulti = class {
     }
     return new I18nScopeMultiImpl(this);
   }
+  /** Live dictionary reference (loaded namespaces only). Do not mutate. */
   getAll() {
-    return cloneAndFreeze(this.dictionary);
+    return this.dictionary;
   }
   hasBuilderResourceLoaded(namespace, partition) {
     return this.builderLoadRegistry.has(namespace, partition);
@@ -906,14 +343,22 @@ var IcuTranslationProviderMulti = class {
   markBuilderResourceLoaded(namespace, partition) {
     this.builderLoadRegistry.mark(namespace, partition);
   }
+  seedBuilderResources(resources) {
+    this.builderLoadRegistry.seed(resources);
+  }
+  serialize() {
+    return {
+      dictionary: this.dictionary,
+      resources: this.builderLoadRegistry.entries()
+    };
+  }
   applyLoadMergeNamespace(namespace, values) {
-    const existing = this.dictionary[namespace];
-    const merged = mergeNamespaceLocalesCore(existing ?? {}, values);
+    const existing = this.dictionary[namespace] ?? {};
+    const merged = mergeNamespaceLocalesCore(existing, values);
     this.dictionary = {
       ...this.dictionary,
       [namespace]: merged
     };
-    recordPreloadedKeysMulti(namespace, values, this.preloadedKeys);
     for (const [key, incomingLocales] of Object.entries(values)) {
       if (incomingLocales === void 0 || typeof incomingLocales !== "object") {
         continue;
@@ -931,17 +376,8 @@ var IcuTranslationProviderMulti = class {
       }
     }
   }
-  patchKeyMulti(namespace, key, locale, template) {
-    const namespaceDictionary = this.dictionary[namespace];
-    const localeByKey = namespaceDictionary?.[key];
-    assertPatchKeyMulti(namespace, key, locale, template, this.preloadedKeys, localeByKey);
-    this.applyLoadMergeNamespace(
-      namespace,
-      { [key]: { [locale]: template } }
-    );
-  }
 };
 
-export { IcuTranslationProviderMulti, IcuTranslationProviderSingle, createI18nBuilder, createI18nMultiBuilder, createI18nSingleBuilder, formatLocaleFallbackChain, invokeNamespaceLoader, mergeDictionaryLocalesCore, mergeNamespaceLocalesCore, projectDictionaryForDeliveryAreaCore, projectDictionaryLocalesCore, projectNamespaceForDeliveryAreaCore, projectNamespaceLocalesCore, resolveLocaleTemplate, validateLocaleFallback };
+export { IcuTranslationProviderMulti, createI18nHandle, formatLocaleFallbackChain, invokeNamespaceLoader, mergeDictionaryLocalesCore, mergeNamespaceLocalesCore, normalizeI18nCreateInput, resolveLocaleTemplate, validateLocaleFallback };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map