@endora-commerce/platform 0.100.0

package/dist/lifecycle/services/gating-graph.d.ts

@@ -0,0 +1,164 @@
+import type { ModuleManifest } from '@endora-commerce/contracts';
+import { type DeclaredContribution } from '../../kernel/contribution-sinks.js';
+/**
+ * The graph the **presence refusals** read — feature 073, FR-008, Amendment A1.
+ *
+ * It is deliberately not the graph the installer reads. `ModuleDepGraph`
+ * (`dep-graph.ts`) is built from `manifest.dependencies` alone because it has
+ * to be a DAG: it computes the topological install order and the reverse
+ * cascade order, and a cycle there fails the build. That constraint is what
+ * makes a handful of *real* runtime edges undeclarable — `addresses` must
+ * install after `organizations`, so `organizations` cannot declare `addresses`
+ * back, however certainly its customer routes call `addressService`.
+ *
+ * Withholding the declaration used to hide the edge from everything, including
+ * the flip-time refusals, which is how `catalog` came to resolve
+ * `pricingService` from a module an operator can switch off with nothing
+ * refusing the flip. The edges are now declared as
+ * `manifest.acknowledgedDependencies` and this graph is their reader:
+ *
+ * | Direction | Edges used | Why |
+ * | --- | --- | --- |
+ * | deactivating X — who still needs X? | `dependencies` ∪ `acknowledgedDependencies` | an acknowledged edge is a live resolution; the owner disappearing under it is exactly the failure this refuses |
+ * | activating X — what does X need? | `dependencies` only | the acknowledged edges are mutual **by construction**; requiring both ends present before either may be switched on is a deadlock, not a safeguard |
+ *
+ * That asymmetry is the same trade the install order makes, applied to the
+ * other axis, and it is why one union graph with two accessors beats two
+ * graphs.
+ *
+ * **`manifest.nonBindingDependencies` is the third array and this class reads
+ * none of it** (D-44). Those edges are real container resolutions whose
+ * declaring module has a defined behaviour when the owner is absent — a boot
+ * push into an ungated registry, or a read guarded by an
+ * `effectiveState.isPresent` probe — so there is nothing for a refusal to
+ * protect and refusing anyway would kill the owner's activation control for no
+ * gain. {@link nonBindingPortEdgesFrom} flattens them for
+ * `check-port-dependencies.ts`, which wants the ownership claim and not the
+ * lifecycle one; the omission from the constructor below is the decision, not
+ * an oversight, and `test/unit/_lifecycle/gating-graph.test.ts` pins it in both
+ * directions.
+ */
+/** One withheld edge, flattened from the declaring manifest. */
+export interface AcknowledgedPortEdge {
+    /** The module that resolves the port. */
+    readonly moduleId: string;
+    /** The module that owns it. */
+    readonly dependsOn: string;
+    /** The container registration name, e.g. `addressService`. */
+    readonly port: string;
+    readonly reason: string;
+}
+/**
+ * Every acknowledged edge in a manifest set, keyed the way
+ * `check-port-dependencies.ts` needs them: `<resolving module>:<port>`.
+ *
+ * The CI check and the runtime refusal read this one function over the one
+ * declaration set, so the two cannot disagree about which edges exist — they
+ * did, for as long as the list lived in the script as a constant.
+ */
+export declare function acknowledgedPortEdgesFrom(manifests: readonly ModuleManifest[]): AcknowledgedPortEdge[];
+/** One non-binding edge, flattened from the declaring manifest — D-44. */
+export interface NonBindingPortEdge {
+    /** The module that reads the name. */
+    readonly moduleId: string;
+    /** The module that owns it. */
+    readonly dependsOn: string;
+    /** The container registration name, e.g. `promptActionToolRegistry`. */
+    readonly name: string;
+    readonly kind: 'contributes-to' | 'degrades-without' | 'refuses-without';
+    /**
+     * What stops working — required for `degrades-without` and for
+     * `refuses-without`, `null` for a contribution.
+     */
+    readonly whenAbsent: string | null;
+    readonly reason: string;
+}
+/**
+ * Every non-binding edge in a manifest set, keyed the way
+ * `check-port-dependencies.ts` needs them: `<resolving module>:<name>`.
+ *
+ * It sits beside {@link acknowledgedPortEdgesFrom} rather than in the check,
+ * for the reason that function exists: one declaration set, read by the check
+ * and by the runtime, so the two cannot disagree about which edges exist. What
+ * differs is who else reads it — an acknowledged edge reaches the graph below,
+ * and a non-binding one reaches the graph not at all.
+ *
+ * It used to reach **nothing**, which was true of all three kinds until the
+ * owner ruling of 2026-09-12. The `contributes-to` subset now reaches the
+ * container resolution through {@link declaredContributionsFrom}, so that a
+ * push into a registry this composition does not hold is dropped rather than
+ * throwing; `degrades-without` and `refuses-without` still reach nothing.
+ */
+export declare function nonBindingPortEdgesFrom(manifests: readonly ModuleManifest[]): NonBindingPortEdge[];
+/** Is this module effectively present? Supplied by the caller so this file stays pure. */
+export type PresencePredicate = (moduleId: string) => boolean;
+export declare class ModuleGatingGraph {
+    /** moduleId → the modules it declares in `dependencies`. */
+    private readonly declared;
+    /** moduleId → the modules it acknowledges without declaring. */
+    private readonly acknowledged;
+    /** moduleId → everything that depends on it, by either kind of edge. */
+    private readonly dependents;
+    constructor(manifests?: readonly ModuleManifest[]);
+    /** `manifest.dependencies` — the install-ordering edges, and only those. */
+    declaredDependenciesOf(moduleId: string): string[];
+    /** The withheld edges this module declares as acknowledged. */
+    acknowledgedDependenciesOf(moduleId: string): string[];
+    /** Direct dependents over **both** kinds of edge — the refusal direction. */
+    dependentsOf(moduleId: string): string[];
+    /**
+     * Who would be left resolving a module that is no longer there.
+     *
+     * **Direct dependents only, and that is not an approximation.** A transitive
+     * dependent can only be reached through an intermediate one; if that
+     * intermediate is present it blocks here on its own account, and if it is
+     * absent then the transitive dependent is already stranded on the
+     * intermediate, which this flip neither causes nor repairs. So the refusal
+     * decision is identical either way, and the direct set is the one an operator
+     * can act on: these are the modules to switch off first.
+     *
+     * The same shape the CLI takes on the other axis — `orchestrator.disable`
+     * blocks on currently-installed *direct* dependents (`dependents-block`).
+     */
+    presentDependentsOf(moduleId: string, isPresent: PresencePredicate): string[];
+    /**
+     * What this module needs that is not there — `dependencies` only.
+     *
+     * Acknowledged edges are excluded because they are mutual by construction:
+     * `catalog` acknowledges `price_lists` while `price_lists` declares
+     * `catalog`, so requiring each to be present before the other may be switched
+     * on leaves a pair that can never be switched on again. The install order
+     * makes exactly this trade, and for exactly this reason (Amendment A1).
+     */
+    absentDependenciesOf(moduleId: string, isPresent: PresencePredicate): string[];
+}
+/**
+ * The fallback manifest set, from whoever owns the registry.
+ *
+ * Idempotent and last-writer-wins: it is a module-scope installation, not a
+ * per-request choice.
+ */
+export declare function provideDefaultGatingManifests(supplier: () => readonly ModuleManifest[]): void;
+export declare function gatingGraph(): ModuleGatingGraph;
+/** Install the deployment's manifest set. Idempotent; called from the presence load. */
+export declare function installGatingGraph(manifests: readonly ModuleManifest[]): void;
+/**
+ * The `contributes-to` edges, as the container resolution needs them (owner
+ * ruling, 2026-09-12; feature 117, A4).
+ *
+ * It is installed from **both** places this file establishes a manifest set —
+ * here and in {@link provideDefaultGatingManifests} — rather than from the
+ * presence load alone, because the question "did this module declare this
+ * contribution" has to be answerable in every process that composes modules,
+ * and those are the two points at which a process learns which manifests it
+ * has. Deriving it here rather than in the kernel is what keeps the kernel from
+ * importing a manifest: it receives a flattened pair list and knows nothing
+ * about `ModuleManifest`.
+ *
+ * The comment on {@link nonBindingPortEdgesFrom} above says a non-binding edge
+ * "reaches nothing". That was true of all three kinds until this ruling; the
+ * `contributes-to` subset now reaches the container resolution, and nothing
+ * else does.
+ */
+export declare function declaredContributionsFrom(manifests: readonly ModuleManifest[]): DeclaredContribution[];
+//# sourceMappingURL=gating-graph.d.ts.map

