@endora-commerce/platform 0.100.0

package/dist/kernel/compose.d.ts

@@ -0,0 +1,234 @@
+import type { EventBus } from '../events/bus.js';
+import type { ApiInterceptorRegistry } from '../http/interceptors/index.js';
+import { type KernelContainer } from './container.js';
+import { type RequiredModule } from './lifecycle/required-modules.js';
+import { type DecorationLedger, type DecorationRecord, type ModuleContext, type ModuleRegistrationSink, type RegistrationOwnership } from './module-context.js';
+import type { PlatformLogger } from './logging.js';
+export { AmbiguousDecorationError, ForeignDecorationError, PackageDecorationNotOfferedError, type DecorationLedger, type DecorationRecord, } from './module-context.js';
+/**
+ * The composition seam (feature 072, T042/T043).
+ *
+ * `registerModule` is what a module writes; this is what runs it. Everything a
+ * composition root needs to know about a module is the three fields of
+ * {@link ModuleEntry} — which is what makes the list generatable in Phase 5,
+ * and what makes removing a module a deletion rather than an archaeology
+ * exercise.
+ *
+ * Two invariants are enforced here rather than left to review, because both
+ * fail silently otherwise:
+ *
+ *  1. **One owner per registration name.** Otherwise which implementation the
+ *     platform runs depends on the order the composer happens to emit.
+ *  2. **Registration resolves nothing.** At the moment a module registers, the
+ *     modules after it have not registered yet, so an eager resolution either
+ *     throws or — worse — succeeds today and breaks when the topological order
+ *     changes for an unrelated reason.
+ */
+/**
+ * A module failed while the composer was running it (T053).
+ *
+ * The composer is the only place that knows *which* module is executing, so it
+ * is the only place that can say so. Without this, a boot failure reads
+ * `AwilixResolutionError: Could not resolve 'assetReferenceRegistry'` — a name,
+ * with no indication of which of the modules wanted it — and the operator's
+ * first move is to grep for a string that appears in six files.
+ *
+ * The kernel's own composition errors ({@link DuplicateRegistrationError},
+ * {@link EagerResolutionError}) already name the module (and, for a collision,
+ * both of them), so they propagate untouched rather than being wrapped twice.
+ */
+export declare class ModuleCompositionError extends Error {
+    readonly moduleId: string;
+    readonly phase: 'register' | 'decorate' | 'boot';
+    readonly cause: unknown;
+    constructor(moduleId: string, phase: 'register' | 'decorate' | 'boot', cause: unknown);
+}
+/**
+ * A root contributed outside the contribution window (issue #52).
+ *
+ * The window is the single slot between `composeModules(MODULES, …)` and
+ * `runBootHooks()` (D-45), and both of its edges used to be a convention two
+ * composition roots had to remember identically. {@link ComposedModules.contribute}
+ * makes the early edge structural — there is nothing to call the method on until
+ * the registration pass is over — and this makes the late edge loud.
+ */
+export declare class ContributionWindowClosedError extends Error {
+    readonly names: readonly string[];
+    constructor(names: readonly string[]);
+}
+/** What the composer knows about one module. Nothing else about it is reachable. */
+export interface ModuleEntry {
+    /** The manifest id. Injected here, never hard-coded inside the module (FR-031). */
+    readonly id: string;
+    /** The manifest version. */
+    readonly version: string;
+    readonly registerModule: (ctx: ModuleContext) => void;
+    /**
+     * This entry is one of the active **deployment's** overlay modules, found
+     * under `backend/src/apps/<deployment>/modules/` (issue #203).
+     *
+     * Absent for every core module, and the generated composer is what sets it —
+     * from the root the module was discovered under, never from anything the
+     * module says about itself. It exempts the module from the ownership rule on
+     * `ctx.di.decorate`, which is why it is a location and not a declaration.
+     */
+    readonly overlay?: boolean;
+    /**
+     * This entry came from an **installed extension package**, not from this
+     * repository's tree (D-176 Q3).
+     *
+     * Set by the host's package loader from where it found the package, never by
+     * the package — the same rule `overlay` follows, and for the mirror-image
+     * purpose: `overlay` grants the decoration exemption, this **withholds** one.
+     * A deployment's overlay may wrap anything core registers and not a
+     * registration a package owns, because nothing in a package's `exports` map
+     * publishes the container names it registers internally. See
+     * {@link PackageDecorationNotOfferedError}.
+     *
+     * It is a separate field rather than `overlay` widened to an origin enum
+     * (D-156.4): one flag that both grants and refuses is one flag away from
+     * granting a stranger the audit path.
+     */
+    readonly installedPackage?: boolean;
+}
+export interface ComposeModulesOptions {
+    readonly container: KernelContainer;
+    readonly eventBus: EventBus;
+    readonly log: PlatformLogger;
+    /** Absent in composition roots that mount no interceptor surface. */
+    readonly interceptorRegistry?: ApiInterceptorRegistry | undefined;
+    /**
+     * Share one ledger across several `composeModules` calls — which is what a
+     * root does while modules are converted one batch at a time, so a converted
+     * module still collides with a converted module composed in another call.
+     */
+    readonly ownership?: RegistrationOwnership | undefined;
+    /**
+     * Share one decoration ledger across several `composeModules` calls, for the
+     * same reason `ownership` is shared: a client module composed in a later call
+     * still wraps a registration an earlier call decorated.
+     */
+    readonly decorations?: DecorationLedger | undefined;
+    /**
+     * Declared wrapping order per registration name, reaching the composer as
+     * data.
+     *
+     * Only needed where **two different modules** decorate one name; below that
+     * there is nothing to decide. It is checked rather than applied: the composer
+     * emits modules in topological order, so the declaration's job is to say that
+     * this order is the intended one, and composition fails when the two
+     * disagree.
+     *
+     * **Both composition roots pass it**, from the deployment's own
+     * `backend/src/apps/<deployment>/divergence.ts` (feature 107, FR-040/FR-041).
+     * The declaration is a hand-written, reviewed file in the deployment's tree;
+     * `loadDivergenceDeclaration` reads it and each root hands the field over as
+     * data, in the shape `requiredModules` and `activationDeclarations` already
+     * have — the composer is given the answer and never reads a file.
+     *
+     * It was a seam with **no** supply until then (D-156.7): the field was written
+     * against `endora.config.ts`'s `overrides.order` (D-28), an instance-repository
+     * artefact scheduled for F11 that the owner has since ruled will not be built,
+     * so a deployment shipping two overlay modules that decorate one name got
+     * `AmbiguousDecorationError` and could not declare its way out. That failed
+     * closed, so nothing was unsafe; it was a dead end wearing an instruction, and
+     * this paragraph carried the coupling — *"the day a root starts passing this,
+     * that message is what has to change with it"*. It changed with it:
+     * `AmbiguousDecorationError` now names this field and that file.
+     *
+     * Three shapes the *report's* check refuses, because they describe nothing and
+     * will describe the wrong thing later: an entry for a name no two overlay
+     * modules decorate, an entry naming a module that is not one of this
+     * deployment's, and an entry naming fewer modules than decorate that name.
+     * They are `check:divergence`'s and not this composer's, because a stale
+     * ordering is a merge-request question while an ambiguity is a correctness one.
+     */
+    readonly decorationOrder?: Readonly<Record<string, readonly string[]>> | undefined;
+    /**
+     * The modules this composition is required to have — issue #258, and see
+     * `lifecycle/required-modules.ts` for the whole reasoning.
+     *
+     * A root derives it with `requiredModulesFrom(manifests)` and hands it over as
+     * data, for the same reason `activationDeclarationsFrom` exists: the composer
+     * is given three fields per module and may not read a manifest. Deriving it is
+     * the root's job; there is no list anywhere, so withdrawing a lock changes
+     * this refusal in the same run (D-100).
+     *
+     * Omitting it means *this composition requires nothing*, which is the honest
+     * answer for a fixture composing two modules that do not exist. Every root
+     * that composes the platform passes it, and `harness-parity.test.ts` is what
+     * keeps the two from drifting apart on it.
+     */
+    readonly requiredModules?: readonly RequiredModule[] | undefined;
+}
+export interface ComposedModules {
+    /** Everything the modules contributed, in registration order. */
+    readonly sink: ModuleRegistrationSink;
+    /** Which module registered `name`, for diagnostics and for the duplicate report. */
+    ownerOf(name: string): string | undefined;
+    /**
+     * The override report (T065): every decoration this composition applied, in
+     * application order, innermost first.
+     *
+     * A build's customisations should be readable from the build, not inferred
+     * from which files happen to exist on disk. Empty means a bare-core build,
+     * and it means it explicitly.
+     */
+    readonly decorations: readonly DecorationRecord[];
+    /**
+     * The **contribution window** (D-45, issue #52): the one slot where a root
+     * may write a name a module has defaulted.
+     *
+     * Register it earlier and the module's own registration overwrites it;
+     * register it later and a boot hook has already read the default. Both edges
+     * are enforced by the shape rather than remembered: the early one because
+     * this object does not exist until every module has registered, the late one
+     * because the method refuses once {@link runBootHooks} has started
+     * ({@link ContributionWindowClosedError}).
+     *
+     * Host values **no module defaults** — the Redis client, the EventBus, a
+     * deployment flag — have no window at all and are registered with
+     * `registerValues` where they come into existence. The window is about
+     * overwriting, and there is nothing to overwrite.
+     */
+    contribute(values: Readonly<Record<string, unknown>>): void;
+    /**
+     * A **post-registration** `ModuleContext` for one composed module — D-157.7,
+     * beside `ownerOf` and `contribute`, which are the two accessors this object
+     * already exists to provide.
+     *
+     * It exists for the host's CLI runner (D-160.9): a module-declared command
+     * receives a `ModuleContext`, not a cradle, so its body resolves with
+     * `lazyPort<T>(ctx, 'literalName')` — character-for-character what
+     * `backend.ts` writes, which is what keeps `check:port-dependencies` able to
+     * see the edge. A `scope.cradle.someForeignPort` read would be an undeclared
+     * port edge that reports clean.
+     *
+     * Two properties of the context it returns, both deliberate:
+     *
+     *  - `isRegistering` is **false**, so the phase guard permits resolution.
+     *    That is the whole difference from the context `registerModule` was
+     *    given, and it is correct here: every module has registered.
+     *  - its registration **sink is a throwaway**. A command is invoked after the
+     *    composition is built, so a route or a worker pushed into it is read by
+     *    nobody. The sink is not shared with the composition's, so a command
+     *    cannot half-register a surface into a running platform either.
+     *
+     * @throws {Error} when `moduleId` is not one of the composed entries — a
+     * caller asking for a context by id has to be told the id is wrong, rather
+     * than handed a context for a module that is not there.
+     */
+    contextFor(moduleId: string): ModuleContext;
+    /**
+     * Run the explicit boot phase (FR-021): every module's `onBoot` hook, in
+     * registration order, each inside its own `enterSystemScope`.
+     *
+     * A boot hook is the one place a module may do composition-time work that
+     * resolves — so it runs after **every** module has registered, and never as a
+     * side effect of route attachment, which a `BACKEND_ROLE=worker` process
+     * would never reach.
+     */
+    runBootHooks(): Promise<void>;
+}
+export declare function composeModules(entries: readonly ModuleEntry[], options: ComposeModulesOptions): ComposedModules;
+//# sourceMappingURL=compose.d.ts.map

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

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

