@endora-commerce/platform 0.100.0

package/dist/kernel/i18n/error-translation.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Which bundle holds which error code's sentence — the **routing**, derived
+ * from the modules' own `errorCodes` declarations.
+ *
+ * **This file is the platform's and was `_i18n`'s until
+ * `specs/117-instance-bring-up/` FR-030.** The line it moved across is the one
+ * that matters and is worth stating in place: *the routing is derived from
+ * manifests, the translation is a service*. `translateErrorMessage` — the other
+ * half of the error envelope's i18n injection — resolves a key against a bundle
+ * and stays `_i18n`'s, correctly, reached through that module's own registration.
+ * Nothing here translates anything. It reads `manifest.errorCodes` and answers
+ * with `{ moduleId, key }` pairs, and its input is the **resolved manifest set**,
+ * which is a composition-root input rather than anything `_i18n` owns.
+ *
+ * Four measured facts put it here rather than in the module (T040b's criterion
+ * 8, the test `absolutizePublicUrl` moved out of `email` under):
+ *
+ *   1. `_i18n` had **no consumer of it inside its own module** — its barrel
+ *      re-exported it and nothing else in the package called it.
+ *   2. Its callers are the two composition roots and one host check script.
+ *   3. Its input type restates `RegisteredManifestEntry`, a host type, and says
+ *      so — it was restated because a module may not name another module's file.
+ *   4. Its output feeds `ErrorEnvelopeOptions.errorTranslationTargets`, whose
+ *      type the platform already declares in `http/error-envelope.ts`.
+ *
+ * A **port** was the alternative and is structurally unavailable, not merely
+ * unattractive: the production root calls this *before* `composeModules`, so
+ * there is no container to resolve one from, and moving the call after
+ * composition would move the collision warning with it — a diagnostic that is
+ * logged where it is precisely so an operator reads it before the first request
+ * that renders wrong. Gating a derivation over a root's own input on a module's
+ * effective state would also be an answer to a question nobody asked.
+ *
+ * It sits beside `request-language.ts` because that file is the same kind of
+ * thing: the producer of another `ErrorEnvelopeOptions` member, platform-owned,
+ * injected by a root. It is on **no barrel** — no module calls it, so
+ * `specs/080-f4-real-scope/contracts/host-package.md` §1.3 classifies it
+ * *unreached* and publishing it would put a host-only name into the platform's
+ * module-facing contract.
+ */
+export interface ErrorTranslationTarget {
+    moduleId: string;
+    /**
+     * Widened from `errors.${ErrorCode}` by feature 090: a module declares codes
+     * the platform's enumeration does not hold, and the key is built from the
+     * code either way.
+     */
+    key: `errors.${string}`;
+}
+/**
+ * One manifest, and the file it was declared in.
+ *
+ * Structurally what `RegisteredManifestEntry` already is, and still restated
+ * rather than imported. The original reason — *"`_lifecycle` owns that type and
+ * a module may not name a file in another module's directory"* — retired with
+ * the move; the restatement stays for a second reason that did not, and that is
+ * now the load-bearing one: this function's callers include a **check script**
+ * that builds its declarations from source text rather than from a composed
+ * registry, so the parameter has to be the narrowest shape the answer needs and
+ * not whatever `RegisteredManifestEntry` happens to carry. The `filePath` is
+ * not decoration — it is what §3.1 rule 3 requires a collision report to name
+ * for **every** claimant, and a module id alone does not tell an operator which
+ * package on their disk to look at.
+ */
+export interface ErrorCodeDeclarationSource {
+    readonly manifest: {
+        readonly id: string;
+        readonly errorCodes?: readonly {
+            readonly code: string;
+        }[] | undefined;
+    };
+    readonly filePath: string;
+}
+/** One module's claim on a code. */
+export interface ErrorCodeClaim {
+    readonly moduleId: string;
+    readonly declaredIn: string;
+}
+/** A code more than one registered module declares. Nobody wins. */
+export interface ErrorCodeCollision {
+    readonly code: string;
+    readonly claims: readonly ErrorCodeClaim[];
+}
+/**
+ * The whole answer: the routing, and the codes it refuses to route.
+ *
+ * Named `Routing` rather than `Targets` since the move, and the rename is not
+ * cosmetic: `http/error-envelope.ts` declares an `ErrorTranslationTargets` of
+ * its own — the record this one's `targets` member is assigned to — and two
+ * types of one name inside one package, one being the input to the other's
+ * consumer, is a confusion with a real cost. Nothing outside this package ever
+ * named the aggregate, so the rename cost one file.
+ */
+export interface ErrorTranslationRouting {
+    readonly targets: Readonly<Record<string, ErrorTranslationTarget>>;
+    readonly collisions: readonly ErrorCodeCollision[];
+}
+/**
+ * Which bundle holds which code's sentence, derived from the manifests.
+ *
+ * The input is **every registered manifest** — core, this deployment's overlay
+ * modules and every installed package — which is the set `resolvedManifestEntries()`
+ * produces and `admin_roles` builds the permission catalogue from. Activation
+ * and platform availability are **not** consulted, and that is a standing ruling
+ * rather than an omission (`specs/082-error-code-ownership/contracts/error-code-ownership.md`
+ * §1.3): a code owned by a switchable module is raised by other modules too, so
+ * a switched-off `carts` must not cost `orders` its checkout sentence.
+ *
+ * **Collisions: nobody wins** (§3). A code more than one module declares is
+ * *absent* from `targets` and present in `collisions` with every claimant named.
+ * There is no tie-break — not first-wins, not last-wins, not by origin, not by
+ * manifest order, not by module id — because every one of them renders one
+ * raiser's condition under the other's sentence: good prose about the wrong
+ * thing, with no symptom an operator or a client can detect. The envelope
+ * already rules that trade at five other exits from the same hook, and the
+ * answer is the same one: untranslated prose which is true beats a rendered
+ * sentence that is not.
+ *
+ * **One derivation** (D-100): the report and the routing come out of this one
+ * call, so they cannot come to disagree about which codes are contested.
+ *
+ * **Deterministic**: the answer does not depend on the order the manifests
+ * arrive in. Claims are sorted by module id, collisions by code.
+ *
+ * **There is no fall-through** (§4.1). A code no registered manifest declares is
+ * *absent* from `targets`: it is not routed to the platform, to `core`, or to
+ * anything else, and the envelope answers the raising code's own English. That
+ * is `specs/082-error-code-ownership/rulings.md` §9 (D-129) delivered — *"`core`
+ * is only ever reached by being named"* — and it is what the deleted prefix
+ * chain could not do, because its last line was `return 'core'`.
+ *
+ * **The chain and `composeErrorTranslationTargets` are gone** (feature 090
+ * Phase 4). The transitional composition laid these declarations over
+ * `moduleIdForErrorCode` so that the migration could be delivered one module per
+ * merge request while staying answer-preserving; all eighteen owners have
+ * declared, so both roots call this directly. The answer it gives for every
+ * member of `ERROR_CODES` is still measured against the frozen capture in
+ * `backend/test/fixtures/error-code-routing/chain-answers.ts`, which is now the
+ * only record of what the chain said.
+ */
+export declare function buildErrorTranslationTargets(manifests: readonly ErrorCodeDeclarationSource[]): ErrorTranslationRouting;
+/** One line per claimant, in the words an operator reads on `/platform/modules`. */
+export declare function describeErrorCodeCollisions(collisions: readonly ErrorCodeCollision[]): string;
+//# sourceMappingURL=error-translation.d.ts.map