package/dist/lifecycle/services/gating-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gating-graph.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/services/gating-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,oCAAoC,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,gEAAgE;AAChE,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+BAA+B;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,SAAS,cAAc,EAAE,GACnC,oBAAoB,EAAE,CAaxB;AAED,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+BAA+B;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,GAAG,iBAAiB,CAAC;IACzE;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,cAAc,EAAE,GACnC,kBAAkB,EAAE,CAetB;AAED,0FAA0F;AAC1F,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAE9D,qBAAa,iBAAiB;IAC5B,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IACnE,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0C;IACvE,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;gBAEjD,SAAS,GAAE,SAAS,cAAc,EAAO;IAoBrD,4EAA4E;IAC5E,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAIlD,+DAA+D;IAC/D,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAItD,6EAA6E;IAC7E,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE;IAIxC;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,GAAG,MAAM,EAAE;IAI7E;;;;;;;;OAQG;IACH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,GAAG,MAAM,EAAE;CAK/E;AAyBD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,SAAS,cAAc,EAAE,GAAG,IAAI,CAQ7F;AAED,wBAAgB,WAAW,IAAI,iBAAiB,CAc/C;AAED,wFAAwF;AACxF,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAG7E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,SAAS,cAAc,EAAE,GACnC,oBAAoB,EAAE,CAIxB"}