package/dist/kernel/compose.js

@@ -0,0 +1,279 @@
+import { registerValues } from './container.js';
+import { effectiveState } from './lifecycle/effective-state.js';
+import { assertRequiredModulesPresent, } from './lifecycle/required-modules.js';
+import { assertUniqueModuleIds } from './lifecycle/unique-module-ids.js';
+import { enterSystemScope } from './scope.js';
+import { AmbiguousDecorationError, DuplicateRegistrationError, EagerResolutionError, ForeignDecorationError, PackageDecorationNotOfferedError, createDecorationLedger, createDecorationQueue, createModuleContext, createModuleRegistrationSink, createRegistrationOwnership, } from './module-context.js';
+export { AmbiguousDecorationError, ForeignDecorationError, PackageDecorationNotOfferedError, } from './module-context.js';
+/**
+ * The composition seam (feature 072, T042/T043).
+ *
+ * `registerModule` is what a module writes; this is what runs it. Everything a
+ * composition root needs to know about a module is the three fields of
+ * {@link ModuleEntry} — which is what makes the list generatable in Phase 5,
+ * and what makes removing a module a deletion rather than an archaeology
+ * exercise.
+ *
+ * Two invariants are enforced here rather than left to review, because both
+ * fail silently otherwise:
+ *
+ *  1. **One owner per registration name.** Otherwise which implementation the
+ *     platform runs depends on the order the composer happens to emit.
+ *  2. **Registration resolves nothing.** At the moment a module registers, the
+ *     modules after it have not registered yet, so an eager resolution either
+ *     throws or — worse — succeeds today and breaks when the topological order
+ *     changes for an unrelated reason.
+ */
+/**
+ * A module failed while the composer was running it (T053).
+ *
+ * The composer is the only place that knows *which* module is executing, so it
+ * is the only place that can say so. Without this, a boot failure reads
+ * `AwilixResolutionError: Could not resolve 'assetReferenceRegistry'` — a name,
+ * with no indication of which of the modules wanted it — and the operator's
+ * first move is to grep for a string that appears in six files.
+ *
+ * The kernel's own composition errors ({@link DuplicateRegistrationError},
+ * {@link EagerResolutionError}) already name the module (and, for a collision,
+ * both of them), so they propagate untouched rather than being wrapped twice.
+ */
+export class ModuleCompositionError extends Error {
+    moduleId;
+    phase;
+    cause;
+    constructor(moduleId, phase, cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        super(phase === 'register'
+            ? `[kernel] module '${moduleId}' failed while registering: ${detail}`
+            : phase === 'decorate'
+                ? // D-176 — a decoration is applied at the drain, after the last
+                    // module has registered, so a failure in one is no longer inside
+                    // the decorating module's `registerModule`. The phase says so
+                    // rather than borrowing 'register', which would attribute the
+                    // failure to a call that had already returned.
+                    `[kernel] module '${moduleId}' failed while its decoration was applied: ${detail}`
+                : `[kernel] module '${moduleId}' failed in its boot hook: ${detail}`);
+        this.moduleId = moduleId;
+        this.phase = phase;
+        this.cause = cause;
+        this.name = 'ModuleCompositionError';
+    }
+}
+/**
+ * A root contributed outside the contribution window (issue #52).
+ *
+ * The window is the single slot between `composeModules(MODULES, …)` and
+ * `runBootHooks()` (D-45), and both of its edges used to be a convention two
+ * composition roots had to remember identically. {@link ComposedModules.contribute}
+ * makes the early edge structural — there is nothing to call the method on until
+ * the registration pass is over — and this makes the late edge loud.
+ */
+export class ContributionWindowClosedError extends Error {
+    names;
+    constructor(names) {
+        super(`[kernel] contribution outside the window: ${names.join(', ')}. ` +
+            'A root contribution over a name a module defaults goes between ' +
+            '`composeModules(MODULES, …)` and `runBootHooks()` (D-45). The boot phase has ' +
+            'already started, so a hook may have read the default this was meant to replace ' +
+            '— move the `contribute(…)` call above `runBootHooks()`.');
+        this.names = names;
+        this.name = 'ContributionWindowClosedError';
+    }
+}
+/** Both already carry the module id; wrapping them would only bury it. */
+function alreadyNamesTheModule(error) {
+    return (error instanceof DuplicateRegistrationError ||
+        error instanceof EagerResolutionError ||
+        error instanceof AmbiguousDecorationError ||
+        error instanceof ForeignDecorationError ||
+        error instanceof PackageDecorationNotOfferedError);
+}
+export function composeModules(entries, options) {
+    // T030c / D-155.7 — module id uniqueness, in the same slot and for the same
+    // reason as the refusal below: both answers exist already, and a composition
+    // that is going to be refused must not half-run first. Unconditional, because
+    // there is no composition in which two entries claiming one id is a coherent
+    // request — see `lifecycle/unique-module-ids.ts` for what used to happen
+    // instead.
+    assertUniqueModuleIds(entries.map((entry) => entry.id));
+    // Issue #258 — before the first module registers, because both answers this
+    // needs exist already and nothing it could refuse is worth half-doing. It has
+    // to land ahead of the boot phase, which is where the failure it prevents
+    // surfaces (as `invoices` failing in a hook, naming the wrong module and no
+    // remedy); ahead of the *registration* phase is simply the earliest point
+    // that is still ahead of it.
+    //
+    // A composition passing no `requiredModules` requires nothing and is left
+    // alone: the presence singleton is process-wide and has nothing to do with a
+    // fixture composing two modules that do not exist.
+    if (options.requiredModules && options.requiredModules.length > 0) {
+        assertRequiredModulesPresent(options.requiredModules, new Set(entries.map((entry) => entry.id)), effectiveState);
+    }
+    const combined = createModuleRegistrationSink();
+    const ownership = options.ownership ?? createRegistrationOwnership();
+    const decorations = options.decorations ?? createDecorationLedger(options.decorationOrder ?? {});
+    const bootHooks = [];
+    // D-176 — every `ctx.di.decorate` of this pass lands here and is applied
+    // below, once the last module has registered.
+    const decorationQueue = createDecorationQueue();
+    // D-176 Q3 — which of these entries a stranger shipped. Derived from the
+    // entries the root handed over, so a package cannot answer for itself, and
+    // read only by the decoration guard.
+    const installedPackageModuleIds = new Set(entries.filter((entry) => entry.installedPackage === true).map((entry) => entry.id));
+    // Read by every context this call creates, so the phase guard covers the
+    // whole pass rather than one module at a time: module A resolving something
+    // module B registers is exactly the order-dependence being forbidden.
+    let registering = true;
+    try {
+        for (const entry of entries) {
+            const sink = createModuleRegistrationSink();
+            const ctx = createModuleContext({
+                module: { id: entry.id, version: entry.version },
+                container: options.container,
+                eventBus: options.eventBus,
+                sink,
+                log: options.log,
+                ownership,
+                decorations,
+                decorationQueue,
+                installedPackageModuleIds,
+                isRegistering: () => registering,
+                ...(entry.overlay === undefined ? {} : { overlay: entry.overlay }),
+                ...(options.interceptorRegistry
+                    ? { interceptorRegistry: options.interceptorRegistry }
+                    : {}),
+            });
+            try {
+                entry.registerModule(ctx);
+            }
+            catch (err) {
+                if (alreadyNamesTheModule(err))
+                    throw err;
+                throw new ModuleCompositionError(entry.id, 'register', err);
+            }
+            combined.plugins.push(...sink.plugins);
+            combined.rootPlugins.push(...sink.rootPlugins);
+            combined.workers.push(...sink.workers);
+            combined.unsubscribes.push(...sink.unsubscribes);
+            for (const hook of sink.bootHooks)
+                bootHooks.push({ moduleId: entry.id, hook });
+        }
+    }
+    finally {
+        registering = false;
+    }
+    // ---- The decoration drain (D-176) ---------------------------------------
+    //
+    // One registration pass, then one drain. Every `ctx.di.decorate` of the pass
+    // above was queued rather than applied, so what a decoration can reach no
+    // longer depends on where its module sat in the array — which is what makes
+    // D-45's sentence true of this seam as well: registration order is
+    // meaningless, and `decorate` was the one operation that read and rewrote the
+    // container without resolving anything, so the `registering` guard never saw
+    // the dependency it created.
+    //
+    // In the queue's own order, deliberately. `AmbiguousDecorationError` exempts
+    // a module that decorates one name twice because it wrote both wraps in the
+    // order it wrote them, and a queue keeps that for free.
+    //
+    // Nothing is sorted and nothing is grouped: the drain removes the
+    // *dependency* on order, not the order. Two different modules decorating one
+    // name is still refused unless the composition declares which wraps which.
+    for (const pending of decorationQueue.pending) {
+        try {
+            pending.apply();
+        }
+        catch (err) {
+            // The kernel's own decoration refusals name the module already; anything
+            // else — a wrap that threw while building — is attributed to the module
+            // that wrote it, which is the fact the queued entry carries for exactly
+            // this reason.
+            if (alreadyNamesTheModule(err))
+                throw err;
+            throw new ModuleCompositionError(pending.moduleId, 'decorate', err);
+        }
+    }
+    // The report is emitted, not merely available: a deployment running a client
+    // override should say so once at boot, in the same place the operator already
+    // reads what the platform composed.
+    if (decorations.entries.length > 0) {
+        options.log.info({
+            overrides: decorations.entries.map((entry) => ({
+                registration: entry.name,
+                decoratedBy: entry.moduleId,
+                owner: entry.owner ?? null,
+                depth: entry.depth,
+            })),
+        }, 'kernel.decorations');
+    }
+    // Closed by the boot phase rather than by the end of it: hooks run in
+    // registration order, so a contribution made from inside one is already
+    // invisible to every hook that ran before it.
+    let contributionWindowOpen = true;
+    return {
+        sink: combined,
+        ownerOf: (name) => ownership.ownerOf(name),
+        decorations: decorations.entries,
+        contextFor(moduleId) {
+            const entry = entries.find((candidate) => candidate.id === moduleId);
+            if (entry === undefined) {
+                throw new Error(`[kernel] no module '${moduleId}' in this composition, so there is no context to ` +
+                    `build for it. Composed: ${entries.map((e) => e.id).join(', ')}.`);
+            }
+            return createModuleContext({
+                module: { id: entry.id, version: entry.version },
+                container: options.container,
+                eventBus: options.eventBus,
+                // Throwaway — see the interface comment. Nothing reads it, and that is
+                // better than handing over the composition's, which a command could
+                // push a route into after the server was built.
+                sink: createModuleRegistrationSink(),
+                log: options.log,
+                ownership,
+                decorations,
+                // No queue, and that is the honest shape: the drain has already run, so
+                // a decoration written from a command's context applies at the call —
+                // which is what it did before D-176 and what it must keep doing, since
+                // queueing it would be a wrap nobody ever applies. The guards are
+                // unchanged either way, `installedPackageModuleIds` included.
+                installedPackageModuleIds,
+                // The one difference from the registration pass: every module has
+                // registered, so resolving is exactly what this context is for.
+                isRegistering: () => false,
+                ...(entry.overlay === undefined ? {} : { overlay: entry.overlay }),
+                ...(options.interceptorRegistry
+                    ? { interceptorRegistry: options.interceptorRegistry }
+                    : {}),
+            });
+        },
+        contribute(values) {
+            if (!contributionWindowOpen) {
+                throw new ContributionWindowClosedError(Object.keys(values));
+            }
+            registerValues(options.container, values);
+        },
+        async runBootHooks() {
+            contributionWindowOpen = false;
+            for (const { moduleId, hook } of bootHooks) {
+                await enterSystemScope(`boot: ${moduleId}`, async () => {
+                    try {
+                        await hook();
+                    }
+                    catch (err) {
+                        if (alreadyNamesTheModule(err))
+                            throw err;
+                        throw new ModuleCompositionError(moduleId, 'boot', err);
+                    }
+                }, 
+                // Branch the scope off the container these modules registered into,
+                // not off the process-wide default. `ctx.cradle()` resolves through
+                // the ambient scope when there is one, so a boot hook opened against
+                // the wrong root would fail to resolve the module's own services —
+                // in a composition root that never called `setRootContainer`, which
+                // is every unit test that composes its own container.
+                { entryPoint: 'boot', container: options.container });
+            }
+        },
+    };
+}
+//# sourceMappingURL=compose.js.map

