@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/server.js

@@ -0,0 +1,1234 @@
+import { a as getState, h as createScope, t as textDirection } from "./dir-zw6bGMKQ.js";
+import { a as hostLocale, c as localizedPathsFor, d as splitLocalePath, i as awayHref, l as matchRoute, n as atHome, o as localeOrigin, r as atHost, s as localizePath } from "./url-CsBkRaJy.js";
+import { r as matchLocale } from "./match-BGr8EXB3.js";
+import { t as createScopedApi } from "./scoped-BMYpSthj.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/server/catalogs.ts
+/**
+* Server registration and catalogs (INTERNALS §3.2 "Server registration").
+* The boot module (or `registerCatalogs`) registers once; from then on this
+* module owns what `/server` loads for it: the per-locale catalogs, the
+* `sources` map and the client plan. The source catalog and `sources` start
+* loading at registration, so `State.serverFallback` exists before the first
+* request and untransformed code resolves source literals from the start.
+*
+* Module-level variables rather than one state object: the minifier renames
+* them, which keeps `/server` inside its PLAN §6 budget.
+*/
+const S = getState();
+/**
+* Dev mode from the plugin's `define`, read the way the runtime reads it:
+* code bundled without the plugin behaves as production.
+*/
+const DEV = typeof __VI18N_DEV__ !== "undefined" && !!__VI18N_DEV__;
+/**
+* `ROUTES` of the URL codec, read here again: the packed `/server` imports
+* the runtime chunk, where a constant cannot fold this entry's branches out
+* (§6 D134).
+*/
+const ROUTES = typeof __VI18N_ROUTES__ === "undefined" || !!__VI18N_ROUTES__;
+const own = Object.hasOwn;
+const noop = () => {};
+const error = (text) => /* @__PURE__ */ new Error("vi18n: " + text);
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(text) {
+	if (warned.has(text)) return;
+	if (warned.size > 499) warned.clear();
+	warned.add(text);
+	console.warn("vi18n: " + text);
+}
+const zones = /* @__PURE__ */ new Set();
+/**
+* True for an IANA zone name this engine's Intl accepts (INTERNALS §3.2).
+* Names start with a letter. UTC offsets (`+01:00`, `-0530`, `+01`), which
+* Intl accepts too, are thousands of spellings: a client cycling them
+* through `vi18n_tz` would add a formatter per spelling to every cache
+* keyed by zone.
+*/
+function isTimeZone(zone) {
+	if (typeof zone !== "string" || zone.length > 64 || !/^[a-z]/i.test(zone)) return false;
+	if (zones.has(zone)) return true;
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: zone });
+	} catch {
+		return false;
+	}
+	if (zones.size < 1024) zones.add(zone);
+	return true;
+}
+/** The registration served; replaced when the state registers again. */
+let reg = null;
+let config;
+let loaders;
+/** Dev catalogs (`registration.catalogs`) are re-imported per scope, so HMR invalidation shows. */
+let dev = false;
+/**
+* Build catalogs, settled or in flight (concurrent scopes share one load; a
+* failed load is dropped so the next request retries), least recently used
+* first.
+*/
+let loaded = /* @__PURE__ */ new Map();
+/** `sources()` as a Map, once settled; every scope `/server` opens carries it. */
+let sources;
+/** Source catalog and `sources` both settled: scopes may open without waiting. */
+let settled = false;
+let readying;
+/** The client plan: undefined until loaded, null without one (sentinel, dev, `registerCatalogs`). */
+let plan;
+let planning;
+/**
+* The config of the current registration, (re)starting this module when the
+* state registered again. Throws before any registration: there is nothing
+* to negotiate with, and a guess would render the wrong locale.
+*/
+function current() {
+	const r = S.registration;
+	if (!r) throw error(DEV ? "no registration yet: the Vite plugin's boot module registers on import, and servers built without it call registerCatalogs() first" : "no registration (registerCatalogs)");
+	if (r !== reg) {
+		reg = r;
+		config = r.config;
+		loaders = r.serverCatalogs ?? r.catalogs;
+		dev = DEV && !r.serverCatalogs && !!r.catalogs;
+		loaded = /* @__PURE__ */ new Map();
+		sources = void 0;
+		settled = false;
+		readying = void 0;
+		plan = r.clientPlan ? void 0 : null;
+		planning = void 0;
+		ready()?.catch(noop);
+	}
+	return config;
+}
+/** Resolves once the source catalog and `sources` are loaded; undefined when they already are. */
+function ready() {
+	if (settled) return void 0;
+	const r = reg;
+	return readying ??= Promise.all([catalog(config.sourceLocale), loadSources(r)]).then(([c, map]) => {
+		if (r !== reg) return;
+		sources = map;
+		settled = true;
+		S.serverFallback = createScope("request", config.sourceLocale, c.messages, {
+			timeZone: config.ssr.timeZone,
+			timeZoneSource: "config",
+			sources: map
+		});
+	}, (e) => {
+		if (r === reg) readying = void 0;
+		throw e;
+	});
+}
+const isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+/** A module namespace's default export, or the object itself (both are accepted everywhere). */
+function unwrap(m) {
+	return isObject(m) && own(m, "default") && isObject(m.default) ? m.default : m;
+}
+async function loadSources(r) {
+	if (!r.sources) return void 0;
+	const data = unwrap(await r.sources());
+	if (!isObject(data)) throw error("sources() did not return an object");
+	const map = /* @__PURE__ */ new Map();
+	for (const k in data) if (own(data, k) && typeof data[k] === "string") map.set(k, data[k]);
+	return map;
+}
+const entries = (v) => new Map(Object.entries(isObject(v) ? v : {}));
+function toCatalog(locale, m) {
+	const data = unwrap(m);
+	if (!isObject(data)) throw error("the " + locale + " catalog is not an object");
+	if (!(DEV && dev)) return { messages: entries(data) };
+	const d = data;
+	return {
+		messages: entries(d.messages),
+		labels: entries(d.labels)
+	};
+}
+const devMaps = /* @__PURE__ */ new WeakMap();
+/** The catalog of a configured locale: a value when loaded (build), else a promise. */
+function catalog(locale) {
+	const into = loaded;
+	let c = into.get(locale);
+	if (!c) {
+		if (!loaders || !own(loaders, locale)) return Promise.reject(error("no server catalog for locale " + JSON.stringify(locale)));
+		if (DEV && dev) return loaders[locale]().then((m) => {
+			if (!isObject(m)) return toCatalog(locale, m);
+			let d = devMaps.get(m);
+			if (!d) devMaps.set(m, d = toCatalog(locale, m));
+			return d;
+		});
+		c = loaders[locale]().then((m) => {
+			const k = toCatalog(locale, m);
+			into.set(locale, k);
+			return k;
+		}, (e) => {
+			into.delete(locale);
+			throw e;
+		});
+	}
+	into.delete(locale);
+	into.set(locale, c);
+	for (const l of into.keys()) if (into.size > config.ssr.maxLoadedLocales && l !== config.sourceLocale) into.delete(l);
+	return c;
+}
+/** Loads the client plan once; the sentinel string (or anything malformed) means fallback mode. */
+function loadPlan() {
+	if (plan !== void 0) return void 0;
+	const r = reg;
+	return planning ??= r.clientPlan().then((m) => {
+		if (r !== reg) return;
+		const p = m.default;
+		plan = typeof p === "object" && p ? p : null;
+	}, (e) => {
+		if (r === reg) planning = void 0;
+		throw e;
+	});
+}
+const STRATEGIES = [
+	"url",
+	"cookie",
+	"header",
+	"localStorage",
+	"default"
+];
+const RULES = [
+	["locales", []],
+	["pseudoLocales", []],
+	["fallbacks", { values: [] }],
+	["routing", {}],
+	["routing.strategy", [STRATEGIES]],
+	["routing.routeStrategies", { values: [STRATEGIES] }],
+	["routing.url", [
+		"prefix_except_default",
+		"prefix",
+		"prefix_and_default",
+		"no_prefix"
+	]],
+	["routing.redirectRoot", "boolean"],
+	["routing.propagate", ["header", false]],
+	["routing.switch", ["in-place", "navigate"]],
+	["routing.cookie", {}],
+	["routing.cookie.name", "string"],
+	["routing.cookie.maxAge", "number"],
+	["routing.base", "string"],
+	["ssr", {}],
+	["ssr.timeZone", "string"],
+	["ssr.timeZoneFrom", { values: ["config", "request"] }],
+	["ssr.normalizeSpaces", "boolean"]
+];
+function matches(v, rule) {
+	if (typeof rule === "string") return typeof v === rule;
+	if (Array.isArray(rule)) {
+		if (!rule.length || Array.isArray(rule[0])) {
+			const list = rule[0];
+			return Array.isArray(v) && v.every((x) => list ? list.includes(x) : typeof x === "string");
+		}
+		return rule.includes(v);
+	}
+	return isObject(v) && (!rule.values || Object.values(v).every((x) => matches(x, rule.values)));
+}
+/**
+* The last registration `registerCatalogs()` made: a server built without
+* the Vite plugin, so no client plan exists and no client reads a payload.
+*/
+let bare;
+/**
+* `config.json` from `vi18n compile --out` arrives as untyped JSON: each
+* field the server reads is checked, so a stale or hand-edited file fails at
+* startup with the field's name instead of mid-request.
+*/
+function validateConfig(input) {
+	const c = unwrap(input);
+	const fail = (path) => {
+		throw new TypeError("vi18n: registerCatalogs: invalid config: " + path);
+	};
+	if (!isObject(c)) fail("not an object");
+	for (const [path, rule] of RULES) if (!matches(path.split(".").reduce((o, k) => o[k], c), rule)) fail(path);
+	if (!c.locales.length) fail("locales");
+	if (!c.locales.includes(c.sourceLocale)) fail("sourceLocale");
+	if (ROUTES) {
+		const { paths, domains } = c.routing;
+		if (paths !== void 0 && !matches(paths, { values: { values: "string" } })) fail("routing.paths");
+		if (domains !== void 0 && !matches(domains, { values: "string" })) fail("routing.domains");
+	}
+	if (!isTimeZone(c.ssr.timeZone)) fail("ssr.timeZone");
+	return c;
+}
+function registerCatalogs(loaders, options) {
+	const config = validateConfig(options.config);
+	if (!isObject(loaders)) throw new TypeError("vi18n: registerCatalogs: loaders must be an object");
+	S.register(bare = {
+		mode: "build",
+		consumer: "server",
+		config,
+		serverCatalogs: loaders,
+		sources: options.sources
+	});
+	current();
+}
+const registerBefore = S.register;
+S.register = (r) => {
+	const done = registerBefore(r);
+	if (r.consumer === "server" && S.registration === r) current();
+	return done;
+};
+//#endregion
+//#region src/server/als.ts
+/**
+* Request isolation (PLAN §5.13 "Isolation"). Scopes travel in an
+* AsyncLocalStorage; there is deliberately no synchronous-slot fallback,
+* because a slot still readable after an `await` would serve one request's
+* locale to another.
+*/
+const als = S.serverScopes ??= new AsyncLocalStorage();
+/** Framework request stores (SvelteKit `getRequestEvent()`) supply the scope; null removes it. */
+function setScopeResolver(resolve) {
+	als.resolver = resolve;
+}
+/**
+* The current scope. A `withLocale`/`createTranslator` scope entered inside
+* a request outranks the framework's request store: the store would still
+* name the request, and an e-mail rendered for another user inside it must
+* use that user's locale. Otherwise the resolver wins over the ALS, as
+* frameworks may run render code outside the async context `handle` opened.
+*/
+function getScope() {
+	const s = als.getStore();
+	const user = als.resolver;
+	if (s?.kind === "translator" || !user) return s;
+	let u;
+	try {
+		u = user();
+	} catch {}
+	return u ?? s;
+}
+S.serverResolver = getScope;
+/**
+* Some ALS implementations resolve but do not propagate (polyfills that hold
+* the store only synchronously): reading another request's locale later
+* would be silent, so the first scope opener checks that a store survives
+* an `await`, and fails loudly otherwise.
+*/
+async function assertPropagation(store) {
+	const k = {};
+	if (!await store.run(k, async () => {
+		await Promise.resolve();
+		return store.getStore() === k;
+	})) throw error("AsyncLocalStorage loses its store across await; enable nodejs_als or nodejs_compat (compatibility date 2026-08-04+)");
+}
+let probed;
+let ok = false;
+/** Runs the probe once per process; a failure is remembered, so every request reports it. */
+function propagation() {
+	if (ok) return void 0;
+	return probed ??= assertPropagation(als).then(() => {
+		ok = true;
+	});
+}
+//#endregion
+//#region src/server/inject.ts
+/**
+* The streaming HTML transform of `handle()` (PLAN §5.13 step 5): `lang` and
+* `dir` on `<html>` unless the app set them, the payload before `</head>`,
+* a late payload before `</body>` for ids recorded after the head was
+* flushed. It works on bytes, not text: the needles are ASCII, so chunks
+* without a match pass through as the same buffers, with no decode/encode
+* round trip. The inserted markup is UTF-8 (payload text included), so pages
+* must be UTF-8 too; `handle()` warns in dev about any other declared charset.
+*/
+const enc = new TextEncoder();
+/**
+* Tag names; `tagAt` returns their index (literals below, which the minifier
+* keeps short). 4–5 start raw text and 6 a comment, skipped whole: a
+* `</head>` inside an inline script's string literal does not end the head.
+* `<title>` and `<textarea>` are left out: their text is escaped (`&lt;`)
+* by every renderer, unlike script and style source.
+*/
+const TAGS = [
+	"<html",
+	"</head",
+	"<body",
+	"</body",
+	"<script",
+	"<style",
+	"<!--"
+];
+/** A `<html` start tag longer than this is not one we can edit; it passes through. */
+const MAX_TAG = 8192;
+/**
+* Which of `names` starts at `at`, -1 for none, -2 when `buf` ends first. A
+* tag name must be followed by a delimiter; `<!--` and `-->` need none.
+*/
+function tagAt(buf, at, names) {
+	let undecided = false;
+	for (let t = 0; t < names.length; t++) {
+		const name = names[t];
+		let k = 0;
+		for (; k < name.length && at + k < buf.length; k++) {
+			const b = buf[at + k];
+			if ((b > 64 && b < 91 ? b | 32 : b) !== name.charCodeAt(k)) break;
+		}
+		const d = buf[at + k];
+		if (k === name.length && (name.length < 5 || d <= 32 || d === 62 || d === 47)) return t;
+		if (d === void 0) undecided = true;
+	}
+	return undecided ? -2 : -1;
+}
+/** Index of the `>` closing the tag that starts at `from`, honouring quoted values; -1 if not in `buf`. */
+function tagEnd(buf, from) {
+	let quote = 0;
+	for (let i = from; i < buf.length; i++) {
+		const b = buf[i];
+		if (quote) {
+			if (b === quote) quote = 0;
+		} else if (b === 34 || b === 39) quote = b;
+		else if (b === 62) return i;
+	}
+	return -1;
+}
+/** The attributes to add to an `<html …>` tag (its text without `<html` and `>`). */
+function missingAttributes(tag, lang, dir) {
+	const names = (" " + tag.replace(/"[^"]*"|'[^']*'/g, "")).toLowerCase();
+	return (/[\s/]lang(?![^\s=/>])/.test(names) ? "" : ` lang="${lang}"`) + (/[\s/]dir(?![^\s=/>])/.test(names) ? "" : ` dir="${dir}"`);
+}
+/**
+* The transform. Phases: 0 looks for `<html`, 1 for `</head` (`<body` ends
+* both), 2 for `</body`, 3 passes everything through. Before phase 3,
+* comments and raw-text elements are skipped whole, as a parser would. A
+* chunk that ends inside a candidate tag keeps that tail back (at most
+* `MAX_TAG` bytes) and joins it to the next chunk.
+*/
+function injector(hooks) {
+	let phase = 0;
+	let carry = null;
+	/** The end tag (`<\/script`…) or `-->` ending the raw text being skipped; "" outside it. */
+	let raw = "";
+	return {
+		transform(chunk, controller) {
+			let buf = chunk;
+			if (carry) {
+				buf = new Uint8Array(carry.length + chunk.length);
+				buf.set(carry);
+				buf.set(chunk, carry.length);
+				carry = null;
+			}
+			let pos = 0;
+			const emit = (end) => {
+				if (end > pos) controller.enqueue(buf.subarray(pos, end));
+				pos = end;
+			};
+			const hold = (at) => {
+				emit(at);
+				carry = buf.slice(at);
+			};
+			const insert = (text) => {
+				if (text) controller.enqueue(enc.encode(text));
+			};
+			let i = 0;
+			while (phase < 3) {
+				const lt = buf.indexOf(raw ? raw.charCodeAt(0) : 60, i);
+				if (lt < 0) break;
+				i = lt + 1;
+				const t = tagAt(buf, lt, raw ? [raw] : TAGS);
+				if (t === -2) return hold(lt);
+				if (raw) {
+					if (!t) raw = "";
+				} else if (t > 3) raw = t > 5 ? "-->" : "</" + TAGS[t].slice(1);
+				else if (t === 0 && !phase) {
+					const end = tagEnd(buf, lt + 5);
+					if (end >= 0) {
+						const { lang, dir } = hooks.attributes();
+						emit(buf[end - 1] === 47 ? end - 1 : end);
+						insert(missingAttributes(new TextDecoder().decode(buf.subarray(lt + 5, end)), lang, dir));
+						i = end + 1;
+					} else if (buf.length - lt <= MAX_TAG) return hold(lt);
+					phase = 1;
+				} else if (t === 1 && phase < 2) {
+					emit(lt);
+					insert(hooks.head());
+					phase = 2;
+				} else if (t === 2) {
+					if (phase < 2) phase = 2;
+				} else if (t === 3) {
+					emit(lt);
+					insert(hooks.tail());
+					phase = 3;
+				}
+			}
+			emit(buf.length);
+		},
+		flush(controller) {
+			if (carry) controller.enqueue(carry);
+		}
+	};
+}
+//#endregion
+//#region src/server/types.ts
+/** Header the client runtime adds to same-origin `fetch` calls (`routing.propagate`). */
+const LOCALE_HEADER = "x-vi18n-locale";
+/** Cookie the client runtime writes with the browser's IANA zone. */
+const TIME_ZONE_COOKIE = "vi18n_tz";
+//#endregion
+//#region src/server/negotiate.ts
+/**
+* Server locale resolution (INTERNALS §2.11.9, PLAN §5.14). The SPA boot
+* script and the client runtime implement the same algorithm, and
+* `tests/fixtures/resolution/cases.json` keeps the three equal. Every input
+* (URL segment, header, cookie, Referer) is matched against `locales` and
+* nothing else, so a request can only ever select a configured locale.
+*/
+/** The base as a path starting and ending with `/`, as the URL codec reads it. */
+function baseOf(config) {
+	const b = config.routing.base;
+	return b && b[0] === "/" ? b.endsWith("/") ? b : b + "/" : "/";
+}
+/**
+* The pathname as route globs see it (INTERNALS §2.7.3): delocalized,
+* without the base and without a trailing slash; the root is `/`.
+*/
+function routeOf(pathname, config) {
+	const p = splitLocalePath(pathname, config).path;
+	const base = baseOf(config);
+	const s = p.startsWith(base) ? "/" + p.slice(base.length) : p + "/" === base ? "/" : p;
+	return s.length > 1 && s.endsWith("/") ? s.slice(0, -1) : s;
+}
+const keyCache = /* @__PURE__ */ new WeakMap();
+function keysOf(o) {
+	let k = keyCache.get(o);
+	if (!k) keyCache.set(o, k = Object.keys(o));
+	return k;
+}
+/**
+* The `url` step: an unprefixed path is the source locale's canonical page
+* (on a listed host, the host's locale's) unless every locale is prefixed.
+*/
+function urlStep(config, pathname) {
+	const url = config.routing.url;
+	if (url === "no_prefix") return null;
+	return splitLocalePath(pathname, config).locale ?? (url === "prefix" ? null : ROUTES && config.routing.home || config.sourceLocale);
+}
+/**
+* The canonical URL of a page the URL names, where localized paths or
+* domains are configured (§6 D133), or null when `pathname` is it: the
+* locale's own path for the route (`/de/about` → `/de/ueber-uns`), without
+* the prefix of the unprefixed locale, on the host serving the locale (an
+* absolute URL, from the config only). Under `prefix_and_default` the
+* requested prefix form stays. A target that would not read back as the
+* same route is never answered, so no config can loop.
+*/
+function canonical(pathname, config) {
+	const url = config.routing.url;
+	if (url === "no_prefix") return null;
+	const split = splitLocalePath(pathname, config);
+	const l = split.locale ?? (url === "prefix" ? null : config.routing.home ?? config.sourceLocale);
+	if (l === null) return null;
+	const away = awayHref(split.path, l, config);
+	if (away !== null) return away;
+	const c = url === "prefix_and_default" && split.locale !== null ? {
+		...config,
+		routing: {
+			...config.routing,
+			url: "prefix"
+		}
+	} : config;
+	const target = localizePath(split.path, l, c);
+	return target !== pathname && splitLocalePath(target, c).path === split.path ? target : null;
+}
+/** One cookie's decoded value from a `Cookie` header, or null. */
+function readCookie(header, name) {
+	for (const part of header ? header.split(";") : []) {
+		const eq = part.indexOf("=");
+		if (eq > 0 && part.slice(0, eq).trim() === name) try {
+			return decodeURIComponent(part.slice(eq + 1).trim());
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+const MAX_HEADER = 1024;
+const MAX_ENTRIES = 20;
+const QVALUE = /^\s*q\s*=\s*(0(?:\.\d{0,3})?|1(?:\.0{0,3})?)\s*$/i;
+/**
+* Accept-Language as language tags by preference. Hardened for hostile
+* input: at most 1024 characters and 20 entries are read (an entry cut by
+* the length cap is dropped), `q=0` means refused, a missing q is 1, a
+* malformed q drops its entry, and equal q keeps header order (stable sort).
+* Tags are not validated here; `matchLocale` canonicalises them in try/catch.
+*/
+function parseAcceptLanguage(header) {
+	if (!header) return [];
+	const cut = header.length > MAX_HEADER;
+	const parts = (cut ? header.slice(0, MAX_HEADER) : header).split(",", 21);
+	if (cut && parts.length <= MAX_ENTRIES) parts.pop();
+	const entries = [];
+	for (let i = 0; i < parts.length && i < MAX_ENTRIES; i++) {
+		const part = parts[i];
+		const semi = part.indexOf(";");
+		const tag = (semi < 0 ? part : part.slice(0, semi)).trim();
+		if (!tag || tag === "*") continue;
+		let q = 1;
+		if (semi >= 0) {
+			const m = QVALUE.exec(part.slice(semi + 1));
+			if (!m) continue;
+			q = Number(m[1]);
+		}
+		if (q > 0) entries.push({
+			tag,
+			q
+		});
+	}
+	entries.sort((a, b) => b.q - a.q);
+	return entries.map((e) => e.tag);
+}
+const ISLANDS = "/_server-islands/";
+/** §2.11.9 for one request, with the canonical and root redirects. */
+function negotiateFor(request, url, config) {
+	if (ROUTES) config = atHost(config, url.host);
+	const { locales, sourceLocale, routing } = config;
+	const pathname = url.pathname;
+	const { routeStrategies, strategy } = routing;
+	const keys = keysOf(routeStrategies);
+	const route = keys.length ? matchRoute(keys, routeOf(pathname, config)) : null;
+	const chain = route === null ? strategy : routeStrategies[route];
+	let locale = null;
+	let source = "default";
+	let vary;
+	let redirect;
+	let status;
+	const headers = request.headers;
+	if (headers.get("sec-fetch-mode") !== "navigate" && !(urlStep(config, pathname) && chain.includes("url"))) {
+		const x = headers.get(LOCALE_HEADER);
+		if (x !== null && locales.includes(x)) {
+			locale = x;
+			source = "header-x";
+			vary = "x-vi18n-locale";
+		}
+	}
+	if (locale === null && routeOf(pathname, config).startsWith(ISLANDS)) {
+		let ref = null;
+		try {
+			ref = new URL(headers.get("referer")).pathname;
+		} catch {}
+		const l = ref === null || ref === "/" ? null : urlStep(config, ref);
+		if (l !== null) {
+			locale = l;
+			source = "referer";
+			vary = "Referer";
+		}
+	}
+	if (locale === null) {
+		const base = baseOf(config);
+		const atRoot = pathname === base || pathname + "/" === base;
+		const redirecting = atRoot && routing.redirectRoot;
+		let asked = false;
+		for (const step of chain) {
+			let l = null;
+			if (step === "url") {
+				if (!redirecting) l = urlStep(config, pathname);
+			} else if (step === "cookie") {
+				asked = true;
+				l = readCookie(headers.get("cookie"), routing.cookie.name);
+			} else if (step === "header") {
+				asked = true;
+				l = matchLocale(parseAcceptLanguage(headers.get("accept-language")), config);
+			} else if (step === "default") l = sourceLocale;
+			if (l !== null && locales.includes(l)) {
+				locale = l;
+				source = step;
+				break;
+			}
+		}
+		locale ??= sourceLocale;
+		if (asked || atRoot && source !== "url") vary = "Accept-Language";
+		const target = ROUTES && awayHref(base, locale, config) || localizePath(base, locale, config);
+		if (redirecting && locale !== urlStep(config, pathname) && target !== pathname) {
+			redirect = new URL(target + url.search, url);
+			status = 307;
+		}
+	}
+	if (ROUTES && (routing.paths || routing.domains)) {
+		const target = !redirect && (request.method === "GET" || request.method === "HEAD") ? canonical(pathname, config) : null;
+		if (target !== null) {
+			redirect = new URL(target + url.search, url);
+			status = 301;
+		}
+	} else if (!redirect && routing.url === "prefix_except_default" && (request.method === "GET" || request.method === "HEAD")) {
+		const split = splitLocalePath(pathname, config);
+		if (split.locale === sourceLocale) {
+			redirect = new URL(split.path + url.search, url);
+			status = 301;
+		}
+	}
+	const n = {
+		locale,
+		source
+	};
+	if (vary) n.vary = vary;
+	if (redirect) {
+		n.redirect = redirect;
+		n.status = status;
+	}
+	return n;
+}
+/**
+* The locale `request` would render in, the redirect `handle()` would
+* answer, and the header its response varies on.
+*/
+function negotiate(request) {
+	return negotiateFor(request, new URL(request.url), current());
+}
+//#endregion
+//#region src/server/payload.ts
+/**
+* The SSR payload (INTERNALS §2.10, PLAN §5.13 "Payload contents"): what a
+* page inlines so hydration renders with zero catalog requests. Ids alone
+* select the client bundles: an id used by exactly one root (`pins`) brings
+* that root's whole key set, other ids bring only their non-`r.*` bundles,
+* and server-only modules record nothing, so island-free pages get nothing.
+*
+* Bundle JSON is serialised (and escaped) once per catalog and key, and
+* spliced into each request's payload: a page's payload costs string
+* concatenation, not a `JSON.stringify` of every message it carries.
+*
+* With `ssr.payload: "preload"` the same selection is preloaded instead:
+* one `<link rel="preload" as="fetch" crossorigin>` per bundle ahead of the
+* payload, which names the keys for the client to load at once.
+*/
+const sent = /* @__PURE__ */ new WeakMap();
+/**
+* `ssr.payload: "preload"` compiled in: the plugin defines it false for the
+* default config, folding the branch out (PLAN §6); copies built without the
+* plugin (Nitro's) keep it and follow the registration's config.
+*/
+const PRELOAD = typeof __VI18N_PRELOAD__ === "undefined" || !!__VI18N_PRELOAD__;
+const escapeJson = (json) => json.replace(/[<\u2028\u2029]/g, (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0"));
+const attr = (v) => v.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+/** Id → keys of the bundles holding it, per plan. */
+const indexes = /* @__PURE__ */ new WeakMap();
+function indexOf(plan) {
+	let idx = indexes.get(plan);
+	if (!idx) {
+		idx = /* @__PURE__ */ new Map();
+		for (const key in plan.bundles) {
+			if (!own(plan.bundles, key)) continue;
+			for (const id of plan.bundles[key]) {
+				const ks = idx.get(id);
+				if (ks) ks.push(key);
+				else idx.set(id, [key]);
+			}
+		}
+		indexes.set(plan, idx);
+	}
+	return idx;
+}
+/** Escaped bundle JSON per catalog and key (for one plan); null when the catalog lacks one of its ids. */
+const bundleCache = /* @__PURE__ */ new WeakMap();
+function bundleJson(plan, messages, key) {
+	let c = bundleCache.get(messages);
+	if (c?.plan !== plan) bundleCache.set(messages, c = {
+		plan,
+		json: /* @__PURE__ */ new Map()
+	});
+	let json = c.json.get(key);
+	if (json === void 0) {
+		json = "{";
+		for (const id of own(plan.bundles, key) && plan.bundles[key] || []) {
+			const m = messages.get(id);
+			if (m === void 0) {
+				json = null;
+				break;
+			}
+			json += (json.length > 1 ? "," : "") + JSON.stringify(id) + ":" + JSON.stringify(m);
+		}
+		if (json !== null) json = escapeJson(json + "}");
+		c.json.set(key, json);
+	}
+	return json;
+}
+/**
+* Picks the bundles for `fresh` ids (§2.10 selection), recording them in
+* `st.keys`. Returns null when none of the ids is a client id. Outside
+* `dupBelow` duplicates an id lives in exactly one bundle, so "bundles not
+* yet selected" needs no check of its own.
+*/
+function select(plan, fresh, st) {
+	const idx = indexOf(plan);
+	const out = [];
+	const add = (k) => {
+		if (!st.keys.has(k)) {
+			st.keys.add(k);
+			out.push(k);
+		}
+	};
+	let client = false;
+	for (const id of fresh) {
+		const keys = idx.get(id);
+		if (!keys) continue;
+		client = true;
+		const root = own(plan.pins, id) ? plan.pins[id] : null;
+		if (root !== null) {
+			if (own(plan.roots, root)) for (const k of plan.roots[root]) add(k);
+		} else for (const k of keys) if (!k.startsWith("r.")) add(k);
+	}
+	if (!client) return null;
+	if (plan.base !== null) add(plan.base);
+	return out.sort();
+}
+/**
+* The `<script>` to insert for `scope` now: the payload when none was
+* emitted yet, otherwise a late payload of what is new, after the preload
+* links of its bundles under `ssr.payload: "preload"`. "" when there is
+* nothing to send (no client ids, nothing new).
+*/
+function scriptFor(scope, nonce) {
+	const used = scope.used;
+	if (!used || !used.size) return "";
+	let st = sent.get(scope);
+	if (!st) sent.set(scope, st = {
+		head: false,
+		ids: /* @__PURE__ */ new Set(),
+		keys: /* @__PURE__ */ new Set()
+	});
+	const fresh = [];
+	for (const id of used) if (!st.ids.has(id)) {
+		st.ids.add(id);
+		fresh.push(id);
+	}
+	if (!fresh.length) return "";
+	const late = st.head;
+	const config = current();
+	const plan$1 = plan ?? null;
+	const messages = scope.messages;
+	const locale = scope.locale;
+	let bundles = "";
+	let extra = "";
+	let links = "";
+	if (plan$1) {
+		const keys = select(plan$1, fresh, st);
+		if (!keys) return "";
+		if (PRELOAD && config.ssr.payload === "preload") {
+			const hashes = own(plan$1.hashes, locale) && plan$1.hashes[locale] || {};
+			const named = [];
+			for (const k of keys) {
+				if (!own(hashes, k)) continue;
+				named.push(k);
+				links += "<link rel=\"preload\" as=\"fetch\" crossorigin href=\"" + attr(plan$1.assetsUrl + locale + "/" + k + "." + hashes[k] + ".json") + "\">";
+			}
+			if (late && !named.length) return "";
+			extra = ",\"preload\":" + escapeJson(JSON.stringify(named));
+		} else {
+			for (const k of keys) {
+				const json = bundleJson(plan$1, messages, k);
+				if (json !== null) bundles += (bundles ? "," : "") + JSON.stringify(k) + ":" + json;
+			}
+			if (late && !bundles) return "";
+		}
+	} else {
+		fresh.sort();
+		let m = "";
+		for (const id of fresh) {
+			const msg = messages.get(id);
+			if (msg !== void 0) m += (m ? "," : "") + JSON.stringify(id) + ":" + JSON.stringify(msg);
+		}
+		if (late && !m) return "";
+		extra = ",\"messages\":" + escapeJson("{" + m + "}");
+	}
+	const v = plan$1 ? plan$1.v : reg.mode === "dev" ? "dev" : null;
+	if (!late) st.head = true;
+	const json = escapeJson(JSON.stringify(late ? {
+		v,
+		locale
+	} : {
+		v,
+		locale,
+		timeZone: scope.timeZone ?? config.ssr.timeZone,
+		now: scope.now ?? Date.now(),
+		manifest: plan$1 && own(plan$1.hashes, locale) && plan$1.hashes[locale] || null
+	}).slice(0, -1)) + ",\"bundles\":{" + bundles + "}" + extra + "}";
+	return links + "<script type=\"application/json\" " + (late ? "data-vi18n-late" : "id=\"__vi18n\"") + (nonce ? " nonce=\"" + attr(nonce) + "\"" : "") + ">" + json + "<\/script>";
+}
+/**
+* The payload element for HTML-string hooks (Nuxt `render:html`), with its
+* preload links under `ssr.payload: "preload"`: the ids rendered so far in
+* the current request scope, or "" when there are none.
+* After it, `handle()` only adds late payloads for ids recorded later.
+*/
+function payload(options) {
+	const scope = getScope();
+	return scope ? scriptFor(scope, options?.nonce) : "";
+}
+/** `<html lang dir>` for the current scope. */
+function htmlAttributes() {
+	const locale = S.resolve().locale;
+	return {
+		lang: locale,
+		dir: textDirection(locale)
+	};
+}
+//#endregion
+//#region src/server/translator.ts
+/**
+* Scope opening shared by every `/server` entry point, plus `withLocale` and
+* `createTranslator` (PLAN §5.13 "E-mail, jobs and webhooks"). Every scope
+* waits for the source catalog and `sources` (so untransformed code resolves
+* source literals from the first request), its locale's catalog and, when the
+* build has one, the client plan.
+*/
+/**
+* The configured locale `input` reaches: itself, else the closest match
+* (`de-AT` reaches `de`), else null.
+*/
+function matched(config, input) {
+	if (input === void 0) return null;
+	return config.locales.includes(input) ? input : matchLocale([input], config);
+}
+/**
+* A configured locale for `input`, the source locale when nothing matches.
+* Inputs here are user data (a stored profile locale), so a miss renders the
+* source locale rather than throwing.
+*/
+function pickLocale(config, input) {
+	const m = matched(config, input);
+	if (m === null && DEV) warnOnce(`${JSON.stringify(input)} is not a configured locale; using ${config.sourceLocale}`);
+	return m ?? config.sourceLocale;
+}
+/** An app-given zone: wrong zones are programming errors, unlike a visitor's cookie. */
+function explicitZone(zone) {
+	if (!isTimeZone(zone)) throw new RangeError("vi18n: invalid time zone " + JSON.stringify(zone));
+	return zone;
+}
+/**
+* Waits for whatever this scope needs that is not loaded or checked yet
+* (the ALS probe runs before the first scope opens); resolves to the
+* locale's catalog.
+*/
+async function prepare(locale) {
+	const p = propagation();
+	const r = ready();
+	const plan = loadPlan();
+	const c = catalog(locale);
+	if (!p && !r && !plan && !(c instanceof Promise)) return c;
+	return (await Promise.all([
+		p,
+		r,
+		plan,
+		c
+	]))[3];
+}
+/** A scope once its catalogs are loaded, carrying the registration's `sources` and dev labels. */
+async function openScope(kind, locale, timeZone, timeZoneSource, now, trackUsed) {
+	const cat = await prepare(locale);
+	const scope = createScope(kind, locale, cat.messages, {
+		timeZone,
+		now,
+		timeZoneSource,
+		trackUsed,
+		sources
+	});
+	if (DEV && cat.labels) scope.labels = cat.labels;
+	return scope;
+}
+function translatorScope(locale, options) {
+	const config = current();
+	const zone = options?.timeZone;
+	return openScope("translator", pickLocale(config, locale), zone === void 0 ? config.ssr.timeZone : explicitZone(zone), zone === void 0 ? "config" : "explicit", options?.now, false);
+}
+/**
+* Runs `fn` with `t` and `fmt` bound to `locale` (and the zone in `options`),
+* also inside a request: an e-mail for another user renders in theirs.
+*/
+async function withLocale(locale, fn, options) {
+	const scope = await translatorScope(locale, options);
+	return await als.run(scope, fn);
+}
+/** `t`, `rich*` and `fmt` bound to one locale and zone, for code that cannot run inside a scope. */
+async function createTranslator(locale, options) {
+	return createScopedApi(await translatorScope(locale, options));
+}
+//#endregion
+//#region src/server/handle.ts
+/**
+* Request scopes (PLAN §5.13 `handle(request, next)` steps 1–5, INTERNALS
+* §3.2): negotiate, maybe redirect, open the scope with its zone and `now`,
+* render inside it, then fix up the response.
+*/
+/**
+* The scope's zone, chosen before rendering (INTERNALS §6 D77): explicit →
+* the route's `timeZoneFrom: config` → the `vi18n_tz` cookie → `cf.timezone`
+* → `ssr.timeZone`. Invalid zones from the client are ignored.
+*/
+function zoneFor(request, url, config, explicit) {
+	const ssr = config.ssr;
+	if (explicit !== void 0) return [explicitZone(explicit), "explicit"];
+	const from = ssr.timeZoneFrom;
+	const keys = keysOf(from);
+	const p = keys.length ? matchRoute(keys, routeOf(url.pathname, config)) : null;
+	if (p === null || from[p] !== "config") {
+		const c = readCookie(request.headers.get("cookie"), TIME_ZONE_COOKIE);
+		if (c !== null && isTimeZone(c)) return [c, "cookie"];
+		const cf = request.cf?.timezone;
+		if (isTimeZone(cf)) return [cf, "cf"];
+	}
+	return [ssr.timeZone, "config"];
+}
+/** Opens the request scope once its catalogs are loaded. */
+function open(config, request, url, locale, options) {
+	const [zone, source] = zoneFor(request, url, config, options?.timeZone);
+	const now = options?.now;
+	return openScope("request", locale, zone, source, Number.isFinite(now) ? now : Date.now(), true);
+}
+const PUBLIC = /(?:^|[\s,])(?:public|s-maxage\s*=)/i;
+const HTML = /^\s*text\/html\s*(?:;|$)/i;
+/**
+* `body`, read inside `scope` whoever reads it, through `inject` when
+* given. Servers read a response after handle() returned, and a lazy body
+* (`ReadableStream.from` over a generator, a pull source) renders as it is
+* pulled. A pipe set up inside the scope is not enough: which context a
+* pipe pulls in is up to the platform's stream scheduling (Node 24 resumes
+* a parked pipe from the call that unblocked it), so every read and the
+* cancel enter the scope themselves.
+*/
+function inScope(body, scope, inject) {
+	const reader = body.getReader();
+	return new ReadableStream({
+		pull: (c) => als.run(scope, () => reader.read()).then((r) => r.done ? (inject?.flush(c), c.close()) : inject ? inject.transform(r.value, c) : c.enqueue(r.value)),
+		cancel: (reason) => als.run(scope, () => reader.cancel(reason))
+	});
+}
+/**
+* A copy of `response` with the scope's headers and its body read inside
+* the scope: injected for HTML, unchanged otherwise.
+*/
+function finish(request, response, scope, n, url, config, options) {
+	if (response.status < 200) return response;
+	const type = response.headers.get("content-type");
+	const html = HTML.test(type);
+	const zoned = scope.timeZoneSource === "cookie" || scope.timeZoneSource === "cf";
+	const perUser = zoned && (scope.formattedTime === true || html);
+	const vary = n?.vary;
+	const body = response.body;
+	if (!html && !vary && !perUser && !body) return response;
+	const encoding = response.headers.get("content-encoding");
+	const plain = html && !(encoding && encoding.toLowerCase() !== "identity");
+	const publicly = () => {
+		const cc = headers.get("cache-control");
+		if (DEV && scope.formattedTime && zoned && cc && PUBLIC.test(cc)) warnOnce(`${routeOf(url.pathname, config)} formats times in a per-user zone but is publicly cacheable; set ssr.timeZoneFrom: config`);
+	};
+	const script = () => options?.payload ?? reg !== bare ? scriptFor(scope, options?.nonce) : "";
+	const res = new Response(body && inScope(body, scope, plain && request.method !== "HEAD" ? injector({
+		attributes: () => ({
+			lang: scope.locale,
+			dir: textDirection(scope.locale)
+		}),
+		head: script,
+		tail: DEV ? () => (publicly(), script()) : script
+	}) : void 0), response);
+	const headers = res.headers;
+	const lower = vary?.toLowerCase();
+	if (vary && !(headers.get("vary") ?? "").split(",").some((t) => (t = t.trim().toLowerCase()) === "*" || t === lower)) headers.append("vary", vary);
+	const cc = headers.get("cache-control");
+	if (vary === "Accept-Language" ? !/private|no-store/i.test(cc) : perUser && !cc) headers.set("cache-control", cc ? "private, " + cc : "private");
+	if (DEV) publicly();
+	if (html) {
+		if (!headers.has("content-language")) headers.set("content-language", scope.locale);
+		if (!plain) {
+			if (DEV) warnOnce(`${url.pathname}: ${encoding}-encoded HTML is not injected; let the server compress after handle()`);
+		} else {
+			headers.delete("content-length");
+			const etag = headers.get("etag");
+			if (etag && !etag.startsWith("W/")) headers.set("etag", "W/" + etag);
+			if (DEV && /charset=(?!"?utf-?8)/i.test(type)) warnOnce(`${url.pathname}: the payload is UTF-8; serve HTML as UTF-8 (${type})`);
+		}
+	}
+	return res;
+}
+/**
+* Negotiates the locale, answers the canonical or root redirect, renders
+* `next(request)` (the original request: rewriting stays with the router)
+* inside the request scope, and streams HTML through the injection.
+*/
+async function handle(request, next, options) {
+	const config = current();
+	const url = new URL(request.url);
+	const f = matched(config, options?.locale);
+	const n = f === null ? negotiateFor(request, url, config) : null;
+	if (n?.redirect) {
+		const headers = new Headers({ location: ROUTES && n.redirect.host !== url.host ? n.redirect.href : n.redirect.pathname + n.redirect.search });
+		if (n.status === 307) {
+			headers.set("cache-control", "private");
+			if (n.vary) headers.set("vary", n.vary);
+		}
+		return new Response(null, {
+			status: n.status,
+			headers
+		});
+	}
+	const scope = await open(config, request, url, f ?? n.locale, options);
+	if (ROUTES) scope.home = hostLocale(url.host, config);
+	const response = await als.run(scope, () => next(request));
+	if (DEV && !(response instanceof Response)) throw error("handle(): next() must return a Response");
+	return finish(request, response, scope, n, url, config, options);
+}
+/**
+* Runs `fn` in the request's scope, for servers that build the response
+* themselves (Nuxt), and returns its value; a `Response` with a body comes
+* back with the same status, headers and bytes, its body read inside the
+* scope.
+*/
+async function withRequest(request, fn, options) {
+	const config = current();
+	const url = new URL(request.url);
+	const scope = await open(config, request, url, matched(config, options?.locale) ?? negotiateFor(request, url, config).locale, options);
+	if (ROUTES) scope.home = hostLocale(url.host, config);
+	const value = await als.run(scope, fn);
+	return value instanceof Response && value.body ? new Response(inScope(value.body, scope), value) : value;
+}
+/**
+* Re-scopes the current request to `locale` (Astro server islands whose
+* props carry it). The scope object is updated in place, so the request's
+* resolver, its payload and its `<html>` attributes all follow.
+*/
+async function scopeLocale(locale) {
+	const scope = getScope();
+	if (!scope) throw error("scopeLocale() called outside a request scope");
+	const l = pickLocale(current(), locale);
+	if (l === scope.locale) return;
+	const cat = await prepare(l);
+	scope.locale = l;
+	scope.messages = cat.messages;
+	scope.labels = cat.labels;
+}
+//#endregion
+//#region src/server/seo.ts
+/**
+* Prerender and SEO helpers (PLAN §5.13, §5.14): every locale's URL of a page
+* for crawlers (`alternates`), and the paths or params a prerenderer walks
+* (`localizedPaths`, `localizedParams`). Pseudo-locales are never advertised.
+*/
+const advertised = (config) => config.locales.filter((l) => !config.pseudoLocales.includes(l));
+/** `pt-BR` → `pt_BR`; a missing region comes from the likely subtags (`de` → `de_DE`). */
+function ogLocale(locale) {
+	try {
+		const l = new Intl.Locale(locale);
+		const region = l.region ?? l.maximize().region;
+		return region ? l.language + "_" + region : l.language;
+	} catch {
+		return locale;
+	}
+}
+/**
+* hreflang links for every locale plus `x-default` (the source locale's
+* URL), the self-canonical (`origin + pathname`: queries and fragments are
+* not separate pages), and `og:locale` metadata for the current locale.
+*/
+function alternates(url) {
+	const config = current();
+	const locale = getScope()?.locale ?? config.sourceLocale;
+	if (ROUTES && config.routing.domains) return onDomains(url, config, locale);
+	const path = splitLocalePath(url.pathname, config).path;
+	const origin = url.origin;
+	const links = [];
+	const locales = advertised(config);
+	const alternate = (hreflang, l) => void links.push({
+		rel: "alternate",
+		hreflang,
+		href: origin + localizePath(path, l, config)
+	});
+	if (config.routing.url !== "no_prefix") {
+		for (const l of locales) alternate(l, l);
+		alternate("x-default", config.sourceLocale);
+	}
+	links.push({
+		rel: "canonical",
+		href: origin + url.pathname
+	});
+	const meta = [{
+		property: "og:locale",
+		content: ogLocale(locale)
+	}];
+	for (const l of locales) if (l !== locale) meta.push({
+		property: "og:locale:alternate",
+		content: ogLocale(l)
+	});
+	return {
+		links,
+		meta
+	};
+}
+/** `og:locale` for `locale`, then `og:locale:alternate` for every other advertised locale. */
+function ogMeta(config, locale) {
+	const meta = [{
+		property: "og:locale",
+		content: ogLocale(locale)
+	}];
+	for (const l of advertised(config)) if (l !== locale) meta.push({
+		property: "og:locale:alternate",
+		content: ogLocale(l)
+	});
+	return meta;
+}
+/**
+* `alternates()` with domains (§6 D135): every URL comes from the config,
+* none from the request's `Host`. Each locale's alternate, `x-default` and
+* the canonical are on the locale's first listed origin, unprefixed, so a
+* page served on an alias, a preview host or with a forged `Host` still
+* names the configured site.
+*/
+function onDomains(url, config, locale) {
+	const path = splitLocalePath(url.pathname, atHost(config, url.host)).path;
+	const at = (l) => (localeOrigin(l, config) ?? url.origin) + localizePath(path, l, atHome(config, l));
+	const links = advertised(config).map((l) => ({
+		rel: "alternate",
+		hreflang: l,
+		href: at(l)
+	}));
+	links.push({
+		rel: "alternate",
+		hreflang: "x-default",
+		href: at(config.sourceLocale)
+	});
+	links.push({
+		rel: "canonical",
+		href: at(locale)
+	});
+	return {
+		links,
+		meta: ogMeta(config, locale)
+	};
+}
+/** Rewritten for the codec with the app's base left out. */
+const atRoot = (config) => ({
+	...config,
+	routing: {
+		...config.routing,
+		base: "/"
+	}
+});
+/**
+* Every path in every advertised locale, for prerender entry lists. Paths are
+* base-free, as for `/config`'s `localizedPaths` and `localizedParams`:
+* prerenderers list routes, and one helper must not need different input
+* at build time and at request time (PLAN §4).
+*/
+function localizedPaths(paths) {
+	return localizedPathsFor(paths, atRoot(current()));
+}
+/**
+* Astro `getStaticPaths()` params for a `[...lang]` route: the locale segment
+* of each advertised locale, `undefined` where the locale's URL carries none
+* (the source locale under `prefix_except_default`).
+*/
+function localizedParams(key = "lang") {
+	const config = current();
+	const root = atRoot(config);
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const l of advertised(config)) {
+		const localized = localizePath("/", l, root);
+		const segment = localized === "/" ? void 0 : localized.slice(1);
+		if (seen.has(segment)) continue;
+		seen.add(segment);
+		out.push({ params: { [key]: segment } });
+	}
+	return out;
+}
+//#endregion
+export { alternates, createTranslator, getScope, handle, htmlAttributes, localizedParams, localizedPaths, negotiate, payload, registerCatalogs, scopeLocale, setScopeResolver, withLocale, withRequest };