package/dist/lifecycle/services/gating-graph.js

@@ -0,0 +1,203 @@
+import { provideDeclaredContributions, } from '../../kernel/contribution-sinks.js';
+/**
+ * Every acknowledged edge in a manifest set, keyed the way
+ * `check-port-dependencies.ts` needs them: `<resolving module>:<port>`.
+ *
+ * The CI check and the runtime refusal read this one function over the one
+ * declaration set, so the two cannot disagree about which edges exist — they
+ * did, for as long as the list lived in the script as a constant.
+ */
+export function acknowledgedPortEdgesFrom(manifests) {
+    const edges = [];
+    for (const manifest of manifests) {
+        for (const edge of manifest.acknowledgedDependencies ?? []) {
+            edges.push({
+                moduleId: manifest.id,
+                dependsOn: edge.moduleId,
+                port: edge.port,
+                reason: edge.reason,
+            });
+        }
+    }
+    return edges;
+}
+/**
+ * Every non-binding edge in a manifest set, keyed the way
+ * `check-port-dependencies.ts` needs them: `<resolving module>:<name>`.
+ *
+ * It sits beside {@link acknowledgedPortEdgesFrom} rather than in the check,
+ * for the reason that function exists: one declaration set, read by the check
+ * and by the runtime, so the two cannot disagree about which edges exist. What
+ * differs is who else reads it — an acknowledged edge reaches the graph below,
+ * and a non-binding one reaches the graph not at all.
+ *
+ * It used to reach **nothing**, which was true of all three kinds until the
+ * owner ruling of 2026-09-12. The `contributes-to` subset now reaches the
+ * container resolution through {@link declaredContributionsFrom}, so that a
+ * push into a registry this composition does not hold is dropped rather than
+ * throwing; `degrades-without` and `refuses-without` still reach nothing.
+ */
+export function nonBindingPortEdgesFrom(manifests) {
+    const edges = [];
+    for (const manifest of manifests) {
+        for (const edge of manifest.nonBindingDependencies ?? []) {
+            edges.push({
+                moduleId: manifest.id,
+                dependsOn: edge.moduleId,
+                name: edge.name,
+                kind: edge.kind,
+                whenAbsent: edge.whenAbsent ?? null,
+                reason: edge.reason,
+            });
+        }
+    }
+    return edges;
+}
+export class ModuleGatingGraph {
+    /** moduleId → the modules it declares in `dependencies`. */
+    declared = new Map();
+    /** moduleId → the modules it acknowledges without declaring. */
+    acknowledged = new Map();
+    /** moduleId → everything that depends on it, by either kind of edge. */
+    dependents = new Map();
+    constructor(manifests = []) {
+        const add = (owner, dependent) => {
+            let set = this.dependents.get(owner);
+            if (!set) {
+                set = new Set();
+                this.dependents.set(owner, set);
+            }
+            set.add(dependent);
+        };
+        for (const manifest of manifests) {
+            this.declared.set(manifest.id, new Set(manifest.dependencies));
+            for (const dep of manifest.dependencies)
+                add(dep, manifest.id);
+            const acknowledged = new Set((manifest.acknowledgedDependencies ?? []).map((edge) => edge.moduleId));
+            this.acknowledged.set(manifest.id, acknowledged);
+            for (const dep of acknowledged)
+                add(dep, manifest.id);
+        }
+    }
+    /** `manifest.dependencies` — the install-ordering edges, and only those. */
+    declaredDependenciesOf(moduleId) {
+        return [...(this.declared.get(moduleId) ?? [])].sort();
+    }
+    /** The withheld edges this module declares as acknowledged. */
+    acknowledgedDependenciesOf(moduleId) {
+        return [...(this.acknowledged.get(moduleId) ?? [])].sort();
+    }
+    /** Direct dependents over **both** kinds of edge — the refusal direction. */
+    dependentsOf(moduleId) {
+        return [...(this.dependents.get(moduleId) ?? [])].sort();
+    }
+    /**
+     * Who would be left resolving a module that is no longer there.
+     *
+     * **Direct dependents only, and that is not an approximation.** A transitive
+     * dependent can only be reached through an intermediate one; if that
+     * intermediate is present it blocks here on its own account, and if it is
+     * absent then the transitive dependent is already stranded on the
+     * intermediate, which this flip neither causes nor repairs. So the refusal
+     * decision is identical either way, and the direct set is the one an operator
+     * can act on: these are the modules to switch off first.
+     *
+     * The same shape the CLI takes on the other axis — `orchestrator.disable`
+     * blocks on currently-installed *direct* dependents (`dependents-block`).
+     */
+    presentDependentsOf(moduleId, isPresent) {
+        return this.dependentsOf(moduleId).filter((id) => id !== moduleId && isPresent(id));
+    }
+    /**
+     * What this module needs that is not there — `dependencies` only.
+     *
+     * Acknowledged edges are excluded because they are mutual by construction:
+     * `catalog` acknowledges `price_lists` while `price_lists` declares
+     * `catalog`, so requiring each to be present before the other may be switched
+     * on leaves a pair that can never be switched on again. The install order
+     * makes exactly this trade, and for exactly this reason (Amendment A1).
+     */
+    absentDependenciesOf(moduleId, isPresent) {
+        return this.declaredDependenciesOf(moduleId).filter((id) => id !== moduleId && !isPresent(id));
+    }
+}
+/**
+ * Process singleton, read by the activation refusals.
+ *
+ * It has **no empty default**, because an empty graph is a refusal that never
+ * fires — the silent fall-open this whole task exists to remove. There are two
+ * ways it gets a value, and they are different questions:
+ * {@link installGatingGraph} sets the deployment's real manifest set (core,
+ * overlay modules and installed packages) as part of the presence load, and
+ * {@link provideDefaultGatingManifests} says what to fall back to for a process
+ * that never runs one — which is most of the test harness.
+ *
+ * **The fallback is the host's to supply** (feature 080, D-160.11). This file
+ * read `REGISTERED_MANIFESTS` directly, which is the host application's
+ * registry: it derives from the generated manifest index and merges the
+ * deployment's overlay and the instance's installed packages, none of which the
+ * platform can see. `backend/src/lifecycle/registered-manifests.ts` installs it
+ * as it is loaded — that file is the manifest registry, so a process that can
+ * answer "which modules exist" has imported it, and one that cannot must not be
+ * given an empty answer instead.
+ */
+let graph = null;
+let defaultManifests = null;
+/**
+ * The fallback manifest set, from whoever owns the registry.
+ *
+ * Idempotent and last-writer-wins: it is a module-scope installation, not a
+ * per-request choice.
+ */
+export function provideDefaultGatingManifests(supplier) {
+    defaultManifests = supplier;
+    // The contribution declarations travel with the manifest set, in both of the
+    // places a process learns one — see `declaredContributionsFrom`. A process
+    // that has a manifest registry but never runs a presence load (a CLI, a
+    // fixture composition) still composes modules, and a contributor in it must
+    // get the same answer.
+    provideDeclaredContributions(() => declaredContributionsFrom(supplier()));
+}
+export function gatingGraph() {
+    if (graph)
+        return graph;
+    if (defaultManifests === null) {
+        throw new Error('[gating-graph] no gating graph and no default manifest set. The activation refusals ' +
+            'read this graph, so answering from an empty one would let every flip through — ' +
+            'exactly the silent fall-open feature 073 removed. A composed process gets its graph ' +
+            'from the presence load (installGatingGraph); anything else must call ' +
+            'provideDefaultGatingManifests first, which the host does as it loads its manifest ' +
+            'registry.');
+    }
+    graph = new ModuleGatingGraph(defaultManifests());
+    return graph;
+}
+/** Install the deployment's manifest set. Idempotent; called from the presence load. */
+export function installGatingGraph(manifests) {
+    graph = new ModuleGatingGraph(manifests);
+    provideDeclaredContributions(() => declaredContributionsFrom(manifests));
+}
+/**
+ * The `contributes-to` edges, as the container resolution needs them (owner
+ * ruling, 2026-09-12; feature 117, A4).
+ *
+ * It is installed from **both** places this file establishes a manifest set —
+ * here and in {@link provideDefaultGatingManifests} — rather than from the
+ * presence load alone, because the question "did this module declare this
+ * contribution" has to be answerable in every process that composes modules,
+ * and those are the two points at which a process learns which manifests it
+ * has. Deriving it here rather than in the kernel is what keeps the kernel from
+ * importing a manifest: it receives a flattened pair list and knows nothing
+ * about `ModuleManifest`.
+ *
+ * The comment on {@link nonBindingPortEdgesFrom} above says a non-binding edge
+ * "reaches nothing". That was true of all three kinds until this ruling; the
+ * `contributes-to` subset now reaches the container resolution, and nothing
+ * else does.
+ */
+export function declaredContributionsFrom(manifests) {
+    return nonBindingPortEdgesFrom(manifests)
+        .filter((edge) => edge.kind === 'contributes-to')
+        .map((edge) => ({ moduleId: edge.moduleId, name: edge.name }));
+}
+//# sourceMappingURL=gating-graph.js.map