package/dist/kernel/compose.js.map

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

package/dist/kernel/container.d.ts

@@ -0,0 +1,95 @@
+import { type AwilixContainer } from 'awilix';
+import type { EntityManager, MikroORM } from '@mikro-orm/postgresql';
+/**
+ * The kernel's root container (feature 072).
+ *
+ * `composition.ts` hand-wires 3144 lines and therefore imports every module by
+ * name. The container replaces that with registrations, so a module set becomes
+ * a build-time variable. Modules never see this file — they see `ModuleContext`,
+ * so the container stays swappable behind that seam.
+ *
+ * Two construction options are load-bearing:
+ *
+ *  - **`InjectionMode.PROXY`** — a registration receives one `cradle` argument
+ *    and destructures the names it needs, so adding a dependency is not a
+ *    positional-argument change at every call site.
+ *  - **`strict: true`** — awilix refuses a lifetime mismatch (a singleton
+ *    capturing a scoped registration) at resolution rather than silently
+ *    pinning the first request's value for the life of the process. Given that
+ *    the one scoped value is the resolved sales channel, a silent capture would
+ *    be a Constitution XII violation with no test to catch it.
+ *
+ * In both modes an unknown name **throws** `AwilixResolutionError`; it never
+ * resolves `undefined`. That is the property `composition.ts` could not offer —
+ * a missing option object key there is `undefined` reaching business logic.
+ */
+/**
+ * The resolution surface. Module registrations are added at composition time,
+ * so the index signature is the honest static type: the container is the
+ * runtime authority, and a miss throws.
+ */
+export interface KernelCradle {
+    /**
+     * The closure ~59 module factories take today as `emFactory`. Calling it
+     * always forks; see the note on `em` below.
+     */
+    readonly emFactory: () => EntityManager;
+    /**
+     * A fresh `EntityManager` fork per resolution — **transient**, matching
+     * `composition.ts:282`'s `em = () => forkScopedEm(orm)` called once per
+     * service method (research R-1b). There is deliberately no request-scoped
+     * EntityManager: introducing one would change identity-map sharing, flush
+     * ordering and transaction nesting for every service in the codebase.
+     */
+    readonly em: EntityManager;
+    readonly [name: string]: unknown;
+}
+export type KernelContainer = AwilixContainer<KernelCradle>;
+/** Build a root container. One per process; scopes are children of it. */
+export declare function createRootContainer(): KernelContainer;
+/**
+ * Register the ORM-derived names.
+ *
+ * `emFactory` keeps today's exact semantics — it is the closure, and every call
+ * forks. `em` is the container-native spelling of the same thing: **transient**,
+ * so each resolution yields its own fork with its own identity map. Neither is
+ * scoped, and that is the invariant the whole request seam rests on: the tenant
+ * filter reads `AsyncLocalStorage` at query-build time (`tenancy/filters.ts`),
+ * which is what makes a bare fork correct.
+ */
+export declare function registerOrm(container: KernelContainer, orm: MikroORM): void;
+/**
+ * Register plain values a composition root already owns — the Redis client, the
+ * `requireAdmin` factory, a port implementation a not-yet-converted module
+ * exposes through its handle.
+ *
+ * It exists so a composition root spells the container's vocabulary without
+ * importing `awilix` either. Modules are *forbidden* to import it
+ * (`scripts/check-container-imports.ts`); a root importing it would still be
+ * one more file to touch the day the container is swapped.
+ */
+export declare function registerValues(container: KernelContainer, values: Readonly<Record<string, unknown>>): void;
+/**
+ * The process-wide root container, created on first use. `enterPlatformScope`
+ * falls back to it so a CLI script or an interval sweep needs no wiring to open
+ * a scope.
+ */
+export declare function getRootContainer(): KernelContainer;
+/** Install a composed root. Used by the composer, and by tests that build their own. */
+export declare function setRootContainer(container: KernelContainer): void;
+/**
+ * Dispose the root container and forget it. Runs every registration's
+ * `.disposer(...)` — Redis clients, queue connections, the ORM — so a composed
+ * process tears down through one call instead of a hand-maintained list.
+ */
+export declare function disposeRootContainer(): Promise<void>;
+/**
+ * Dispose `container` when the process is asked to stop. Returns a detach
+ * function so a test (or a second composition in the same process) does not
+ * leak signal handlers.
+ *
+ * Not installed automatically: importing the kernel must not attach global
+ * signal handlers, or 900 test files would each add a set.
+ */
+export declare function installShutdownDisposal(container: KernelContainer, signals?: readonly NodeJS.Signals[]): () => void;
+//# sourceMappingURL=container.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/kernel/container.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,QAAQ,CAAC;AAChB,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,aAAa,CAAC;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,EAAE,aAAa,CAAC;IAC3B,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC;AAED,MAAM,MAAM,eAAe,GAAG,eAAe,CAAC,YAAY,CAAC,CAAC;AAE5D,0EAA0E;AAC1E,wBAAgB,mBAAmB,IAAI,eAAe,CAKrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,CAM3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,eAAe,EAC1B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,IAAI,CAIN;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAGlD;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAEjE;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAI1D;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,eAAe,EAC1B,OAAO,GAAE,SAAS,MAAM,CAAC,OAAO,EAA0B,GACzD,MAAM,IAAI,CAWZ"}