package/dist/kernel/i18n/error-translation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-translation.d.ts","sourceRoot":"","sources":["../../../src/kernel/i18n/error-translation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,GAAG,EAAE,UAAU,MAAM,EAAE,CAAC;CACzB;AAOD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAKpB,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,GAAG,SAAS,CAAC;KACxE,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,oCAAoC;AACpC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,oEAAoE;AACpE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;CAC5C;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,UAAU,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,SAAS,0BAA0B,EAAE,GAC/C,uBAAuB,CA6BzB;AAED,oFAAoF;AACpF,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,SAAS,kBAAkB,EAAE,GACxC,MAAM,CAYR"}

package/dist/kernel/i18n/error-translation.js

@@ -0,0 +1,84 @@
+/**
+ * Which bundle holds which code's sentence, derived from the manifests.
+ *
+ * The input is **every registered manifest** — core, this deployment's overlay
+ * modules and every installed package — which is the set `resolvedManifestEntries()`
+ * produces and `admin_roles` builds the permission catalogue from. Activation
+ * and platform availability are **not** consulted, and that is a standing ruling
+ * rather than an omission (`specs/082-error-code-ownership/contracts/error-code-ownership.md`
+ * §1.3): a code owned by a switchable module is raised by other modules too, so
+ * a switched-off `carts` must not cost `orders` its checkout sentence.
+ *
+ * **Collisions: nobody wins** (§3). A code more than one module declares is
+ * *absent* from `targets` and present in `collisions` with every claimant named.
+ * There is no tie-break — not first-wins, not last-wins, not by origin, not by
+ * manifest order, not by module id — because every one of them renders one
+ * raiser's condition under the other's sentence: good prose about the wrong
+ * thing, with no symptom an operator or a client can detect. The envelope
+ * already rules that trade at five other exits from the same hook, and the
+ * answer is the same one: untranslated prose which is true beats a rendered
+ * sentence that is not.
+ *
+ * **One derivation** (D-100): the report and the routing come out of this one
+ * call, so they cannot come to disagree about which codes are contested.
+ *
+ * **Deterministic**: the answer does not depend on the order the manifests
+ * arrive in. Claims are sorted by module id, collisions by code.
+ *
+ * **There is no fall-through** (§4.1). A code no registered manifest declares is
+ * *absent* from `targets`: it is not routed to the platform, to `core`, or to
+ * anything else, and the envelope answers the raising code's own English. That
+ * is `specs/082-error-code-ownership/rulings.md` §9 (D-129) delivered — *"`core`
+ * is only ever reached by being named"* — and it is what the deleted prefix
+ * chain could not do, because its last line was `return 'core'`.
+ *
+ * **The chain and `composeErrorTranslationTargets` are gone** (feature 090
+ * Phase 4). The transitional composition laid these declarations over
+ * `moduleIdForErrorCode` so that the migration could be delivered one module per
+ * merge request while staying answer-preserving; all eighteen owners have
+ * declared, so both roots call this directly. The answer it gives for every
+ * member of `ERROR_CODES` is still measured against the frozen capture in
+ * `backend/test/fixtures/error-code-routing/chain-answers.ts`, which is now the
+ * only record of what the chain said.
+ */
+export function buildErrorTranslationTargets(manifests) {
+    const claimsByCode = new Map();
+    for (const entry of manifests) {
+        for (const declaration of entry.manifest.errorCodes ?? []) {
+            const claims = claimsByCode.get(declaration.code);
+            const claim = {
+                moduleId: entry.manifest.id,
+                declaredIn: entry.filePath,
+            };
+            if (claims)
+                claims.push(claim);
+            else
+                claimsByCode.set(declaration.code, [claim]);
+        }
+    }
+    const targets = {};
+    const collisions = [];
+    for (const [code, claims] of claimsByCode) {
+        if (claims.length === 1) {
+            targets[code] = { moduleId: claims[0].moduleId, key: `errors.${code}` };
+            continue;
+        }
+        collisions.push({
+            code,
+            claims: [...claims].sort((a, b) => a.moduleId.localeCompare(b.moduleId) || a.declaredIn.localeCompare(b.declaredIn)),
+        });
+    }
+    return { targets, collisions: collisions.sort((a, b) => a.code.localeCompare(b.code)) };
+}
+/** One line per claimant, in the words an operator reads on `/platform/modules`. */
+export function describeErrorCodeCollisions(collisions) {
+    return collisions
+        .map((collision) => `  - "${collision.code}" is declared by ${collision.claims.length} modules and ` +
+        'therefore routes to none of them; the raising code\'s own message is answered ' +
+        'until one of them gives it up:\n' +
+        collision.claims
+            .map((claim) => `      ${claim.moduleId} (${claim.declaredIn})`)
+            .join('\n'))
+        .join('\n');
+}
+//# sourceMappingURL=error-translation.js.map