package/dist/lifecycle/services/gating-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gating-graph.js","sourceRoot":"","sources":["../../../src/lifecycle/services/gating-graph.ts"],"names":[],"mappings":"AACA,OAAO,EACL,4BAA4B,GAE7B,MAAM,oCAAoC,CAAC;AAoD5C;;;;;;;GAOG;AACH,MAAM,UAAU,yBAAyB,CACvC,SAAoC;IAEpC,MAAM,KAAK,GAA2B,EAAE,CAAC;IACzC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,wBAAwB,IAAI,EAAE,EAAE,CAAC;YAC3D,KAAK,CAAC,IAAI,CAAC;gBACT,QAAQ,EAAE,QAAQ,CAAC,EAAE;gBACrB,SAAS,EAAE,IAAI,CAAC,QAAQ;gBACxB,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAmBD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,uBAAuB,CACrC,SAAoC;IAEpC,MAAM,KAAK,GAAyB,EAAE,CAAC;IACvC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,sBAAsB,IAAI,EAAE,EAAE,CAAC;YACzD,KAAK,CAAC,IAAI,CAAC;gBACT,QAAQ,EAAE,QAAQ,CAAC,EAAE;gBACrB,SAAS,EAAE,IAAI,CAAC,QAAQ;gBACxB,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,IAAI;gBACnC,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAKD,MAAM,OAAO,iBAAiB;IAC5B,4DAA4D;IAC3C,QAAQ,GAAG,IAAI,GAAG,EAA+B,CAAC;IACnE,gEAAgE;IAC/C,YAAY,GAAG,IAAI,GAAG,EAA+B,CAAC;IACvE,wEAAwE;IACvD,UAAU,GAAG,IAAI,GAAG,EAAuB,CAAC;IAE7D,YAAY,YAAuC,EAAE;QACnD,MAAM,GAAG,GAAG,CAAC,KAAa,EAAE,SAAiB,EAAQ,EAAE;YACrD,IAAI,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACrC,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,GAAG,GAAG,IAAI,GAAG,EAAE,CAAC;gBAChB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAClC,CAAC;YACD,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACrB,CAAC,CAAC;QACF,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;YAC/D,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,YAAY;gBAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;YAC/D,MAAM,YAAY,GAAG,IAAI,GAAG,CAC1B,CAAC,QAAQ,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CACvE,CAAC;YACF,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;YACjD,KAAK,MAAM,GAAG,IAAI,YAAY;gBAAE,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,4EAA4E;IAC5E,sBAAsB,CAAC,QAAgB;QACrC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACzD,CAAC;IAED,+DAA+D;IAC/D,0BAA0B,CAAC,QAAgB;QACzC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC7D,CAAC;IAED,6EAA6E;IAC7E,YAAY,CAAC,QAAgB;QAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3D,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,QAAgB,EAAE,SAA4B;QAChE,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,QAAQ,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;IACtF,CAAC;IAED;;;;;;;;OAQG;IACH,oBAAoB,CAAC,QAAgB,EAAE,SAA4B;QACjE,OAAO,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,MAAM,CACjD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,QAAQ,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAC1C,CAAC;IACJ,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,IAAI,KAAK,GAA6B,IAAI,CAAC;AAC3C,IAAI,gBAAgB,GAA6C,IAAI,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,QAAyC;IACrF,gBAAgB,GAAG,QAAQ,CAAC;IAC5B,6EAA6E;IAC7E,2EAA2E;IAC3E,wEAAwE;IACxE,4EAA4E;IAC5E,uBAAuB;IACvB,4BAA4B,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,WAAW;IACzB,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,IAAI,gBAAgB,KAAK,IAAI,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,sFAAsF;YACpF,iFAAiF;YACjF,sFAAsF;YACtF,uEAAuE;YACvE,oFAAoF;YACpF,WAAW,CACd,CAAC;IACJ,CAAC;IACD,KAAK,GAAG,IAAI,iBAAiB,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAClD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,kBAAkB,CAAC,SAAoC;IACrE,KAAK,GAAG,IAAI,iBAAiB,CAAC,SAAS,CAAC,CAAC;IACzC,4BAA4B,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC,SAAS,CAAC,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,yBAAyB,CACvC,SAAoC;IAEpC,OAAO,uBAAuB,CAAC,SAAS,CAAC;SACtC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,gBAAgB,CAAC;SAChD,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AACnE,CAAC"}

