@blamejs/blamejs-shop 0.5.12 → 0.5.13

package/lib/vendor/blamejs/test/layer-0-primitives/i18n.test.js

@@ -804,6 +804,279 @@ async function run() {
   testLazyLoadRejectsInlineTranslations();
   testEagerLocalesValidation();
   testLocaleChain();
+
+  // Adversarial / defensive branch coverage + bug guards
+  testDirCustomRtlCaseInsensitive();
+  testNamespaceShadowFallsBack();
+  testKeyValidation();
+  testGetTranslationsFor();
+  testSetLocaleNonConfigured();
+  testFormatterCallSiteThrows();
+  testMessageFormatViaT();
+  testMessageFormatNamespaceSurface();
+  testInterpolationSameDelimiter();
+  testMiddlewareResolver();
+  testLocaleChainFallbackValidation();
+
+  // Deeper adversarial / defensive branch coverage
+  testValidationDeepBranches();
+  testResolveLocaleBadOverride();
+  testTnNonFiniteCount();
+  testPluralCategoryFallsToOther();
+  testNegotiateReverseMatch();
+  testMiddlewareEdgeCases();
+  testLoadDirReadFailure();
+  testDisplayNameCurrencyScript();
+  testFormatDateNumberAndString();
+  testInterpolationUnclosedDefault();
+
+  // Bulk feature-path coverage
+  testFallbackLocaleDistinctFromDefault();
+  testEmptyAndDottedThroughLeaf();
+  testPluralWithoutCount();
+  testTnToWithExtraVars();
+  testFormatNumberStyles();
+  testFormatDateStyles();
+  testFormatRelativeNumeric();
+  testFormatListStyles();
+  testDisplayNameLocaleOverride();
+  testLocalesGetterCopy();
+  testChainThroughUnpopulatedLocale();
+  testNegotiationEdgeBranches();
+  testLazyLoadDefaultEagerOnly();
+  testObservabilitySinkThrowSwallowed();
+  testMiddlewareBoundHelpers();
+  testMiddlewareCatchNeverCrashes();
+  testMiddlewareCustomHeaderName();
+  testMessageFormatFeaturePathsViaT();
+  testLocaleChainFalsyOpts();
+
+  // Residual defensive-branch coverage + untrusted-input edges
+  testUnvalidatedLocaleTreeStillValidated();
+  testBareStringLocaleTreeFallsThrough();
+  testPluralNonNumericCountInVars();
+  testTnCountArgOverridesVarsCount();
+  testInterpolationTrimsPlaceholderWhitespace();
+  testDirReflectsCurrentLocaleAfterSetLocale();
+  testMiddlewareResolverNonStringReturn();
+  testMiddlewareNonStringExplicitSourcesIgnored();
+}
+
+// create() must reject every malformed sub-opt shape at boot (the
+// config-time throw tier), not just the ones the happy-path tests touch.
+function testValidationDeepBranches() {
+  function throwsCreate(opts) {
+    try { b.i18n.create(opts); return false; } catch (_e) { return true; }
+  }
+  var base = { defaultLocale: "en", locales: ["en"] };
+  function withBase(extra) { return Object.assign({}, base, extra); }
+
+  check("interpolation as a non-object throws",
+        throwsCreate(withBase({ interpolation: 42 })));
+  check("interpolation.end empty string throws",
+        throwsCreate(withBase({ interpolation: { end: "" } })));
+  check("interpolation.escape non-function throws",
+        throwsCreate(withBase({ interpolation: { escape: 42 } })));
+  check("interpolation.strict non-boolean throws",
+        throwsCreate(withBase({ interpolation: { strict: "yes" } })));
+
+  check("rtlLanguages non-array throws",
+        throwsCreate(withBase({ rtlLanguages: "ar" })));
+  check("rtlLanguages with an empty-string entry throws",
+        throwsCreate(withBase({ rtlLanguages: ["ar", ""] })));
+  check("rtlLanguages with a non-string entry throws",
+        throwsCreate(withBase({ rtlLanguages: ["ar", 42] })));
+
+  check("translations as an array throws",
+        throwsCreate(withBase({ translations: [] })));
+  check("translations as null throws",
+        throwsCreate(withBase({ translations: null })));
+
+  check("fallbackLocale with an invalid BCP 47 tag throws",
+        throwsCreate({ defaultLocale: "en", locales: ["en", "es"], fallbackLocale: "not_a_tag" }));
+  check("fallbackLocale not present in locales throws",
+        throwsCreate({ defaultLocale: "en", locales: ["en", "es"], fallbackLocale: "fr" }));
+
+  // Translation-tree leaf that is neither a string nor a nested object.
+  check("translation leaf that is a number throws at load",
+        throwsCreate(withBase({ translations: { en: { count: 5 } } })));
+  check("translation leaf that is an array throws at load",
+        throwsCreate(withBase({ translations: { en: { list: [1, 2] } } })));
+
+  check("eagerLocales as a non-array throws",
+        throwsCreate({ defaultLocale: "en", locales: ["en"], lazyLoad: true, dir: "/x", eagerLocales: "en" }));
+}
+
+// A caller-supplied locale override of the wrong type or a malformed tag
+// throws BAD_LOCALE at the call site (not silently coerced) — the same
+// _resolveLocale guard for every t / formatter / dir entry point.
+function testResolveLocaleBadOverride() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { greet: "Hello" } },
+  });
+  function throwsAt(fn) { try { fn(); return false; } catch (_e) { return true; } }
+
+  check("t() with a non-string locale override throws",
+        throwsAt(function () { i.t("greet", null, { locale: 42 }); }));
+  check("t() with a malformed locale override tag throws",
+        throwsAt(function () { i.t("greet", null, { locale: "not_a_tag" }); }));
+  check("formatNumber() with a malformed locale override throws",
+        throwsAt(function () { i.formatNumber(5, undefined, { locale: "not_a_tag" }); }));
+  check("dir() with a non-string locale override throws",
+        throwsAt(function () { i.dir({ locale: 42 }); }));
+  check("has() with a malformed locale override throws",
+        throwsAt(function () { i.has("greet", { locale: "not_a_tag" }); }));
+
+  // A null/undefined override resolves the current locale (no throw).
+  check("t() with a null locale override uses the current locale",
+        i.t("greet", null, { locale: null }) === "Hello");
+}
+
+function testTnNonFiniteCount() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { items: { one: "{count} item", other: "{count} items" } } },
+  });
+  function throwsAt(fn) { try { fn(); return false; } catch (_e) { return true; } }
+  check("tn() rejects NaN count",       throwsAt(function () { i.tn("items", NaN); }));
+  check("tn() rejects Infinity count",  throwsAt(function () { i.tn("items", Infinity); }));
+  check("tn() rejects a non-number count",
+        throwsAt(function () { i.tn("items", "5"); }));
+}
+
+// When Intl.PluralRules selects a CLDR category the translation entry does
+// not declare, _selectPlural falls back to the mandatory `other` key rather
+// than rendering undefined.
+function testPluralCategoryFallsToOther() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "ru"],
+    translations: {
+      en: { items: { one: "{count} item", other: "{count} items" } },
+      // Russian selects "few" for 2 and "many" for 5, but this entry only
+      // declares one + other — both must fall through to `other`.
+      ru: { items: { one: "{count} штука", other: "{count} (other)" } },
+    },
+  });
+  check("ru count=2 (selects 'few', not declared) → falls to other",
+        i.tn("items", 2, null, { locale: "ru" }) === "2 (other)");
+  check("ru count=5 (selects 'many', not declared) → falls to other",
+        i.tn("items", 5, null, { locale: "ru" }) === "5 (other)");
+}
+
+// Reverse negotiation: a broad requested tag ("pt") resolves to a more
+// specific configured tag ("pt-BR") when no exact / prefix match exists.
+function testNegotiateReverseMatch() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "pt-BR"],
+    translations:  { en: { greet: "Hello" }, "pt-BR": { greet: "Oi" } },
+  });
+  var mw = i.middleware();
+  var req = _mockReq();
+  req.headers = { "accept-language": "pt" };
+  mw(req, _mockRes(), function () {});
+  check("broad requested 'pt' reverse-matches configured 'pt-BR'",
+        req.locale === "pt-BR");
+  check("req.t bound to the reverse-matched locale",
+        req.t("greet") === "Oi");
+}
+
+function testMiddlewareEdgeCases() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es"],
+    translations:  { en: { greet: "Hello" }, es: { greet: "Hola" } },
+  });
+
+  // res is null (next-only pipelines): must bind req.* and not crash.
+  var mwNoRes = i.middleware();
+  var reqNoRes = _mockReq();
+  reqNoRes.headers = { "accept-language": "es" };
+  var nextCalled = false;
+  var crashed = false;
+  try { mwNoRes(reqNoRes, null, function () { nextCalled = true; }); }
+  catch (_e) { crashed = true; }
+  check("middleware with res=null does not crash", crashed === false);
+  check("middleware with res=null still binds req.locale + calls next",
+        reqNoRes.locale === "es" && nextCalled === true);
+
+  // cookieName configured but the request carries no cookies → falls through
+  // to header negotiation without crashing.
+  var mwCookie = i.middleware({ cookieName: "lang" });
+  var reqCookie = _mockReq();
+  reqCookie.headers = { "accept-language": "es" };
+  // no reqCookie.cookies at all
+  mwCookie(reqCookie, _mockRes(), function () {});
+  check("cookieName set but no cookies present → header negotiation",
+        reqCookie.locale === "es");
+
+  // Explicit query value that is not a configured locale falls through.
+  var mwQuery = i.middleware();
+  var reqQuery = _mockReq();
+  reqQuery.headers = { "accept-language": "es" };
+  reqQuery.query = { lang: "zz-not-configured" };
+  mwQuery(reqQuery, _mockRes(), function () {});
+  check("query lang not in configured set → header negotiation",
+        reqQuery.locale === "es");
+}
+
+// _loadFromDir surfaces a read failure (not just missing/parse) as a typed
+// LOAD_FAILED — a path that exists but cannot be read as a file (a directory
+// standing where <locale>.json is expected) exercises the read-error branch.
+function testLoadDirReadFailure() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-i18n-readfail-"));
+  try {
+    fs.writeFileSync(path.join(tmpDir, "en.json"), JSON.stringify({ greet: "Hello" }));
+    // Create a DIRECTORY named de.json so existsSync() is true but reading
+    // it as a file throws EISDIR.
+    fs.mkdirSync(path.join(tmpDir, "de.json"));
+    var threw = false;
+    try {
+      b.i18n.create({ defaultLocale: "en", locales: ["en", "de"], dir: tmpDir });
+    } catch (_e) { threw = true; }
+    check("unreadable locale file (directory) throws LOAD_FAILED", threw);
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+}
+
+function testDisplayNameCurrencyScript() {
+  var i = b.i18n.create({ defaultLocale: "en", locales: ["en"] });
+  var cur = i.displayName("USD", "currency");
+  check("displayName currency type returns a non-empty string",
+        typeof cur === "string" && cur.length > 0);
+  var scr = i.displayName("Latn", "script");
+  check("displayName script type returns a non-empty string",
+        typeof scr === "string" && scr.length > 0);
+}
+
+// formatDate accepts a Date, a numeric epoch, or a parseable string — the
+// two non-Date branches beyond the happy-path Date input.
+function testFormatDateNumberAndString() {
+  var i = b.i18n.create({ defaultLocale: "en-US", locales: ["en-US"] });
+  var epoch = Date.UTC(2024, 0, 15);
+  var fromNum = i.formatDate(epoch, { year: "numeric", month: "long", day: "numeric", timeZone: "UTC" });
+  check("formatDate from a numeric epoch renders 2024",
+        /2024/.test(fromNum) && /January/.test(fromNum));
+  var fromStr = i.formatDate("2024-01-15T00:00:00Z", { year: "numeric", timeZone: "UTC" });
+  check("formatDate from a parseable string renders 2024",
+        /2024/.test(fromStr));
+}
+
+// An unclosed default {var} delimiter is rendered literally (never crashes,
+// never drops the tail of the template).
+function testInterpolationUnclosedDefault() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { partial: "Hello {name" } },
+  });
+  check("unclosed {var} delimiter renders literally",
+        i.t("partial", { name: "Bob" }) === "Hello {name");
 }
 
 function testLocaleChain() {
@@ -1003,7 +1276,886 @@ function testEagerLocalesValidation() {
   check("eagerLocales: must be subset of locales", threw);
 }
 
-module.exports = { run: run };
+// ---- Adversarial / defensive branch coverage ----
+
+// dir() folds the requested locale's primary subtag to lower case before
+// the RTL-membership test. A custom rtlLanguages list must be folded the
+// same way — otherwise an operator-supplied entry like "AR" or "CKB"
+// silently never matches and an RTL language renders left-to-right.
+function testDirCustomRtlCaseInsensitive() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    rtlLanguages:  ["AR", "ckb", "KU"],   // mixed / upper-case custom entries
+  });
+  check("dir(ar) rtl even when custom list entry is upper-case 'AR'",
+        i.dir({ locale: "ar" }) === "rtl");
+  check("dir(AR-EG) rtl (subtag-stripped + case-folded)",
+        i.dir({ locale: "AR-EG" }) === "rtl");
+  check("dir(ku) rtl even when custom list entry is upper-case 'KU'",
+        i.dir({ locale: "ku" }) === "rtl");
+  check("dir(ckb) rtl (lower-case custom entry)",
+        i.dir({ locale: "ckb" }) === "rtl");
+  check("dir(en) ltr (not in custom rtl list)",
+        i.dir({ locale: "en" }) === "ltr");
+}
+
+// A key that resolves to a nested namespace object in the requested locale
+// must NOT shadow a real leaf translation defined in a fallback locale —
+// the lookup should skip the non-renderable namespace and keep walking the
+// fallback chain instead of leaking the raw key into the UI.
+function testNamespaceShadowFallsBack() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "fr"],
+    translations: {
+      en: { title: "English Title", greet: "Hello" },
+      fr: { title: { sub: "Sous-titre" }, greet: "Bonjour" },
+    },
+  });
+  check("namespace in requested locale falls through to fallback leaf",
+        i.t("title", null, { locale: "fr" }) === "English Title");
+  check("fr's own leaf still resolves normally",
+        i.t("greet", null, { locale: "fr" }) === "Bonjour");
+  check("has() reports true when a fallback locale supplies the leaf",
+        i.has("title", { locale: "fr" }) === true);
+
+  // Subtag-strip variant: pt-BR has a namespace, pt has the leaf.
+  var i2 = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "pt", "pt-BR"],
+    translations: {
+      en:      { menu: "Menu" },
+      pt:      { menu: "Menu PT" },
+      "pt-BR": { menu: { file: "Arquivo" } },   // namespace shadows the leaf
+    },
+  });
+  check("subtag-strip skips namespace shadow and resolves parent leaf",
+        i2.t("menu", null, { locale: "pt-BR" }) === "Menu PT");
+
+  // A namespace key with no leaf anywhere in the chain is still a miss.
+  var i3 = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { nav: { home: "Home" } } },
+  });
+  check("namespace key with no leaf in chain is a miss (returns key)",
+        i3.t("nav") === "nav");
+  check("has() false for a pure namespace key",
+        i3.has("nav") === false);
+}
+
+function testKeyValidation() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { greet: "Hello" } },
+  });
+  var threwNonString = false;
+  try { i.t(123); } catch (_e) { threwNonString = true; }
+  check("t() rejects non-string key", threwNonString);
+
+  var threwEmpty = false;
+  try { i.t(""); } catch (_e) { threwEmpty = true; }
+  check("t() rejects empty-string key", threwEmpty);
+
+  check("has() returns false for non-string key (no throw)",
+        i.has(123) === false);
+  check("has() returns false for empty key (no throw)",
+        i.has("") === false);
+}
+
+function testGetTranslationsFor() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { greet: "Hello" } },
+  });
+  var threw = false;
+  try { i.translations(123); } catch (_e) { threw = true; }
+  check("translations() rejects non-string locale", threw);
+  check("translations() returns null for an unloaded locale",
+        i.translations("zz") === null);
+  check("translations() returns the loaded tree for a known locale",
+        i.translations("en") && i.translations("en").greet === "Hello");
+}
+
+// setLocale permits a valid-but-unconfigured tag (operators experiment);
+// it emits i18n.miss.locale and still resolves through the fallback chain.
+function testSetLocaleNonConfigured() {
+  var events = [];
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    observability: { event: function (name, _v, l) { events.push({ name: name, labels: l || {} }); } },
+    translations:  { en: { greet: "Hello" } },
+  });
+  i.setLocale("de");   // valid BCP 47, not in configured locales
+  check("setLocale accepts a valid non-configured tag", i.locale === "de");
+  check("setLocale emits i18n.miss.locale for a non-configured tag",
+        events.some(function (e) { return e.name === "i18n.miss.locale" && e.labels.requested === "de"; }));
+  check("t() under the non-configured locale falls through to defaultLocale",
+        i.t("greet") === "Hello");
+}
+
+// The formatter helpers throw a typed I18nError on the inputs they screen
+// (empty / non-array / bad enum) — the call-site-throw validation tier.
+function testFormatterCallSiteThrows() {
+  var i = b.i18n.create({ defaultLocale: "en", locales: ["en"] });
+
+  var threwUnit = false;
+  try { i.formatRelative(5, ""); } catch (_e) { threwUnit = true; }
+  check("formatRelative rejects empty unit", threwUnit);
+
+  var threwRelVal = false;
+  try { i.formatRelative(Infinity, "day"); } catch (_e) { threwRelVal = true; }
+  check("formatRelative rejects non-finite value", threwRelVal);
+
+  var threwList = false;
+  try { i.formatList("not-an-array"); } catch (_e) { threwList = true; }
+  check("formatList rejects non-array", threwList);
+
+  var threwCode = false;
+  try { i.displayName("", "language"); } catch (_e) { threwCode = true; }
+  check("displayName rejects empty code", threwCode);
+
+  var threwDateNull = false;
+  try { i.formatDate(null); } catch (_e) { threwDateNull = true; }
+  check("formatDate rejects null value", threwDateNull);
+}
+
+// ICU MessageFormat is auto-detected by t() when the entry carries
+// {arg, plural|select|selectordinal ...} syntax, or forced with
+// { messageFormat: true }. Drive the real t() consumer path.
+function testMessageFormatViaT() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations: {
+      en: {
+        role:  "{role, select, admin {Administrator} other {Member}}",
+        inbox: "You have {n, plural, =0 {no messages} one {# message} other {# messages}}.",
+        rank:  "{pos, selectordinal, one {#st} two {#nd} few {#rd} other {#th}} place",
+      },
+    },
+  });
+  check("t() auto-detects select and renders the matched case",
+        i.t("role", { role: "admin" }) === "Administrator");
+  check("t() select falls to 'other' for an unmatched case",
+        i.t("role", { role: "editor" }) === "Member");
+  check("t() plural exact =0 case",
+        i.t("inbox", { n: 0 }) === "You have no messages.");
+  check("t() plural 'one' with # placeholder",
+        i.t("inbox", { n: 1 }) === "You have 1 message.");
+  check("t() plural 'other' with # placeholder",
+        i.t("inbox", { n: 5 }) === "You have 5 messages.");
+  check("t() selectordinal renders ordinal category",
+        i.t("rank", { pos: 3 }) === "3rd place");
+  check("t() selectordinal teen-boundary (21 → 21st)",
+        i.t("rank", { pos: 21 }) === "21st place");
+
+  // Forcing messageFormat on a malformed template surfaces a typed error.
+  var iBad = b.i18n.create({
+    defaultLocale: "en", locales: ["en"],
+    translations:  { en: { broken: "{x, plural, one {a}}" } },   // missing 'other'
+  });
+  var threw = false;
+  try { iBad.t("broken", { x: 1 }, { messageFormat: true }); } catch (_e) { threw = true; }
+  check("t() with messageFormat:true throws on a malformed template", threw);
+}
+
+function testMessageFormatNamespaceSurface() {
+  var mf = b.i18n.messageFormat;
+  check("messageFormat namespace exposes format", typeof mf.format === "function");
+  check("messageFormat namespace exposes parse", typeof mf.parse === "function");
+  check("messageFormat namespace exposes looksLikeMessageFormat",
+        typeof mf.looksLikeMessageFormat === "function");
+  check("looksLikeMessageFormat true for plural syntax",
+        mf.looksLikeMessageFormat("{n, plural, other {x}}") === true);
+  check("looksLikeMessageFormat false for plain interpolation",
+        mf.looksLikeMessageFormat("Hello {name}") === false);
+  check("mf.format select matched case",
+        mf.format("{g, select, male {He} other {They}}", { g: "male" }) === "He");
+  check("mf.format select unmatched → other",
+        mf.format("{g, select, male {He} other {They}}", { g: "x" }) === "They");
+
+  // Prototype-pollution: an operator/end-user select value that names an
+  // Object.prototype member must fall through to the `other` case, not return
+  // an inherited member (which renders garbage, or throws when rendered as a
+  // non-array — a request DoS). Every case-map lookup is own-property only.
+  var protoKeys = ["__proto__", "constructor", "toString", "hasOwnProperty", "valueOf"];
+  for (var pk = 0; pk < protoKeys.length; pk++) {
+    var out;
+    try { out = mf.format("{g, select, male {He} other {They}}", { g: protoKeys[pk] }); }
+    catch (e3) { out = "THREW:" + (e3 && e3.message); }
+    check("mf.format select proto-key '" + protoKeys[pk] + "' falls to other (no proto leak / DoS)",
+          out === "They");
+  }
+  check("mf.format plural resolves its own `other` (no proto leak)",
+        mf.format("{n, plural, other {N items}}", { n: 5 }) === "N items");
+
+  // Malformed templates fail as typed errors, never a raw crash.
+  var threwUnclosed = false;
+  try { mf.parse("{x, plural, other {a"); } catch (e) {
+    threwUnclosed = (e && e.name === "I18nMessageFormatError");
+  }
+  check("mf.parse throws typed I18nMessageFormatError on unclosed body",
+        threwUnclosed);
+  var threwDeep = false;
+  try {
+    var deep = "";
+    for (var d = 0; d < 300; d++) deep += "{a,select,x{";
+    deep += "Z";
+    for (var d2 = 0; d2 < 300; d2++) deep += "}}";
+    mf.parse(deep);
+  } catch (e2) { threwDeep = (e2 && e2.name === "I18nMessageFormatError"); }
+  check("mf.parse caps nesting depth with a typed error (no stack overflow)",
+        threwDeep);
+}
+
+function testInterpolationSameDelimiter() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    interpolation: { start: "%", end: "%" },
+    translations:  { en: { a: "%x% and %y%", stray: "50% done" } },
+  });
+  check("same-delimiter interpolation replaces both placeholders",
+        i.t("a", { x: "1", y: "2" }) === "1 and 2");
+  check("same-delimiter: a lone unmatched delimiter is left literal",
+        i.t("stray") === "50% done");
+}
+
+function testMiddlewareResolver() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es"],
+    translations:  { en: { greet: "Hello" }, es: { greet: "Hola" } },
+  });
+
+  // Resolver wins over Accept-Language.
+  var mw = i.middleware({ resolver: function (req) { return req.myLang; } });
+  var req = _mockReq();
+  req.headers = { "accept-language": "en" };
+  req.myLang = "es";
+  mw(req, _mockRes(), function () {});
+  check("resolver return value wins over Accept-Language", req.locale === "es");
+
+  // Resolver returning an invalid / non-configured tag falls through.
+  var mw2 = i.middleware({ resolver: function () { return "zz-not-configured"; } });
+  var req2 = _mockReq();
+  req2.headers = { "accept-language": "es" };
+  mw2(req2, _mockRes(), function () {});
+  check("resolver invalid value falls through to header negotiation",
+        req2.locale === "es");
+
+  // Resolver throwing must not crash the request.
+  var mw3 = i.middleware({ resolver: function () { throw new Error("resolver bug"); } });
+  var req3 = _mockReq();
+  req3.headers = { "accept-language": "es" };
+  var nextCalled = false;
+  mw3(req3, _mockRes(), function () { nextCalled = true; });
+  check("resolver throw is swallowed; next() still called", nextCalled === true);
+  check("resolver throw falls through to header negotiation", req3.locale === "es");
+}
+
+function testLocaleChainFallbackValidation() {
+  var threwBadFallback = false;
+  try { b.i18n.localeChain("fr", { defaultLocale: "en", fallbackLocale: "not_a_tag" }); }
+  catch (_e) { threwBadFallback = true; }
+  check("localeChain rejects an invalid fallbackLocale tag", threwBadFallback);
+
+  var threwFallbackNotConfigured = false;
+  try {
+    b.i18n.localeChain("fr", { defaultLocale: "en", locales: ["en", "fr"], fallbackLocale: "de" });
+  } catch (_e) { threwFallbackNotConfigured = true; }
+  check("localeChain enforces fallbackLocale membership in configured locales",
+        threwFallbackNotConfigured);
+
+  var threwBadDefault = false;
+  try { b.i18n.localeChain("fr", { defaultLocale: "not_a_tag" }); }
+  catch (_e) { threwBadDefault = true; }
+  check("localeChain rejects an invalid defaultLocale tag", threwBadDefault);
+}
+
+// ---- Bulk feature-path coverage: formatters, negotiation, fallback,
+// ICU message format, lazy load, middleware binding ----
+
+// A fallbackLocale distinct from defaultLocale must appear in the resolved
+// chain AFTER the requested locale and its parents, with defaultLocale as the
+// final baseline — both cross-locale hops fire, de-duplicated.
+function testFallbackLocaleDistinctFromDefault() {
+  var i = b.i18n.create({
+    defaultLocale:  "fr",
+    fallbackLocale: "en",
+    locales:        ["en", "fr", "es"],
+    translations: {
+      en: { only_en: "EN", shared: "EN shared" },
+      fr: { greet: "Bonjour" },
+    },
+  });
+  check("chain for es is [es, en (fallback), fr (default)]",
+        JSON.stringify(i._localeChain("es")) === JSON.stringify(["es", "en", "fr"]));
+  check("miss in es resolves via fallbackLocale en before default fr",
+        i.t("only_en", null, { locale: "es" }) === "EN");
+  check("requested locale then fallback then default, de-duplicated",
+        i._localeChain("en").indexOf("fr") === i._localeChain("en").length - 1);
+}
+
+// An empty-string translation value renders as empty (the early-return path in
+// the interpolator), and a dotted key that walks THROUGH a string leaf returns
+// the key (never crashes descending into a non-object).
+function testEmptyAndDottedThroughLeaf() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { empty: "", greet: "Hello", ns: {} } },
+  });
+  check("empty-string translation renders as empty string",
+        i.t("empty") === "");
+  check("has() true for an empty-string leaf",
+        i.has("empty") === true);
+  check("dotted key walking through a string leaf returns the key",
+        i.t("greet.deeper.leaf") === "greet.deeper.leaf");
+  check("an empty-object entry loads (not a plural shape) and is a namespace miss",
+        i.t("ns") === "ns");
+}
+
+// t() on a plural-shaped entry with no numeric count in vars defaults the count
+// to 0 and selects the corresponding category (en: 0 → other).
+function testPluralWithoutCount() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { items: { one: "{count} item", other: "{count} items" } } },
+  });
+  check("plural entry with no count in vars → count 0 → other",
+        i.t("items") === "{count} items");
+  check("plural entry with explicit count in vars renders one",
+        i.t("items", { count: 1 }) === "1 item");
+}
+
+// tn / to called WITH a caller vars object merge count into a copy (rather than
+// the count-only fast path), so extra interpolation vars survive.
+function testTnToWithExtraVars() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  {
+      en: {
+        items: { one: "{name}: {count} item", other: "{name}: {count} items" },
+        place: { one: "{who} {count}st", two: "{who} {count}nd", few: "{who} {count}rd", other: "{who} {count}th" },
+      },
+    },
+  });
+  check("tn() merges caller vars alongside count",
+        i.tn("items", 3, { name: "Cart" }) === "Cart: 3 items");
+  check("tn() singular with caller vars",
+        i.tn("items", 1, { name: "Cart" }) === "Cart: 1 item");
+  check("to() merges caller vars alongside ordinal count",
+        i.to("place", 2, { who: "Runner" }) === "Runner 2nd");
+}
+
+// formatNumber across styles/locales — percent, currency, unit, notation — the
+// bulk Intl.NumberFormat surface an operator drives.
+function testFormatNumberStyles() {
+  var i = b.i18n.create({
+    defaultLocale: "en-US",
+    locales:       ["en-US", "de-DE", "ja-JP"],
+  });
+  check("formatNumber percent",
+        i.formatNumber(0.25, { style: "percent" }) === "25%");
+  check("formatNumber currency EUR under de-DE",
+        i.formatNumber(1234.5, { style: "currency", currency: "EUR" }, { locale: "de-DE" }).indexOf("€") !== -1);
+  check("formatNumber currency JPY has no fraction digits",
+        i.formatNumber(1234, { style: "currency", currency: "JPY" }, { locale: "ja-JP" }).indexOf("1,234") !== -1);
+  check("formatNumber unit (kilometer)",
+        typeof i.formatNumber(5, { style: "unit", unit: "kilometer" }) === "string" &&
+        i.formatNumber(5, { style: "unit", unit: "kilometer" }).indexOf("5") !== -1);
+  check("formatNumber compact notation",
+        i.formatNumber(1200000, { notation: "compact" }).length > 0);
+  check("formatNumber minimumFractionDigits pads",
+        i.formatNumber(5, { minimumFractionDigits: 2 }) === "5.00");
+  check("formatNumber -0 is finite and formats",
+        i.formatNumber(-0) === "-0" || i.formatNumber(-0) === "0");
+}
+
+// formatDate across dateStyle/timeStyle presets and the no-formatOpts branch
+// (falls to the locale default formatter).
+function testFormatDateStyles() {
+  var i = b.i18n.create({ defaultLocale: "en-US", locales: ["en-US", "ja-JP"] });
+  var d = new Date(Date.UTC(2024, 0, 15, 13, 30, 0));
+  check("formatDate with no formatOpts returns a non-empty string",
+        typeof i.formatDate(d) === "string" && i.formatDate(d).length > 0);
+  check("formatDate dateStyle:full contains 2024",
+        /2024/.test(i.formatDate(d, { dateStyle: "full", timeZone: "UTC" })));
+  check("formatDate timeStyle:short renders a time",
+        /\d/.test(i.formatDate(d, { timeStyle: "short", timeZone: "UTC" })));
+  check("formatDate ja-JP dateStyle:long contains 年",
+        /年/.test(i.formatDate(d, { dateStyle: "long", timeZone: "UTC" }, { locale: "ja-JP" })));
+}
+
+// formatRelative with the `numeric` opt threads it into the formatter — "auto"
+// yields word forms ("today" / "tomorrow"), "always" keeps the numeric form.
+function testFormatRelativeNumeric() {
+  var i = b.i18n.create({ defaultLocale: "en", locales: ["en"] });
+  check("formatRelative numeric:auto 0 day → 'today'",
+        i.formatRelative(0, "day", { numeric: "auto" }) === "today");
+  check("formatRelative numeric:auto -1 day → 'yesterday'",
+        i.formatRelative(-1, "day", { numeric: "auto" }) === "yesterday");
+  check("formatRelative numeric:always 0 day keeps numeric form",
+        i.formatRelative(0, "day", { numeric: "always" }) === "in 0 days");
+  check("formatRelative default (no numeric) uses numeric form",
+        i.formatRelative(0, "day") === "in 0 days");
+}
+
+// formatList across type + style — conjunction/disjunction/unit and short/narrow.
+function testFormatListStyles() {
+  var i = b.i18n.create({ defaultLocale: "en", locales: ["en"] });
+  check("formatList unit type joins without 'and'",
+        i.formatList(["5 min", "30 sec"], { type: "unit" }).indexOf("5 min") !== -1);
+  check("formatList disjunction short style",
+        typeof i.formatList(["A", "B"], { type: "disjunction", style: "short" }) === "string");
+  check("formatList single item returns that item",
+        i.formatList(["Only"]) === "Only");
+  check("formatList two items conjunction",
+        i.formatList(["A", "B"]) === "A and B");
+}
+
+// displayName currency/script honor a caller locale override.
+function testDisplayNameLocaleOverride() {
+  var i = b.i18n.create({ defaultLocale: "en", locales: ["en", "fr"] });
+  check("displayName region under fr locale is localized",
+        typeof i.displayName("US", "region", { locale: "fr" }) === "string");
+  check("displayName currency under a locale override renders",
+        i.displayName("EUR", "currency", { locale: "fr" }).length > 0);
+  check("displayName script under a locale override renders",
+        i.displayName("Latn", "script", { locale: "fr" }).length > 0);
+}
+
+// i.locales() returns a defensive copy of the configured set.
+function testLocalesGetterCopy() {
+  var i = b.i18n.create({ defaultLocale: "en", locales: ["en", "es", "fr"] });
+  var l1 = i.locales();
+  check("locales() returns the configured set",
+        JSON.stringify(l1) === JSON.stringify(["en", "es", "fr"]));
+  l1.push("zz");
+  check("locales() returns a copy — mutating it does not affect the instance",
+        i.locales().indexOf("zz") === -1);
+}
+
+// A non-lazy instance whose fallback chain includes a configured locale with no
+// inline translations tree still resolves (the load-ensure no-ops, chain walks on).
+function testChainThroughUnpopulatedLocale() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es", "fr"],
+    translations:  { en: { greet: "Hello" } },   // es + fr have no tree
+  });
+  check("lookup under es (no tree) falls through to en",
+        i.t("greet", null, { locale: "es" }) === "Hello");
+  check("lookup under fr (no tree) falls through to en",
+        i.t("greet", null, { locale: "fr" }) === "Hello");
+  check("translations() returns null for a configured-but-unpopulated locale",
+        i.translations("es") === null);
+}
+
+// Accept-Language negotiation edge branches: an all-q=0 list excludes every
+// entry and falls to the default; a multi-level requested tag prefix-matches a
+// broader configured tag by stripping subtags one at a time.
+function testNegotiationEdgeBranches() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "zh", "pt"],
+    translations:  { en: { g: "Hello" }, zh: { g: "你好" }, pt: { g: "Olá" } },
+  });
+  function loc(header) {
+    var req = _mockReq();
+    req.headers = { "accept-language": header };
+    i.middleware()(req, _mockRes(), function () {});
+    return req.locale;
+  }
+  check("all-q=0 Accept-Language excludes everything → defaultLocale",
+        loc("zh;q=0,pt;q=0") === "en");
+  check("multi-level tag zh-Hant-TW prefix-matches configured zh",
+        loc("zh-Hant-TW") === "zh");
+  check("single q=0 entry → defaultLocale",
+        loc("pt;q=0") === "en");
+}
+
+// lazyLoad with no eagerLocales loads only the defaultLocale at create; other
+// locales stream in on first lookup.
+function testLazyLoadDefaultEagerOnly() {
+  var tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "blamejs-i18n-lazydef-"));
+  try {
+    fs.writeFileSync(path.join(tmpDir, "en.json"), JSON.stringify({ greet: "Hello" }));
+    fs.writeFileSync(path.join(tmpDir, "es.json"), JSON.stringify({ greet: "Hola" }));
+    var i = b.i18n.create({
+      defaultLocale: "en",
+      locales:       ["en", "es"],
+      lazyLoad:      true,        // no eagerLocales → defaults to [defaultLocale]
+      dir:           tmpDir,
+    });
+    check("lazyLoad w/o eagerLocales: default locale available immediately",
+          i.t("greet") === "Hello");
+    check("lazyLoad w/o eagerLocales: other locale streams in on demand",
+          i.t("greet", null, { locale: "es" }) === "Hola");
+    // A valid-but-unconfigured locale override on a lazy instance: the
+    // load-ensure sees it is not in the configured set and no-ops, so the
+    // lookup falls through the chain to the default locale (no file read,
+    // no crash).
+    check("lazy instance: unconfigured locale override falls through to default",
+          i.t("greet", null, { locale: "de" }) === "Hello");
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_e) {}
+  }
+}
+
+// An observability sink that throws must never break a translation call — the
+// emit is wrapped drop-silent.
+function testObservabilitySinkThrowSwallowed() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    observability: { event: function () { throw new Error("sink boom"); } },
+    translations:  { en: { greet: "Hello" } },
+  });
+  var v;
+  var crashed = false;
+  try { v = i.t("does.not.exist"); } catch (_e) { crashed = true; }
+  check("throwing observability sink does not crash t()", crashed === false);
+  check("t() still returns the key when the sink throws", v === "does.not.exist");
+}
+
+// The middleware binds req.t / req.tn / req.to / req.dir and mirrors them onto
+// res.locals; the bound helpers default the locale to the negotiated one while
+// still honoring an explicit override.
+function testMiddlewareBoundHelpers() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es"],
+    translations:  {
+      en: { greet: "Hello", items: { one: "{count} item", other: "{count} items" },
+            rank: { one: "{count}st", two: "{count}nd", few: "{count}rd", other: "{count}th" } },
+      es: { greet: "Hola", items: { one: "{count} artículo", other: "{count} artículos" },
+            rank: { one: "{count}º", two: "{count}º", few: "{count}º", other: "{count}º" } },
+    },
+  });
+  var req = _mockReq();
+  req.headers = { "accept-language": "es" };
+  var res = _mockRes();
+  i.middleware()(req, res, function () {});
+
+  check("req.tn bound to the negotiated locale",
+        req.tn("items", 5) === "5 artículos");
+  check("req.to bound to the negotiated locale",
+        req.to("rank", 1) === "1º");
+  check("req.to honors an explicit locale override in callerOpts",
+        req.to("rank", 1, null, { locale: "en" }) === "1st");
+  check("req.t honors an explicit locale override over the negotiated one",
+        req.t("greet", null, { locale: "en" }) === "Hello");
+  check("req.tn honors an explicit locale override",
+        req.tn("items", 1, null, { locale: "en" }) === "1 item");
+  check("req.dir returns a direction for the negotiated locale",
+        req.dir() === "ltr");
+  check("res.locals.to bound",     typeof res.locals.to === "function");
+  check("res.locals.tn bound",     typeof res.locals.tn === "function");
+  check("res.locals.t via res.locals resolves the negotiated locale",
+        res.locals.t("greet") === "Hola");
+}
+
+// The middleware never lets an i18n error escape onto the request path: if
+// reading a request field throws, it swallows, sets req.locale to the current
+// default, and still calls next().
+function testMiddlewareCatchNeverCrashes() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { greet: "Hello" } },
+  });
+  var req = _mockReq();
+  req.headers = {};
+  // A query getter that throws forces the try/catch guard in the middleware.
+  Object.defineProperty(req, "query", {
+    get: function () { throw new Error("query access boom"); },
+    configurable: true,
+  });
+  var res = _mockRes();
+  var nextCalled = false;
+  var crashed = false;
+  try { i.middleware()(req, res, function () { nextCalled = true; }); }
+  catch (_e) { crashed = true; }
+  check("middleware swallows a throwing request field", crashed === false);
+  check("middleware still calls next() after swallowing", nextCalled === true);
+  check("middleware falls back to the current default locale on error",
+        req.locale === "en");
+}
+
+// A custom headerName reads the negotiation source from a non-standard header.
+function testMiddlewareCustomHeaderName() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es"],
+    translations:  { en: { greet: "Hello" }, es: { greet: "Hola" } },
+  });
+  var req = _mockReq();
+  req.headers = { "x-locale": "es" };
+  i.middleware({ headerName: "X-Locale" })(req, _mockRes(), function () {});
+  check("custom headerName negotiates from the named header",
+        req.locale === "es");
+}
+
+// ICU MessageFormat feature surface driven through t(): nested plural inside
+// select, plural offset, selectordinal, and the # placeholder.
+function testMessageFormatFeaturePathsViaT() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations: {
+      en: {
+        nested: "{tier, select, pro {{n, plural, one {# pro seat} other {# pro seats}}} other {{n, plural, one {# seat} other {# seats}}}}",
+        party:  "{n, plural, offset:1 =0 {nobody} one {you and # other} other {you and # others}}",
+        medal:  "{p, selectordinal, one {#st} two {#nd} few {#rd} other {#th}} place",
+        exact:  "{n, plural, =0 {no items} =1 {a single item} other {# items}}",
+      },
+    },
+  });
+  check("nested select→plural (pro, one)",
+        i.t("nested", { tier: "pro", n: 1 }) === "1 pro seat");
+  check("nested select→plural (pro, other)",
+        i.t("nested", { tier: "pro", n: 4 }) === "4 pro seats");
+  check("nested select falls to other branch",
+        i.t("nested", { tier: "free", n: 2 }) === "2 seats");
+  check("plural offset =0 exact case",
+        i.t("party", { n: 0 }) === "nobody");
+  check("plural offset one case subtracts the offset in #",
+        i.t("party", { n: 2 }) === "you and 1 other");
+  check("plural offset other case subtracts the offset in #",
+        i.t("party", { n: 4 }) === "you and 3 others");
+  check("selectordinal few (3rd)",
+        i.t("medal", { p: 3 }) === "3rd place");
+  check("selectordinal other (11th)",
+        i.t("medal", { p: 11 }) === "11th place");
+  check("plural exact =1 literal case beats the 'one' category",
+        i.t("exact", { n: 1 }) === "a single item");
+  check("plural exact falls to other for a non-literal count",
+        i.t("exact", { n: 7 }) === "7 items");
+
+  // messageFormat: true forces the ICU path even for a plain-looking entry.
+  var i2 = b.i18n.create({
+    defaultLocale: "en", locales: ["en"],
+    translations: { en: { plain: "just text {x}" } },
+  });
+  check("messageFormat:true on a plain entry renders the literal placeholder text",
+        typeof i2.t("plain", { x: "v" }, { messageFormat: true }) === "string");
+}
+
+// localeChain called with a falsy opts argument still validates (and throws on
+// the now-missing defaultLocale) rather than dereferencing undefined.
+function testLocaleChainFalsyOpts() {
+  var threw = false;
+  try { b.i18n.localeChain("fr", null); } catch (_e) { threw = true; }
+  check("localeChain('fr', null) throws (defaultLocale required)", threw);
+
+  // A configured-set that DOES include the members passes membership validation
+  // and returns the chain (the happy path through the membership guard).
+  var chain = b.i18n.localeChain("fr-CA", {
+    defaultLocale: "en", fallbackLocale: "en", locales: ["en", "fr", "fr-CA"],
+  });
+  check("localeChain with a valid configured set returns the chain",
+        JSON.stringify(chain) === JSON.stringify(["fr-CA", "fr", "en"]));
+}
+
+// Every inline translation tree is validated at create — including a locale
+// present in `translations` but absent from the configured `locales` array. Such
+// a locale is still reachable via an explicit locale override, so the shape /
+// plural invariants the lookup relies on (notably _selectPlural assuming a
+// mandatory `other`) must hold for it too. A malformed tree there is rejected at
+// boot (fail-closed) rather than silently accepted and left to make t() return
+// undefined at request time — the contract is that t() returns a string.
+function testUnvalidatedLocaleTreeStillValidated() {
+  // A non-string / non-object leaf in a non-configured locale is rejected.
+  var threwLeaf = null;
+  try {
+    b.i18n.create({
+      defaultLocale: "en", locales: ["en"],
+      translations:  { en: { greet: "Hello" }, zz: { num: 123 } },
+    });
+  } catch (e) { threwLeaf = e; }
+  check("non-configured locale tree is validated: a non-string leaf is rejected at create",
+        threwLeaf !== null && /string or nested object/.test(threwLeaf.message));
+  // A plural entry missing the mandatory `other` in a non-configured locale is
+  // rejected too — otherwise t(count=5) selecting the CLDR `other` category
+  // would return undefined instead of the key.
+  var threwPlural = null;
+  try {
+    b.i18n.create({
+      defaultLocale: "en", locales: ["en"],
+      translations:  { en: {}, zz: { items: { one: "uno" } } },
+    });
+  } catch (e) { threwPlural = e; }
+  check("non-configured locale plural entry missing `other` is rejected at create",
+        threwPlural !== null);
+  // A well-formed non-configured locale is accepted and usable via override.
+  var i = b.i18n.create({
+    defaultLocale: "en", locales: ["en"],
+    translations:  { en: { greet: "Hello" }, zz: { greet: "Hallo" } },
+  });
+  check("a well-formed non-configured locale is usable via an explicit override",
+        i.t("greet", null, { locale: "zz" }) === "Hallo");
+}
+
+// _validateTranslationTree treats a bare string as a valid leaf at ANY depth,
+// including the tree root, so `translations: { de: "just-a-string" }` is accepted
+// at create. A subsequent lookup resolving to that locale hands _resolveKey a
+// non-object `tree`; its guard returns undefined and the chain walk falls through
+// to a locale that carries a real object tree — no crash, no raw-key leak.
+function testBareStringLocaleTreeFallsThrough() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "de"],
+    translations:  { en: { greet: "Hello" }, de: "not-an-object-tree" },
+  });
+  check("bare-string locale tree: lookup falls through to a real tree",
+        i.t("greet", null, { locale: "de" }) === "Hello");
+  check("has() resolves the leaf from the fallback despite a bare-string tree",
+        i.has("greet", { locale: "de" }) === true);
+  check("translations() returns the bare-string tree verbatim",
+        i.translations("de") === "not-an-object-tree");
+}
+
+// A plural-shaped entry's CLDR category is selected from the numeric `count`.
+// When `count` is present in vars but NOT a number (a stringified digit), it does
+// not drive selection — the code defaults the selection count to 0 (→ the "other"
+// category for en) while the raw string value still interpolates into `{count}`.
+// So a string "1" renders the plural (not singular) form.
+function testPluralNonNumericCountInVars() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { items: { one: "{count} item", other: "{count} items" } } },
+  });
+  check("string count '1' selects 'other' (not 'one') but interpolates '1'",
+        i.t("items", { count: "1" }) === "1 items");
+  check("string count '5' selects 'other' and interpolates '5'",
+        i.t("items", { count: "5" }) === "5 items");
+  // A boolean count is likewise non-numeric → other category.
+  check("boolean count is non-numeric → 'other' category",
+        i.t("items", { count: true }) === "true items");
+}
+
+// tn()/to() merge the numeric count arg LAST into a copy of the caller vars, so
+// the count argument authoritatively wins over any `count` key the caller also
+// put in vars — the plural category tracks the argument, not the stray var.
+function testTnCountArgOverridesVarsCount() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { items: { one: "{count} item", other: "{count} items" } } },
+  });
+  check("tn(): count arg (5) overrides vars.count (999) for selection + render",
+        i.tn("items", 5, { count: 999 }) === "5 items");
+  check("tn(): count arg (1) yields the 'one' category despite vars.count 999",
+        i.tn("items", 1, { count: 999 }) === "1 item");
+}
+
+// The interpolator trims whitespace inside the placeholder, so `{  name  }`
+// resolves the `name` var (and, in strict mode, a genuinely-missing var still
+// throws referencing the trimmed name).
+function testInterpolationTrimsPlaceholderWhitespace() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    translations:  { en: { hi: "Hi {  name  }!", tabbed: "{\tkey\t}" } },
+  });
+  check("placeholder with surrounding spaces resolves the trimmed var",
+        i.t("hi", { name: "Bob" }) === "Hi Bob!");
+  check("placeholder with surrounding tabs resolves the trimmed var",
+        i.t("tabbed", { key: "V" }) === "V");
+
+  var iStrict = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en"],
+    interpolation: { strict: true },
+    translations:  { en: { hi: "Hi {  name  }!" } },
+  });
+  var threw = false;
+  try { iStrict.t("hi", { other: "x" }); } catch (_e) { threw = true; }
+  check("strict mode still throws on a genuinely-missing trimmed var", threw);
+}
+
+// dir() with no callerOpts resolves the CURRENT locale, so it tracks setLocale()
+// mutations — flipping to an RTL language flips the reported direction.
+function testDirReflectsCurrentLocaleAfterSetLocale() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "ar"],
+  });
+  check("dir() defaults to ltr under the initial en locale", i.dir() === "ltr");
+  i.setLocale("ar");
+  check("dir() with no opts reflects the RTL current locale after setLocale",
+        i.dir() === "rtl");
+  i.setLocale("en");
+  check("dir() flips back to ltr after setLocale('en')", i.dir() === "ltr");
+}
+
+// A resolver that returns a non-string value (a number, an object) is not a
+// usable locale: _isValidBcp47 rejects the non-string, so negotiation falls
+// through to Accept-Language rather than coercing the junk value.
+function testMiddlewareResolverNonStringReturn() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es"],
+    translations:  { en: { greet: "Hello" }, es: { greet: "Hola" } },
+  });
+
+  var mwNum = i.middleware({ resolver: function () { return 42; } });
+  var reqNum = _mockReq();
+  reqNum.headers = { "accept-language": "es" };
+  mwNum(reqNum, _mockRes(), function () {});
+  check("resolver returning a number falls through to header negotiation",
+        reqNum.locale === "es");
+
+  var mwObj = i.middleware({ resolver: function () { return { lang: "es" }; } });
+  var reqObj = _mockReq();
+  reqObj.headers = { "accept-language": "es" };
+  mwObj(reqObj, _mockRes(), function () {});
+  check("resolver returning an object falls through to header negotiation",
+        reqObj.locale === "es");
+}
+
+// The explicit-source readers (query param, cookie) require a STRING value; a
+// non-string (a number, an array) is ignored — an attacker-controlled request
+// field of the wrong shape can never coerce the negotiated locale, and never
+// crashes the middleware. Negotiation falls back to Accept-Language.
+function testMiddlewareNonStringExplicitSourcesIgnored() {
+  var i = b.i18n.create({
+    defaultLocale: "en",
+    locales:       ["en", "es"],
+    translations:  { en: { greet: "Hello" }, es: { greet: "Hola" } },
+  });
+
+  var reqNumQuery = _mockReq();
+  reqNumQuery.headers = { "accept-language": "es" };
+  reqNumQuery.query = { lang: 42 };
+  i.middleware()(reqNumQuery, _mockRes(), function () {});
+  check("numeric ?lang is ignored → header negotiation",
+        reqNumQuery.locale === "es");
+
+  var reqArrQuery = _mockReq();
+  reqArrQuery.headers = { "accept-language": "es" };
+  reqArrQuery.query = { lang: ["es", "fr"] };
+  i.middleware()(reqArrQuery, _mockRes(), function () {});
+  check("array ?lang (duplicate query keys) is ignored → header negotiation",
+        reqArrQuery.locale === "es");
+
+  var reqNumCookie = _mockReq();
+  reqNumCookie.headers = { "accept-language": "es" };
+  reqNumCookie.cookies = { pref: 5 };
+  i.middleware({ cookieName: "pref" })(reqNumCookie, _mockRes(), function () {});
+  check("non-string cookie value is ignored → header negotiation",
+        reqNumCookie.locale === "es");
+}
 
 if (require.main === module) {
   run().then(