package/dist/kernel/i18n/error-translation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-translation.js","sourceRoot":"","sources":["../../../src/kernel/i18n/error-translation.ts"],"names":[],"mappings":"AA6GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,4BAA4B,CAC1C,SAAgD;IAEhD,MAAM,YAAY,GAAG,IAAI,GAAG,EAA4B,CAAC;IACzD,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;QAC9B,KAAK,MAAM,WAAW,IAAI,KAAK,CAAC,QAAQ,CAAC,UAAU,IAAI,EAAE,EAAE,CAAC;YAC1D,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAClD,MAAM,KAAK,GAAmB;gBAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE;gBAC3B,UAAU,EAAE,KAAK,CAAC,QAAQ;aAC3B,CAAC;YACF,IAAI,MAAM;gBAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;;gBAC1B,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IAED,MAAM,OAAO,GAA2C,EAAE,CAAC;IAC3D,MAAM,UAAU,GAAyB,EAAE,CAAC;IAC5C,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,YAAY,EAAE,CAAC;QAC1C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,UAAU,IAAI,EAAE,EAAE,CAAC;YACzE,SAAS;QACX,CAAC;QACD,UAAU,CAAC,IAAI,CAAC;YACd,IAAI;YACJ,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,CACtB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,CAC3F;SACF,CAAC,CAAC;IACL,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;AAC1F,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,2BAA2B,CACzC,UAAyC;IAEzC,OAAO,UAAU;SACd,GAAG,CACF,CAAC,SAAS,EAAE,EAAE,CACZ,QAAQ,SAAS,CAAC,IAAI,oBAAoB,SAAS,CAAC,MAAM,CAAC,MAAM,eAAe;QAChF,gFAAgF;QAChF,kCAAkC;QAClC,SAAS,CAAC,MAAM;aACb,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,UAAU,GAAG,CAAC;aAC/D,IAAI,CAAC,IAAI,CAAC,CAChB;SACA,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC"}