package/dist/lifecycle/services/lock.d.ts

@@ -0,0 +1,27 @@
+import type { Redis } from 'ioredis';
+export declare const LOCK_KEY = "b2b:module:lifecycle:lock";
+export declare const LOCK_TTL_SECONDS = 300;
+export declare const LOCK_REFRESH_INTERVAL_MS = 60000;
+export declare class LifecycleLockError extends Error {
+    readonly heldBy: string | null;
+    constructor(heldBy: string | null);
+}
+export interface LifecycleLeaseHandle {
+    /** UUID identifying this acquisition. */
+    readonly leaseId: string;
+    /** Stops the auto-refresh timer and releases the lock if still held. */
+    release(): Promise<void>;
+}
+/**
+ * Acquire the global lifecycle lock. Returns a handle that auto-extends
+ * the lease every 60 s and exposes `release()` for the caller's `finally`.
+ *
+ * Throws `LifecycleLockError` if the lock is currently held by someone
+ * else (single attempt — the lifecycle commands surface this as exit 75
+ * rather than block).
+ */
+export declare function acquireLifecycleLock(redis: Redis, options?: {
+    ttlSeconds?: number;
+    refreshIntervalMs?: number;
+}): Promise<LifecycleLeaseHandle>;
+//# sourceMappingURL=lock.d.ts.map

package/dist/lifecycle/services/lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/services/lock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,eAAO,MAAM,QAAQ,8BAA8B,CAAC;AACpD,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,wBAAwB,QAAS,CAAC;AA2B/C,qBAAa,kBAAmB,SAAQ,KAAK;aACf,MAAM,EAAE,MAAM,GAAG,IAAI;gBAArB,MAAM,EAAE,MAAM,GAAG,IAAI;CAQlD;AAED,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAO,GAChE,OAAO,CAAC,oBAAoB,CAAC,CAoC/B"}

package/dist/lifecycle/services/lock.js

@@ -0,0 +1,82 @@
+import { randomUUID } from 'node:crypto';
+export const LOCK_KEY = 'b2b:module:lifecycle:lock';
+export const LOCK_TTL_SECONDS = 300; // 5 minutes
+export const LOCK_REFRESH_INTERVAL_MS = 60_000; // 1 minute
+/**
+ * Compare-and-delete release script. Prevents the case where a stale
+ * lease's TTL elapsed, the lock was acquired by someone else, and our
+ * own `finally` block then deletes their key.
+ */
+const RELEASE_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("del", KEYS[1])
+else
+  return 0
+end
+`;
+/**
+ * Compare-and-extend script. Refreshes the lease only when we still
+ * own it; otherwise reports zero so the caller can stop refreshing.
+ */
+const EXTEND_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("expire", KEYS[1], ARGV[2])
+else
+  return 0
+end
+`;
+export class LifecycleLockError extends Error {
+    heldBy;
+    constructor(heldBy) {
+        super(heldBy
+            ? `lifecycle lock is held by another process (lease ${heldBy})`
+            : 'lifecycle lock is currently held');
+        this.heldBy = heldBy;
+        this.name = 'LifecycleLockError';
+    }
+}
+/**
+ * Acquire the global lifecycle lock. Returns a handle that auto-extends
+ * the lease every 60 s and exposes `release()` for the caller's `finally`.
+ *
+ * Throws `LifecycleLockError` if the lock is currently held by someone
+ * else (single attempt — the lifecycle commands surface this as exit 75
+ * rather than block).
+ */
+export async function acquireLifecycleLock(redis, options = {}) {
+    const ttl = options.ttlSeconds ?? LOCK_TTL_SECONDS;
+    const refreshIntervalMs = options.refreshIntervalMs ?? LOCK_REFRESH_INTERVAL_MS;
+    const leaseId = randomUUID();
+    const result = await redis.set(LOCK_KEY, leaseId, 'EX', ttl, 'NX');
+    if (result !== 'OK') {
+        const heldBy = await redis.get(LOCK_KEY);
+        throw new LifecycleLockError(heldBy);
+    }
+    let released = false;
+    const refresh = setInterval(() => {
+        if (released)
+            return;
+        void redis
+            .eval(EXTEND_SCRIPT, 1, LOCK_KEY, leaseId, String(ttl))
+            .catch(() => {
+            /* refresh failure is silent — release() will still run */
+        });
+    }, refreshIntervalMs);
+    // Don't keep the event loop alive on the refresh interval.
+    refresh.unref?.();
+    return {
+        leaseId,
+        async release() {
+            if (released)
+                return;
+            released = true;
+            clearInterval(refresh);
+            await redis
+                .eval(RELEASE_SCRIPT, 1, LOCK_KEY, leaseId)
+                .catch(() => {
+                /* swallow — the lock will expire on its TTL anyway */
+            });
+        },
+    };
+}
+//# sourceMappingURL=lock.js.map