package/dist/kernel/i18n/request-language.d.ts

@@ -0,0 +1,80 @@
+import type { FastifyRequest } from 'fastify';
+import { type SupportedLanguage } from '@endora-commerce/contracts';
+export interface RequestLanguageDeps {
+    /**
+     * The admin's stored `preferredLanguage`, or `null`.
+     *
+     * Supplied by the composition root rather than resolved here (D-137): the
+     * policy is the kernel's, the one rung that reads a module's data is not.
+     *
+     * **What the root supplies it out of is a gated port, and this doc block used
+     * to say it must not be.** The paragraph read: "a gated port would throw
+     * `ModuleDisabledError` while another error is being serialised, and the
+     * guard that mistake needs is a `catch` around a port — `check:port-catches`
+     * refuses one, and is right to. A root reading its own entity has no gate and
+     * no such failure mode." Feature 080's T052 then converted the closure from
+     * `em().findOne(AdminUser, …)` to `adminUserReadPort.findById(…)`, because
+     * D-168 leaves a packaged module no named entity class for a root to read —
+     * so the entity-reading alternative the paragraph rested on no longer exists.
+     *
+     * The prediction was exactly right about the consequence. With `admin_users`
+     * platform-absent, every error answered to a signed-in admin lost its
+     * `ErrorEnvelope` outright: the throw lands in `preSerialization` of a reply
+     * Fastify is already treating as an error, so it cannot be routed back
+     * through `setErrorHandler` and Fastify's own fallback serialiser answers
+     * instead. The remedy is not the `catch` the paragraph refused — the guard
+     * lives in `registerErrorEnvelope`, around the whole decoration, where it is
+     * a renderer declining to let a decoration replace the thing it decorates
+     * rather than a caller hiding a capability's absence.
+     *
+     * So the standing rule for this dependency is the weaker, true one: it may
+     * throw, and a caller that cannot afford the throw must say so at its own
+     * seam. {@link createRequestLanguageResolver} does not catch it.
+     */
+    adminPreferredLanguage: (adminUserId: string) => Promise<string | null>;
+}
+/**
+ * A tag reduced to a language the platform ships a bundle for, or `null`.
+ *
+ * The candidate set is `SUPPORTED_LANGUAGES` and nothing else — **not** the
+ * channel's `languages[]` (D-135). That column is a market's content offer, is
+ * empty on most rows that exist, and bounding by it would need an "empty means
+ * unbounded" carve-out: an absent value silently becoming a permissive one.
+ *
+ * A tag that does not normalise is not an error and is not echoed anywhere. It
+ * falls to the next rung; it never becomes one.
+ */
+export declare function normalise(tag: string | null | undefined): SupportedLanguage | null;
+/**
+ * `Accept-Language` as an ordered list of tags, heaviest `q` first.
+ *
+ * RFC 9110 makes the header a q-weighted list, and three sites in the tree read
+ * it as `split(',')[0]` — so `en;q=0.2,pl;q=0.9` is read as English by every
+ * one of them. Exported for their conversion (T024); nothing else in this
+ * feature reads it.
+ *
+ * Bounded twice, because the header is attacker-controlled on every request:
+ * to {@link MAX_HEADER_LENGTH} characters and, after weighting, to
+ * {@link MAX_TAGS} tags. Exceeding either is not an error — the remainder is
+ * simply not read. A malformed `q` drops its tag rather than guessing a weight.
+ * `*` is returned as an ordinary tag and never normalises.
+ */
+export declare function parseAcceptLanguage(header: string | string[] | undefined): string[];
+/**
+ * The ladder in this file's header, as a function of the request.
+ *
+ * Every rung that cannot *answer* falls to the next, and the last always
+ * answers. The buyer arm performs no database read at all — the channel is
+ * already resolved and cached on the request scope.
+ *
+ * The admin arm is the exception and this used to claim otherwise ("it never
+ * throws"): it calls {@link RequestLanguageDeps.adminPreferredLanguage}, which
+ * a root supplies out of a gated port, so it throws while the owner of that
+ * port is absent. Not caught here, deliberately — a `catch` around a port at
+ * the one site that reads it is the shape `check:port-catches` refuses. The
+ * caller that cannot afford the throw guards at its own seam, and there is one:
+ * `registerErrorEnvelope`, whose decoration falls back to the untranslated
+ * envelope.
+ */
+export declare function createRequestLanguageResolver(deps: RequestLanguageDeps): (request: FastifyRequest) => Promise<SupportedLanguage>;
+//# sourceMappingURL=request-language.d.ts.map

package/dist/kernel/i18n/request-language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-language.d.ts","sourceRoot":"","sources":["../../../src/kernel/i18n/request-language.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AA4CpC,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAAsB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACzE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAMlF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,CAcnF;AAgBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,mBAAmB,GACxB,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,iBAAiB,CAAC,CA6CzD"}

package/dist/kernel/i18n/request-language.js

@@ -0,0 +1,168 @@
+import { LANGUAGE_FALLBACK, SUPPORTED_LANGUAGES, } from '@endora-commerce/contracts';
+import { currentSalesChannel } from '../sales-channels/sales-channel-resolver.middleware.js';
+/**
+ * Which language the platform answers a request in (feature 083, D-130 … D-139).
+ *
+ * **The platform answers in the language the client is rendering in, and each
+ * audience states that language the way its own client already computes it.**
+ * The two shipped clients compute it differently, so this is one function with
+ * one branch on actor kind rather than one ladder pretending to serve both:
+ *
+ * ```
+ * actor.kind === 'admin'
+ *   1. the stored `preferredLanguage`      — the admin SPA renders from this
+ *   2. LANGUAGE_FALLBACK                      field and ignores the browser
+ *
+ * otherwise (anonymous | customer | api_key)
+ *   0. [reserved] a stored per-customer preference — see below
+ *   1. Accept-Language, q-sorted, first tag that normalises
+ *   2. the resolved sales channel's `defaultLanguage`
+ *   3. LANGUAGE_FALLBACK
+ * ```
+ *
+ * **The channel is the buyer's backstop, never their override** (D-131). The
+ * platform already resolves product *content* header-first
+ * (`CatalogQueryService.pickLang`, feature 022); inverting it here would name a
+ * product in one language and refuse it in another inside one response body.
+ * And the header is not a browser setting on this platform — it is the
+ * storefront's own answer, written by its language switcher, so overriding it
+ * from the channel would contradict a choice the buyer made two clicks ago.
+ *
+ * Before this file, `resolvePreferredLanguage` was a closure in each of the two
+ * composition roots and both began `if (actor.kind !== 'admin') return null`.
+ * Every Polish error sentence the platform ships was therefore unreachable for
+ * a buyer, from the day the hook was written (issue #234). The policy lives in
+ * one kernel file now: the roots keep one line each, the admin lookup, which is
+ * the only rung that reads a module's table.
+ */
+/** Bound on the header read — the parse half of the security bound (D-139 § 8.1). */
+const MAX_HEADER_LENGTH = 512;
+/** Bound on how many tags are considered, applied **after** q-sorting. */
+const MAX_TAGS = 10;
+/**
+ * A tag reduced to a language the platform ships a bundle for, or `null`.
+ *
+ * The candidate set is `SUPPORTED_LANGUAGES` and nothing else — **not** the
+ * channel's `languages[]` (D-135). That column is a market's content offer, is
+ * empty on most rows that exist, and bounding by it would need an "empty means
+ * unbounded" carve-out: an absent value silently becoming a permissive one.
+ *
+ * A tag that does not normalise is not an error and is not echoed anywhere. It
+ * falls to the next rung; it never becomes one.
+ */
+export function normalise(tag) {
+    if (!tag)
+        return null;
+    const primary = tag.split('-', 1)[0]?.trim().toLowerCase() ?? '';
+    return SUPPORTED_LANGUAGES.includes(primary)
+        ? primary
+        : null;
+}
+/**
+ * `Accept-Language` as an ordered list of tags, heaviest `q` first.
+ *
+ * RFC 9110 makes the header a q-weighted list, and three sites in the tree read
+ * it as `split(',')[0]` — so `en;q=0.2,pl;q=0.9` is read as English by every
+ * one of them. Exported for their conversion (T024); nothing else in this
+ * feature reads it.
+ *
+ * Bounded twice, because the header is attacker-controlled on every request:
+ * to {@link MAX_HEADER_LENGTH} characters and, after weighting, to
+ * {@link MAX_TAGS} tags. Exceeding either is not an error — the remainder is
+ * simply not read. A malformed `q` drops its tag rather than guessing a weight.
+ * `*` is returned as an ordinary tag and never normalises.
+ */
+export function parseAcceptLanguage(header) {
+    const raw = Array.isArray(header) ? header[0] : header;
+    if (!raw)
+        return [];
+    const weighted = [];
+    for (const part of raw.slice(0, MAX_HEADER_LENGTH).split(',')) {
+        const [tagPart, ...parameters] = part.split(';');
+        const tag = tagPart?.trim() ?? '';
+        if (tag.length === 0)
+            continue;
+        const weight = readWeight(parameters);
+        if (weight === null)
+            continue;
+        weighted.push({ tag, weight, order: weighted.length });
+    }
+    weighted.sort((a, b) => b.weight - a.weight || a.order - b.order);
+    return weighted.slice(0, MAX_TAGS).map((entry) => entry.tag);
+}
+/** The `q` parameter of one list element: its weight, `1` by default, or `null` if malformed. */
+function readWeight(parameters) {
+    for (const parameter of parameters) {
+        const separator = parameter.indexOf('=');
+        if (separator < 0)
+            continue;
+        if (parameter.slice(0, separator).trim().toLowerCase() !== 'q')
+            continue;
+        const value = parameter.slice(separator + 1).trim();
+        const parsed = Number(value);
+        if (value.length === 0 || !Number.isFinite(parsed))
+            return null;
+        return parsed;
+    }
+    return 1;
+}
+/**
+ * The ladder in this file's header, as a function of the request.
+ *
+ * Every rung that cannot *answer* falls to the next, and the last always
+ * answers. The buyer arm performs no database read at all — the channel is
+ * already resolved and cached on the request scope.
+ *
+ * The admin arm is the exception and this used to claim otherwise ("it never
+ * throws"): it calls {@link RequestLanguageDeps.adminPreferredLanguage}, which
+ * a root supplies out of a gated port, so it throws while the owner of that
+ * port is absent. Not caught here, deliberately — a `catch` around a port at
+ * the one site that reads it is the shape `check:port-catches` refuses. The
+ * caller that cannot afford the throw guards at its own seam, and there is one:
+ * `registerErrorEnvelope`, whose decoration falls back to the untranslated
+ * envelope.
+ */
+export function createRequestLanguageResolver(deps) {
+    return async (request) => {
+        // `Actor | undefined` rather than `Actor`, and the widening is this site's
+        // rather than the declaration's (T118b). `request.actor` is decorated by
+        // `auth`'s `onRequest` hook, and this resolver runs while an error is being
+        // **serialised** — a reply Fastify rejected before that hook ran carries no
+        // decoration at all. Throwing here would mean failing to render an error
+        // with another error, so the absent case falls through to the rungs below.
+        //
+        // Until T118b this read went through a private `ActorSlice` interface,
+        // declared here because D-52 forbids the kernel an import of `auth`. The
+        // shape is `@endora-commerce/contracts`' now and the augmentation is the
+        // platform's own, so the restatement is gone and this reads the type every
+        // other consumer reads.
+        const actor = request.actor;
+        // The admin arm reads the stored preference and nothing else (D-132).
+        // `admin/src/App.tsx` renders the chrome from `preferredLanguage ?? 'en'`
+        // and does not send `Accept-Language` at all, so consulting the browser
+        // here would put Polish refusals on an English screen. Consulting the
+        // channel would make an operator's error language depend on whichever
+        // channel their last request happened to resolve, which is not a thing
+        // any operator chose.
+        if (actor?.kind === 'admin' && typeof actor.adminUserId === 'string') {
+            return normalise(await deps.adminPreferredLanguage(actor.adminUserId)) ?? LANGUAGE_FALLBACK;
+        }
+        // Rung 0 — a stored per-customer preference goes here when one exists, and
+        // the storefront's language switcher must write it for a logged-in buyer
+        // (D-133). Deliberately a comment and not a branch: there is no column, no
+        // contract field and no screen, and #234 does not need one.
+        for (const tag of parseAcceptLanguage(request.headers['accept-language'])) {
+            const language = normalise(tag);
+            if (language)
+                return language;
+        }
+        // A `null` channel is **normal**, not a failure: the resolver middleware
+        // does not run on `/api/v1/_health` or off the API prefix, and a request
+        // with no scope open has none either. The rung falls through; nothing is
+        // logged and nothing throws. Do not add a throw here — `currentSalesChannel`
+        // has a throwing sibling (`getResolvedChannel`) and reaching for it would
+        // turn every health-path error into a 500.
+        return normalise(currentSalesChannel()?.defaultLanguage) ?? LANGUAGE_FALLBACK;
+    };
+}
+//# sourceMappingURL=request-language.js.map