package/dist/lifecycle/services/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../../src/lifecycle/services/lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,CAAC,MAAM,QAAQ,GAAG,2BAA2B,CAAC;AACpD,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC,CAAC,YAAY;AACjD,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC,CAAC,WAAW;AAE3D;;;;GAIG;AACH,MAAM,cAAc,GAAG;;;;;;CAMtB,CAAC;AAEF;;;GAGG;AACH,MAAM,aAAa,GAAG;;;;;;CAMrB,CAAC;AAEF,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IACf;IAA5B,YAA4B,MAAqB;QAC/C,KAAK,CACH,MAAM;YACJ,CAAC,CAAC,oDAAoD,MAAM,GAAG;YAC/D,CAAC,CAAC,kCAAkC,CACvC,CAAC;QALwB,WAAM,GAAN,MAAM,CAAe;QAM/C,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AASD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAAY,EACZ,UAA+D,EAAE;IAEjE,MAAM,GAAG,GAAG,OAAO,CAAC,UAAU,IAAI,gBAAgB,CAAC;IACnD,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,wBAAwB,CAAC;IAChF,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAE7B,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IACnE,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzC,MAAM,IAAI,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE;QAC/B,IAAI,QAAQ;YAAE,OAAO;QACrB,KAAK,KAAK;aACP,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;aACtD,KAAK,CAAC,GAAG,EAAE;YACV,0DAA0D;QAC5D,CAAC,CAAC,CAAC;IACP,CAAC,EAAE,iBAAiB,CAAC,CAAC;IACtB,2DAA2D;IAC3D,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;IAElB,OAAO;QACL,OAAO;QACP,KAAK,CAAC,OAAO;YACX,IAAI,QAAQ;gBAAE,OAAO;YACrB,QAAQ,GAAG,IAAI,CAAC;YAChB,aAAa,CAAC,OAAO,CAAC,CAAC;YACvB,MAAM,KAAK;iBACR,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC;iBAC1C,KAAK,CAAC,GAAG,EAAE;gBACV,sDAAsD;YACxD,CAAC,CAAC,CAAC;QACP,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/lifecycle/services/manifest-loader.d.ts