package/dist/kernel/i18n/request-language.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-language.js","sourceRoot":"","sources":["../../../src/kernel/i18n/request-language.ts"],"names":[],"mappings":"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"}

package/dist/kernel/index.d.ts

@@ -0,0 +1,142 @@
+/**
+ * The kernel (feature 072) — the platform's module-facing surface.
+ * Peer of `events/`, `tenancy/`, `http/`, `db/`; becomes the `./kernel` subpath
+ * of `@endora-commerce/platform` in F4 (D-160.1 — one host package, not five
+ * mirroring the five directories).
+ *
+ * **That subpath is the boundary a future `@endora-commerce/kernel` would
+ * take.** D-160.6 answered the meta-package *no* on measurement rather than on
+ * possibility — over the five publishable directories the graph holds one
+ * breakable cycle, and the median module needs four of the five — and it kept
+ * the split available in the direction it is cheap: one package becomes five by
+ * re-pointing a subpath, while five published packages become one only by
+ * breaking every dependent. So this barrel is a package boundary in waiting,
+ * and it carries **this directory's** symbols and nothing else. A symbol from
+ * `http/`, `events/`, `tenancy/` or `commands/` re-exported here to save a
+ * consumer one import line spends that option for a convenience.
+ *
+ * **What is on it is decided by `contracts/host-package.md` §1.3, not by what
+ * happens to be here** (T042c). Until T042c the barrel was an accumulation:
+ * 126 names, of which modules took **six** — `ModuleContext`, `lazyPort`, the
+ * two public-origin readers and two settings errors — while every other module
+ * reach into this directory went by relative path and will become a bare
+ * specifier when its module moves. Publishing the rest of the directory
+ * alongside them would have made `@endora-commerce/platform` owe a major
+ * version for `ManifestReconciler` (§1.3 row 46, **A**, on the barrel since
+ * feature 072), for the container the host builds once, and for
+ * `AuditLogService`, whose class D-160.10 replaced with {@link AuditPort}
+ * precisely so the platform does not freeze into a contract the shape
+ * Principle XIII routes around.
+ *
+ * So the rule is: a symbol is here when §1.3 records a module taking it from a
+ * file it marks **P**, or when it is the argument, return or thrown shape of a
+ * published method — a `@throws` a caller cannot name is a method a caller
+ * cannot call. Everything else is reachable by relative path, which the two
+ * composition roots and the tests have and a packaged module does not.
+ * `test/unit/kernel/published-surface.test.ts` is the two-way ratchet, and it
+ * carries the reason each removed name is not published.
+ *
+ * Three groups deserve naming here because a future author will look for them:
+ *
+ *  - **the composition machinery** — `createRootContainer`, `composeModules`,
+ *    `registerValues`, `createModuleContext`, `registerRequestScopeHook`,
+ *    `requiredModulesFrom` and the errors they raise. D-45 gives a module one
+ *    registration pass and one boot phase, both run by the host; no module
+ *    builds a container or composes a module list.
+ *  - **the seams a `ModuleContext` already exposes** — `registerPort`
+ *    (`ctx.di.providePort`), `defineModuleWorker` / `subscribeForModule` /
+ *    `pauseWorkersFor` / `resumeWorkersFor` (`ctx.worker`, `ctx.subscribe`),
+ *    `moduleLogger` (`ctx.log`). Publishing the function re-opens by bare
+ *    specifier the seam the context closed, which is `check:subscribe-seam`'s
+ *    argument in reverse.
+ *  - **the three classes §1.4d/§1.4e make ports** — `SettingsService`,
+ *    `SalesChannelMembershipService` and `SalesChannelResolverService` are
+ *    reached through `settingsReadPort`, `salesChannelMembershipPort` and
+ *    `salesChannelResolutionPort`; their error and mutation shapes stay,
+ *    because those are what a caller of the port catches and passes.
+ *
+ * Also not here, and classified **A** outright by §1.3: the registry cache,
+ * `ModuleRegistration`, `activationDeclarationsFrom`, and anything under `db/`,
+ * `overlay/` or `packages/`.
+ *
+ * The boundary rule, enforced by `scripts/check-kernel-boundary.ts`: a module
+ * may declare an ORM relation into the kernel, never into another module, and
+ * the kernel never relates into a module.
+ */
+export { type ModuleContext } from './module-context.js';
+export { lazyPort } from './lazy-port.js';
+/**
+ * The public origin of this backend, and the error the second one throws when a
+ * production deployment has none (issue #218). The root's boot-time refusal,
+ * `assertPublicApiBaseUrlConfigured`, is not published: it is the host's.
+ */
+export { PublicApiBaseUrlNotConfiguredError, configuredPublicApiBaseUrl, resolvePublicApiBaseUrl, } from './public-api-base-url.js';
+export { effectiveState, toModulePresenceDto } from './lifecycle/effective-state.js';
+export type { CapabilityRegistry, ExclusiveCapabilityDeclaration, ModuleCapabilityDeclaration, } from './lifecycle/capability-registry.js';
+/**
+ * The **P** half of `plugin-helpers` (§1.4c). `rethrowIfModuleDisabled` and
+ * `ModuleDisabledError` are mandated by composition-checklist item 7, and
+ * `requireModuleEnabled` is the sanctioned call for an entry point with no port
+ * and no request. The four worker/subscriber wrappers are not here — a composed
+ * module uses `ctx.worker` and `ctx.subscribe`.
+ */
+export { ModuleDisabledError, rethrowIfModuleDisabled, requireModuleEnabled, } from './lifecycle/plugin-helpers.js';
+/**
+ * The platform's structured-logger shape: `ctx.log`, the optional worker
+ * logger, and every `log` a module is handed or holds.
+ *
+ * The **type** is published and the destination machinery around it is not —
+ * `attachPlatformLogger` and `moduleLogger` are the host's, and a module that
+ * could call the second would re-open by bare specifier the attribution seam
+ * `ModuleContext` closed. A module needs the name because it declares fields
+ * and constructor parameters of this shape; it needs none of the rest.
+ *
+ * It was published under the name `WorkerLogger` from
+ * `lifecycle/plugin-helpers.js`, an identical interface declared a second time
+ * because nothing had noticed the first. Naming a consumer rather than a shape
+ * is what made a second declaration look reasonable — `ctx.log` is not a
+ * worker's — and the two spellings then diverged into a third name, an alias
+ * called `ModuleLifecycleLogger`, colliding with the unrelated hook logger
+ * `@endora-commerce/contracts` publishes under exactly that name.
+ */
+export { type PlatformLogger } from './logging.js';
+/**
+ * The one scope entry a module opens for itself (§1.3 row 13, 27 reaches). The
+ * platform-scope family below it is the host's: a module never asks which scope
+ * it is in, and the balance counter is a harness assertion.
+ */
+export { enterSystemScope } from './scope.js';
+/**
+ * The audit seam (D-160.10). `AuditLogService` is the host's implementation and
+ * is deliberately **not** published: Principle XIII routes a domain write
+ * through `CommandBus.run`, which makes the bus the audit log's caller, and
+ * freezing the writer class into the platform contract would owe third-party
+ * packages a major version to change the shape the principle routes around.
+ */
+export { type AuditPort, type RecordAuditInput, type AuditLogFilter } from './ports/audit.js';
+export { AuditLogEntry } from './audit/audit-log-entry.entity.js';
+export { InProcessCacheRegistry, inProcessCaches, type InProcessCacheLayer, } from './cache/in-process-cache-registry.js';
+export { hashPassword, verifyPassword } from './crypto/password-hasher.js';
+export { SalesChannel } from './sales-channels/sales-channel.entity.js';
+/**
+ * The channel cache as a module reads it. `toCachedChannel`, `CachedChannel`
+ * and the LRU TTL are how it is *filled*, which is the kernel's own half.
+ */
+export { SalesChannelsCache, SALES_CHANNELS_CACHE_KEY_PREFIX, SALES_CHANNELS_CACHE_NAMESPACE, type SalesChannelsCacheInvalidation, } from './sales-channels/sales-channels-cache.js';
+export { parseHostMap, type ResolverError, } from './sales-channels/sales-channel-resolver.service.js';
+export { NoSystemDefaultChannel } from './sales-channels/no-system-default-channel.error.js';
+export { type MembershipMutationOptions, type MembershipMutationResult, } from './sales-channels/sales-channel-membership.service.js';
+export { getResolvedChannel, currentSalesChannel, } from './sales-channels/sales-channel-resolver.middleware.js';
+export { productIdsInRequestChannel, outOfRequestChannel, } from './sales-channels/request-channel-assortment.js';
+export { Setting } from './settings/setting.entity.js';
+export { SettingGroup } from './settings/setting-group.entity.js';
+export { SettingValue } from './settings/setting-value.entity.js';
+export { SettingNotRegistered, SettingOutOfScopeForChannel, SettingValueShapeMismatch, SettingsChannelIdInvalid, } from './settings/settings.service.js';
+export { SETTINGS_CACHE_KEY_PREFIX, SETTINGS_CACHE_NAMESPACE, type SettingsCacheInvalidation, } from './settings/settings-cache.js';
+export { encryptSecretValue, secretValueIsSet, SecretKeyMissing, SecretKeyInvalid, } from './settings/secret-value-codec.js';
+export { type AdminPermissionChecker, type RequireAdminAnyFactory, type RequireAdminFactory, } from './ports/require-admin.js';
+export { type OrganizationReadPort, type OrganizationSnapshot } from './ports/organizations.js';
+export { type RequireCustomerGuard } from './ports/require-customer.js';
+export { type SettingsReadPort, type SettingsReadResult } from './ports/settings.js';
+export { type ResolvedChannel, type SalesChannelMembershipPort, type SalesChannelResolutionPort, } from './ports/sales-channel.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kernel/index.ts"],"names":[],"mappings":"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"}