@@ -0,0 +1,125 @@
+import { type ModuleManifest, type ModuleInstallHook, type ModuleLifecycleParticipant, type ModuleUninstallHook, type ModuleRecentActivity } from '@endora-commerce/contracts';
+import { ModuleDepGraph } from './dep-graph.js';
+export interface LoadedModuleEntry<EM = unknown, R = unknown> {
+    manifest: ModuleManifest;
+    /** Absolute path to the manifest.ts file on disk. */
+    filePath: string;
+    installHook?: ModuleInstallHook<EM, R>;
+    uninstallHook?: ModuleUninstallHook<EM, R>;
+    /**
+     * This module's interest in *every other* module's install and hard
+     * uninstall — feature 080, T036a / D-159. Declared as an export of the
+     * module's `manifest.ts`, exactly as the two hooks above are.
+     */
+    lifecycleParticipant?: ModuleLifecycleParticipant<EM>;
+    /**
+     * The module's recent-activity eligibility — feature 080, T042j / D-163.1.
+     * The orchestrator reads it to reconcile the visibility Setting the
+     * declaration implies, which for a package is the only author it has.
+     */
+    recentActivity?: ModuleRecentActivity;
+}
+/** A participant, with the module that declared it — named in a failure. */
+export interface LoadedLifecycleParticipant<EM = unknown> {
+    moduleId: string;
+    participant: ModuleLifecycleParticipant<EM>;
+}
+export interface LoadedManifestRegistry<EM = unknown, R = unknown> {
+    modules: Map<string, LoadedModuleEntry<EM, R>>;
+    graph: ModuleDepGraph;
+    /**
+     * Every lifecycle participant the modules in this registry declare — or
+     * `null` when whoever built this registry is in no position to say.
+     *
+     * The two answers are different facts and the field exists to keep them
+     * apart. `[]` means *"I enumerated the modules and none declares one"*, and
+     * the orchestrator proceeds. `null` means *"I cannot enumerate them"*, and
+     * the orchestrator **refuses** the operation rather than performing an
+     * install that silently reconciles nothing. Collapsing the two is the
+     * fail-open this field was added to close: the reconcilers used to be
+     * optional injected values, so a caller that passed neither got an install
+     * indistinguishable from one where there was nothing to reconcile. The idiom
+     * is `MigrationOwnership.migrationNamesFor`'s, eleven lines from where the
+     * orchestrator reads it (`src/db/configured-migrations.ts`).
+     *
+     * It is **required**, so a builder cannot omit the answer: `[]` for a fixture
+     * registry that carries no participants is a declaration a reader can see.
+     */
+    participants: readonly LoadedLifecycleParticipant<EM>[] | null;
+}
+/**
+ * Collect the participants declared by a set of loaded entries.
+ *
+ * Sorted by module id so the order a projection is written in is a property of
+ * the platform rather than of whichever walk produced the map.
+ */
+export declare function collectLifecycleParticipants<EM = unknown, R = unknown>(entries: Iterable<LoadedModuleEntry<EM, R>>): LoadedLifecycleParticipant<EM>[];
+export declare class ManifestLoadError extends Error {
+    readonly kind: 'duplicate-id' | 'cycle' | 'self-dep' | 'orphan-dep' | 'folder-id-mismatch' | 'package-root' | 'parse-failed';
+    constructor(kind: 'duplicate-id' | 'cycle' | 'self-dep' | 'orphan-dep' | 'folder-id-mismatch' | 'package-root' | 'parse-failed', message: string);
+}
+export interface DiscoverOptions {
+    /** Root directory to scan (e.g. `backend/src/modules`). */
+    modulesRoot: string;
+    /**
+     * Subdirectories under `modulesRoot` that the loader should INCLUDE.
+     * Defaults to "every direct subdirectory". Used by tests to scope
+     * discovery to a single fixture tree.
+     */
+    include?: readonly string[];
+    /**
+     * Names of subdirectories under `modulesRoot` to ignore (e.g.
+     * `__pycache__`-like or test fixtures). Defaults to none.
+     */
+    exclude?: readonly string[];
+}
+/**
+ * Discover every `manifest.ts` under `modulesRoot/<id>/manifest.ts` and
+ * dynamically import each module. Returns the validated registry plus
+ * the dep graph derived from declarations.
+ *
+ * Production builds may swap this loader for a generated
+ * `manifest-index.ts` that imports the same modules eagerly — this
+ * runtime path is for dev/test where the file system is the source of
+ * truth.
+ *
+ * **Identity here is the directory name, and that scopes this loader** (feature
+ * 080, T032). It walks a tree this repository lays out, where Principle VI says
+ * `<id>/manifest.ts` — so the folder name is a claim about the id and a
+ * disagreement is a defect. An **installed package** has neither property: its
+ * directory is its npm name (`@endora-commerce/mod-blog`), and its identity is
+ * the `endora.id` field of its `package.json` (D-142), checked against its
+ * manifest by `src/packages/package-runtime.ts`. Pointing this loader at a
+ * `node_modules` is therefore refused outright rather than walked — see
+ * {@link ManifestLoadError} kind `package-root`. Without that refusal the walk
+ * happens to work and then reports `folder-id-mismatch`, which blames a vendor
+ * for naming their package correctly and sends the reader to fix the one thing
+ * that is right.
+ */
+export declare function discoverManifests<EM = unknown, R = unknown>(opts: DiscoverOptions): Promise<LoadedManifestRegistry<EM, R>>;
+/**
+ * Convenience for tests: resolve `modulesRoot` relative to a test file.
+ * Avoids hard-coding paths that break under different working dirs.
+ */
+export declare function resolveFromFile(metaUrl: string, relative: string): string;
+/** Test helper — assert that a value is one of the known load-error kinds. */
+export declare function isLoadError(err: unknown): err is ManifestLoadError;
+/**
+ * Production loader entry point: scans the project's
+ * `backend/src/modules` for every `manifest.ts`. Skips the fixtures
+ * trees under `test/`. Used by `composition.ts` at boot.
+ */
+export declare function loadProjectManifests<EM = unknown, R = unknown>(modulesRoot: string): Promise<LoadedManifestRegistry<EM, R>>;
+/**
+ * The folder name a **directory-named** module's id comes from.
+ *
+ * It answers for the anchor {@link discoverManifests} produces — a
+ * `manifest.ts` under `<modules root>/<id>/`. It refuses a `package.json`
+ * anchor, which is what a resolved package entry's `filePath` is (feature 080,
+ * T032): `basename(dirname(...))` would answer `mod-blog`, the tail of an npm
+ * name, which is neither the module id nor even unique without the `@scope`
+ * this drops. A confident wrong answer is worse than a refusal — a package's id
+ * is its `endora.id`, and `resolvedManifestEntries()` already carries it.
+ */
+export declare function folderNameFromPath(filePath: string): string;
+//# sourceMappingURL=manifest-loader.d.ts.map

package/dist/lifecycle/services/manifest-loader.d.ts.map

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