@endora-commerce/platform 0.100.0

package/dist/lifecycle/services/presence-load.js

@@ -0,0 +1,437 @@
+import { ModuleRegistration } from '../../kernel/lifecycle/module-registration.entity.js';
+import { platformLogger } from '../../kernel/logging.js';
+import { activationDeclarationsFrom } from '../../kernel/lifecycle/activation-resolver.js';
+import { capabilityRegistryFrom } from '../../kernel/lifecycle/capability-registry.js';
+import { installGatingGraph } from './gating-graph.js';
+import { registryCache } from '../../kernel/lifecycle/registry-cache.js';
+import { deploymentShippedEntries, } from './module-origin.js';
+/**
+ * The boot refuses: this deployment composes modules that need modules it does
+ * not have, and has not said so (D-101).
+ *
+ * A distinct type from every deactivation refusal on purpose. `assertDeactivatable`
+ * refuses a **transition** an operator asked for and answers them with an HTTP
+ * envelope; this refuses an **initial state** nobody asked about, and answers the
+ * person who composed the deployment, at their terminal, before anything serves.
+ * Merging the two would re-make exactly the conflation D-100 exists to stop.
+ *
+ * It keeps its name after D-205 renamed the file it points at. The declaration
+ * is `divergence.ts` because it grew past omissions; this refusal did not — all
+ * three of its findings are about a module set that is *reduced*, which is what
+ * `omittedModules` still declares.
+ */
+export class ReducedDeploymentError extends Error {
+    findings;
+    constructor(findings) {
+        super(refusalMessage(findings));
+        this.name = 'ReducedDeploymentError';
+        this.findings = findings;
+    }
+}
+const LEDGER_PATH = 'backend/src/apps/<deployment>/divergence.ts';
+function refusalMessage(findings) {
+    const lines = [
+        'This deployment will not boot: it composes modules whose declarations it does not satisfy.',
+        '',
+    ];
+    for (const finding of findings) {
+        if (finding.kind === 'not-shipped') {
+            lines.push(`  ${finding.moduleId} — not shipped by this deployment, and it is needed:`);
+            for (const needer of finding.neededBy) {
+                lines.push(`      ${needer.moduleId} — ${needer.via}` +
+                    (needer.port === null ? '' : `, port \`${needer.port}\``));
+            }
+        }
+        else if (finding.kind === 'not-installed') {
+            lines.push(`  ${finding.moduleId} — shipped, but \`module_registrations\` says \`${finding.state}\`,`, `      and the platform cannot run without it: ${finding.reason}`, `      remedy: pnpm --filter backend run module:enable ${finding.moduleId}`);
+        }
+        else {
+            lines.push(`  ${finding.moduleId} — declared as omitted, but this deployment ships it and its row is fine.`, `      Remove the entry from the \`omittedModules\` of ${LEDGER_PATH}; a declaration`, '      nothing omits is how a deployment silently reacquires the hazard it once declared.');
+        }
+        lines.push('');
+    }
+    lines.push('Ship the modules, or — if the omission is deliberate — declare each one, with a reason,', `in the \`omittedModules\` of ${LEDGER_PATH}. The declaration is reviewed in the merge`, 'request that assembles the deployment, which a flag set at 2 a.m. is not (D-69, D-101).');
+    return lines.join('\n');
+}
+/**
+ * Refuse a composition that never shipped what it composes against — D-101,
+ * the owner's E1 ruling: *"the failure belongs to whoever composes the
+ * deployment, loudly and immediately — not to a user who meets it as a 503 at
+ * login."*
+ *
+ * **Pure, and that is load-bearing rather than stylistic.** The harness never
+ * calls {@link loadModulePresence} — it seeds the registry cache directly — so a
+ * refusal that only existed inside the boot step would have no proof that runs.
+ * Its whole input is the three things a composition has: what it ships, what the
+ * registry says, and what it declared.
+ *
+ * `rows === null` means *the registry has not been read yet*. The shipping
+ * question is answerable without it, so it is asked first, before
+ * `reconcileExistingModules` touches the database.
+ *
+ * **What it does not read: the absent module's manifest.** The decision is
+ * framed around `activation.nonDeactivatable`, and for the "shipped but not
+ * installed" trigger that is exactly what it asks. For the *not shipped* trigger
+ * it cannot: a packaging split that drops `admin_users` drops its manifest with
+ * it, so "was it locked?" has no answer at the seam that has to refuse. What
+ * survives the split is the **declaration in the module that stays** —
+ * `admin_roles`' `acknowledgedDependencies` entry — and that is what this rests
+ * on. It is deliberately wider than "locked modules only", and D-100 points the
+ * same way: an argument from a lock nothing here can re-derive is the shape that
+ * goes stale. `nonBindingDependencies` is left out, because that array is the
+ * declaration that the owner's absence is expected and handled (D-44).
+ */
+export function assertLockedModulesPresent(manifests, rows, declared) {
+    const shipped = new Set(manifests.map((manifest) => manifest.id));
+    const findings = [];
+    // 1 — not shipped. Both ends of every missing edge, because a message naming
+    // only the absentee sends the reader hunting across three arrays in 65
+    // manifests.
+    const neededBy = new Map();
+    const need = (moduleId, entry) => {
+        if (shipped.has(moduleId) || declared.has(moduleId))
+            return;
+        const list = neededBy.get(moduleId) ?? [];
+        list.push(entry);
+        neededBy.set(moduleId, list);
+    };
+    for (const manifest of manifests) {
+        for (const dependency of manifest.dependencies ?? []) {
+            need(dependency, { moduleId: manifest.id, via: 'dependencies', port: null });
+        }
+        for (const edge of manifest.acknowledgedDependencies ?? []) {
+            need(edge.moduleId, {
+                moduleId: manifest.id,
+                via: 'acknowledgedDependencies',
+                port: edge.port,
+            });
+        }
+    }
+    for (const [moduleId, needers] of [...neededBy.entries()].sort()) {
+        findings.push({ kind: 'not-shipped', moduleId, neededBy: needers });
+    }
+    if (rows !== null) {
+        // 2 — shipped, but carrying a row the boot reconciler will not repair. By
+        // construction this is not an operator's choice: since D-69 the orchestrator
+        // refuses to disable or uninstall a `nonDeactivatable` module, with no
+        // `--force`, so the only way to hold one is to have written it before that
+        // refusal landed. The reconciler must not repair it — it inserts only, and
+        // deciding a state rather than converging to one is the orchestrator's job —
+        // so the refusal names the remedy instead.
+        for (const manifest of manifests) {
+            const activation = manifest.activation;
+            if (activation === undefined || !('nonDeactivatable' in activation))
+                continue;
+            if (declared.has(manifest.id))
+                continue;
+            const state = rows.get(manifest.id);
+            if (state === undefined || state === 'installed')
+                continue;
+            findings.push({
+                kind: 'not-installed',
+                moduleId: manifest.id,
+                state,
+                reason: activation.reason,
+            });
+        }
+        // 3 — the declaration is two-way. An entry for a module this deployment
+        // ships, in the state it should be in, describes a deployment that no longer
+        // exists. Asked only once the registry has been read: a shipped module with a
+        // legacy row is a live declaration, not a stale one.
+        for (const moduleId of [...declared].sort()) {
+            if (!shipped.has(moduleId))
+                continue;
+            const state = rows.get(moduleId);
+            if (state !== undefined && state !== 'installed')
+                continue;
+            findings.push({ kind: 'stale-declaration', moduleId });
+        }
+    }
+    if (findings.length > 0)
+        throw new ReducedDeploymentError(findings);
+}
+/**
+ * The composition step that gives module presence an answer (feature 072,
+ * D-38).
+ *
+ * It used to live in `_lifecycle`'s Fastify plugin body, which runs inside
+ * `buildServer` — after `composeApp()` has registered every module and run every
+ * boot hook. Eleven boot hooks resolve a gated port, so they all asked a cache
+ * nothing had loaded, all got "not installed", and the first one reached threw
+ * `ModuleCompositionError` before the process could listen. The ordering was the
+ * bug; the cache, the gate and the composer were each doing exactly their job.
+ *
+ * So this is called from the composition root **before the first module
+ * registers**, and it is awaited and fatal: its two inputs are the EntityManager
+ * factory and the manifest list, and a root has both before it composes
+ * anything. Redis is not involved — arming the notification channel is
+ * `registryCache.watch()`, which happens after composition and cannot fail a
+ * boot.
+ *
+ * It lives under `lifecycle/` rather than in `kernel/` even though D-37 A1 moved
+ * the cache, the resolver and the gating wrappers into the kernel. The reason is
+ * `installGatingGraph` below: the graph's *fallback* is the host's manifest
+ * registry, which the harness relies on without ever calling this function, so
+ * the two belong to the same subsystem. D-37 §2.3 records the call as deliberate
+ * and arguable; the call site is already where it needs to be either way.
+ */
+export async function loadModulePresence(opts) {
+    const manifests = opts.entries.map((entry) => entry.manifest);
+    // D-101 — two refusals, in the order the two questions can be answered.
+    //
+    // The **shipping** question needs no database, so it is asked first: a
+    // deployment that never shipped what it composes fails before a connection is
+    // used, and the person who assembled it reads the failure instead of a user
+    // meeting it as a 503 at login. The **registry** question needs the rows, and
+    // is asked once they are read.
+    //
+    // Both are one line here because the analysis is a pure function beside this
+    // one: the harness never calls `loadModulePresence`, so a refusal written into
+    // this body would have no proof that runs.
+    const declared = new Set(opts.declaredOmissions ?? []);
+    assertLockedModulesPresent(manifests, null, declared);
+    // D-157.6(b) — and this is the one place the resolved set is narrowed. The
+    // insert converges the registry to what this **build** ships; a package is
+    // converged by `module:install`, which is also what runs its migrations.
+    const rows = await reconcileExistingModules(opts.em, firstBootInsertPopulation(opts.entries));
+    // …and it stops being silent about the one thing convergence cannot do. A
+    // **warning, not a refusal**: this must not break a first boot, and the
+    // remedy is a command the operator can run afterwards. One line here for the
+    // reason the two refusals are one line each — the analysis is a pure function
+    // beside this one, because the harness never calls `loadModulePresence`.
+    for (const warning of bootConvergenceWarnings(opts.entries, new Set(rows.keys()))) {
+        (opts.log ?? platformLogger()).warn({ moduleId: warning.moduleId }, warning.message);
+    }
+    assertLockedModulesPresent(manifests, rows, declared);
+    // Feature 073 (T045/T046) — the graph the flip-time refusals read. Installed
+    // from the same manifest list as the activation declarations, so an overlay
+    // module's edges count for a refusal exactly as a core module's do (FR-027).
+    installGatingGraph(manifests);
+    await registryCache.load({
+        em: opts.em,
+        // Feature 073 — the operator-activation axis. Declarations come from the
+        // shipped manifests, so there is no hand-maintained list: a module that
+        // declares no control is governed by the platform axis alone.
+        activationDeclarations: activationDeclarationsFrom(manifests),
+        // Feature 132 — the capability families, from the **same** manifest list and
+        // in the **same** call, which is the Redis cache-invalidation design rather
+        // than a convenience (`data-model.md` §2.2). A family owner's exclusion reads
+        // membership and activation together on every refusal, and this cache is
+        // refreshed by the `b2b:module:state-changed` channel; installed here, the
+        // two are refreshed by one event and cannot disagree. Cached anywhere else,
+        // the family would need a second invalidation path and would be stale for
+        // exactly the window in which an operator is flipping a connector.
+        //
+        // Same list, so the same three populations declare on identical terms (R2.1):
+        // a core module, this deployment's overlay modules and every installed Endora
+        // module package. That is the property the three arrays this replaces could
+        // not have — an overlay module had to be written into a core contracts file
+        // to join its family, which is Principle XV failing quietly.
+        capabilityRegistry: capabilityRegistryFrom(manifests),
+    });
+}
+/**
+ * The first-boot reconciler's insert population: **core plus this deployment's
+ * overlay**, never the instance-resolved set (D-157.6(b)).
+ *
+ * T031 made `composeApp` hand the resolved set — which since then includes every
+ * installed Endora module package — to {@link loadModulePresence}, and the
+ * reconciler inserts `state='installed'` for every manifest with no row. So the
+ * next boot after `pnpm add @vendor/some-module` converged that package before
+ * one migration of its had run, `module:install` answered `already-installed`
+ * and returned 0, and the operator was left with a module whose tables do not
+ * exist. A package is installed by `install` — the mechanism that applies its
+ * migrations, reconciles its settings and runs its install hook — and
+ * converging it silently is the one thing that mechanism cannot survive.
+ *
+ * **Only the insert is narrowed.** The presence *cache* still loads over the
+ * full resolved set, so a package that **has** been installed is present, gated
+ * and deactivatable exactly like a core module. Narrowing the cache too would
+ * trade a silent install for a silent absence.
+ *
+ * Pure, and separate from the boot step for the same reason
+ * {@link assertLockedModulesPresent} is: the harness never calls
+ * {@link loadModulePresence}, so a rule written into that body would be proved
+ * by nothing that runs.
+ *
+ * The origin split itself is `deploymentShippedEntries` and is deliberately not
+ * spelled here (feature 080, T046): the boot settings reconcile has to stop at
+ * the same line, for reasons of its own, and a second copy of an origin test is
+ * two answers waiting to disagree (D-100).
+ *
+ * **It answers with entries and not with manifests**, which it used to. Two
+ * readers now need the population and one of them —
+ * {@link bootConvergenceWarnings} — asks about `installHook`, which lives on the
+ * entry. Returning manifests would have made that reader re-derive the origin
+ * split for itself, which is the D-100 shape this function exists to prevent.
+ */
+export function firstBootInsertPopulation(entries) {
+    return deploymentShippedEntries(entries);
+}
+/**
+ * The convergence stops being silent: one warning per manifest this boot is
+ * about to converge that declares an `installHook`.
+ *
+ * ## What it is about
+ *
+ * {@link reconcileExistingModules} writes `state='installed'` for a shipped
+ * manifest with no row and runs no hook. Before the `bootConvergedAt` marker,
+ * `install` could not tell that row from one it had written itself, so it
+ * answered `already-installed` and the hook never ran and never would. The
+ * marker makes the repair possible; this makes it **findable**, which is the
+ * half a marker cannot do on its own: nobody runs a command they have not been
+ * told to run.
+ *
+ * ## A warning and not a refusal
+ *
+ * Deliberate, and the direction matters. A refusal here would break a first
+ * boot, which is the one boot a fresh deployment cannot route around, and it
+ * would make **presence a function of hook declaration** — presence being
+ * Constitution XVII's platform-availability axis. The codebase has refused that
+ * trade twice in writing: `firstBootInsertPopulation` above (*"would trade a
+ * silent install for a silent absence"*) and
+ * `backend/test/unit/_lifecycle/first-boot-package-reconcile.test.ts` (*"the same
+ * defect wearing the other sign"*). Whether a boot-first database should instead
+ * be **refused** is an open owner question; `ModuleRegistration.bootConvergedAt`
+ * is the datum such a refusal would read, so that ruling costs a branch rather
+ * than a redesign.
+ *
+ * ## And not "run the hook here"
+ *
+ * Three reasons that each resolve in this tree. `loadModulePresence` runs
+ * **before** `DefaultChannelReconciler` in `compose-app.ts`, so a hook here has
+ * strictly *less* context than at install. `install` takes `acquireLock()` and
+ * this takes nothing, while an instance runs `start` and `worker` as two
+ * processes that both compose — two racing the same seed writes. And `install`
+ * turns a hook failure into `install-failed` with that run's migrations reverted
+ * and the error persisted, where at boot a seeding problem becomes a platform
+ * that will not start; `backend/src/lifecycle/scripts/install.ts` already names
+ * the neighbouring hazard in its D-157.2 comment.
+ *
+ * ## Pure, for the reason its two neighbours are
+ *
+ * The harness never calls {@link loadModulePresence} — it seeds the registry
+ * cache directly — so a rule written into that body would be proved by nothing
+ * that runs. It reads the population by **calling**
+ * {@link firstBootInsertPopulation} rather than restating the origin test, so
+ * the warning and the insert cannot disagree about who is converged.
+ *
+ * @param entries the instance-resolved set, exactly as the boot step has it
+ * @param existingModuleIds the ids that **already** had a row — so a converged
+ *   database, which is the steady state and boots many times a day, says nothing
+ */
+export function bootConvergenceWarnings(entries, existingModuleIds) {
+    const warnings = [];
+    for (const entry of firstBootInsertPopulation(entries)) {
+        if (entry.installHook === undefined)
+            continue;
+        if (existingModuleIds.has(entry.manifest.id))
+            continue;
+        const id = entry.manifest.id;
+        warnings.push({
+            moduleId: id,
+            message: `module "${id}" was marked installed by boot convergence, which cannot run its ` +
+                'install hook — so the rows that hook seeds are absent. Run ' +
+                `\`module:install ${id}\` (or \`module:install --all\`) to complete it; both are ` +
+                'idempotent, and the platform serves normally in the meantime.',
+        });
+    }
+    return warnings;
+}
+/**
+ * First-boot reconciler — idempotent.
+ *
+ * For every shipped manifest with NO row in `module_registrations`, inserts one
+ * with `state='installed'`. This lets feature 018 land on a running platform
+ * without breaking the gating wrappers (`defineModuleRoutes`,
+ * `defineModuleWorker`, `subscribeForModule`) — pre-existing modules continue
+ * serving traffic because their auto-created row marks them
+ * installed-and-enabled.
+ *
+ * Modules added AFTER feature 018 ships go through the explicit
+ * `module:install <id>` flow.
+ *
+ * command-coverage-ignore: boot convergence of the registry to the shipped
+ * manifest list — a system-invariant repair with no operator behind it. Spelled
+ * out, because "a reconcile is not a write" is exactly the argument that lets a
+ * real unaudited write through next time:
+ *
+ * **Why the hatch appears only now.** The write is feature 018's, unchanged
+ * since 2026-05-06. It lived in `_lifecycle/plugin.ts`, which
+ * `check-command-coverage` did not scan at the time — it judged
+ * `modules/<m>/services/*.ts` and nothing else, one level deep (issue #122
+ * widened it to every file a module owns) — and D-38 moved it here, into a
+ * services file, when presence became a composition step. So what changed in
+ * feature 072 is the check's line of sight, not the decision being made;
+ * nothing about the reconcile became sensitive on the way across.
+ *
+ * **What it writes.** One `module_registrations` row per shipped manifest that
+ * has none, carrying `state='installed'`, the manifest's version and
+ * `bootConvergedAt` — the marker saying *"boot wrote this and no install has
+ * run"*. Inserts only: it skips every id that already has a row, so it never
+ * updates a state, never bumps a version, never deletes. It therefore cannot
+ * overwrite an operator's platform-availability choice, and it does not touch the
+ * operator activation axis at all — that lives in the settings store (Principle
+ * XVII). On a converged database it writes nothing.
+ *
+ * **The marker changes nothing about the decision this function makes**, which
+ * is why the hatch above still covers it verbatim: it is a second field on a row
+ * this function was already inserting, recording *who wrote it* rather than
+ * deriving *what to write*. `install` reads it, completes the row it describes
+ * and clears it. Before it existed, `install` short-circuited on
+ * `state === 'installed'` and answered `already-installed` over a converged row,
+ * so a database whose first action after the migrations was a boot could never
+ * run any `installHook` — invisible until feature 134's W7, because until then
+ * the tree had no `installHook` at all. The marker is on **every** converged row
+ * and not only a hook-bearing one: it is true of both, and narrowing it to the
+ * hook-bearing set would leave a module that gains a hook later unmarked, which
+ * is the residual case all over again one release on.
+ *
+ * **Why no actor exists.** It runs from `composeApp()` before the first module
+ * registers, inside
+ * `enterSystemScope('boot: load module presence', …, { entryPoint: 'boot' })`.
+ * There is no admin user and no request to attribute it to; the identity the
+ * path does have is that scope, and `enterSystemScope` already reports it
+ * through `recordEscapeHatchAudit` (`tenant.escape_hatch`, with the reason and
+ * `entryPoint: 'boot'`). A Command would add one `actorAdminUserId: null` entry
+ * per boot per deployment, diluting the `module.*` trail the orchestrator
+ * writes for the transitions an operator really did request.
+ *
+ * **What would make a future change need a Command.** Any write here that
+ * *decides* rather than converges: updating `state` or `version` on an existing
+ * row, deleting the row of a manifest this deployment no longer ships, or
+ * deriving what to write from anything other than the shipped manifest list.
+ * Each of those changes an operator's platform-availability answer, and those
+ * transitions belong to `LifecycleOrchestrator`, which audits every one of them
+ * (`module.installed`, `module.enabled`, `module.disabled`, …). If this
+ * function ever needs one of them, the write moves there — the hatch does not
+ * stretch to cover it.
+ */
+async function reconcileExistingModules(emFactory, entries) {
+    const em = emFactory();
+    const existing = await em.find(ModuleRegistration, {});
+    const existingIds = new Set(existing.map((r) => r.moduleId));
+    const now = new Date();
+    for (const { manifest } of entries) {
+        if (existingIds.has(manifest.id))
+            continue;
+        em.create(ModuleRegistration, {
+            moduleId: manifest.id,
+            state: 'installed',
+            version: manifest.version,
+            installedAt: now,
+            lastStateChangeAt: now,
+            lastInstallFailedAt: null,
+            lastInstallError: null,
+            // The marker, on the row and on the same timestamp as the rest of it.
+            bootConvergedAt: now,
+        });
+    }
+    await em.flush();
+    // The rows as they were **before** this converged them, which is what D-101's
+    // second trigger asks about: a row it just inserted says `installed` by
+    // construction, and a row it left alone is the one the reconciler will not
+    // repair.
+    return new Map(existing.map((row) => [row.moduleId, row.state]));
+}
+//# sourceMappingURL=presence-load.js.map

package/dist/lifecycle/services/presence-load.js.map

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

package/dist/lifecycle/services/static-registry.d.ts

@@ -0,0 +1,47 @@
+import type { ModuleInstallHook, ModuleLifecycleParticipant, ModuleManifest, ModuleRecentActivity, ModuleUninstallHook } from '@endora-commerce/contracts';
+import type { LoadedManifestRegistry } from './manifest-loader.js';
+/**
+ * Build a `LoadedManifestRegistry` from static imports — what the
+ * production composition root uses instead of filesystem discovery.
+ *
+ * Why a separate path? `composition.ts` already imports every module's
+ * plugin via static `import` statements (so the build picks them up).
+ * Asking the same code to do filesystem discovery in production would
+ * require shipping the source tree alongside `dist/`, which we don't.
+ * The CLI scripts (which run via `tsx` against the source tree) and
+ * tests (which run via vitest, ditto) use the dynamic discovery loader.
+ */
+/**
+ * What {@link buildStaticRegistry} accepts.
+ *
+ * **Hand the resolved entries straight in; do not re-map them.** Five CLI
+ * scripts, `composition.ts` and the test harness each carried a hand-written
+ * identity map from `RegisteredManifestEntry` into this shape, field by field —
+ * seven copies of one function, of which `status.ts` had already dropped
+ * `filePath` and every one of them would have dropped the
+ * `lifecycleParticipant` added in feature 080's T036a. The two types are
+ * structurally compatible on purpose, so there is nothing to copy.
+ *
+ * Every optional field spells `| undefined` explicitly, and that is what makes
+ * the compatibility hold: under `exactOptionalPropertyTypes` a bare `?:`
+ * refuses a value whose own property is typed `T | undefined`, which is what
+ * every carrier of these fields has.
+ */
+export interface StaticRegistryEntry {
+    manifest: ModuleManifest;
+    installHook?: ModuleInstallHook | undefined;
+    uninstallHook?: ModuleUninstallHook | undefined;
+    /**
+     * This module's interest in every *other* module's install and hard
+     * uninstall (feature 080, T036a / D-159).
+     */
+    lifecycleParticipant?: ModuleLifecycleParticipant | undefined;
+    /**
+     * The module's recent-activity eligibility (feature 080, T042j / D-163.1).
+     */
+    recentActivity?: ModuleRecentActivity | undefined;
+    /** Optional source-file path for diagnostics; defaults to `'<static>'`. */
+    filePath?: string | undefined;
+}
+export declare function buildStaticRegistry(entries: ReadonlyArray<StaticRegistryEntry>): LoadedManifestRegistry;
+//# sourceMappingURL=static-registry.d.ts.map

package/dist/lifecycle/services/static-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-registry.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/services/static-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,0BAA0B,EAC1B,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,sBAAsB,EAAqB,MAAM,sBAAsB,CAAC;AAEtF;;;;;;;;;;GAUG;AACH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC5C,aAAa,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAChD;;;OAGG;IACH,oBAAoB,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAC9D;;OAEG;IACH,cAAc,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IAClD,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,CAAC,mBAAmB,CAAC,GAC1C,sBAAsB,CA8CxB"}

package/dist/lifecycle/services/static-registry.js

@@ -0,0 +1,41 @@
+import { ModuleDepGraph } from './dep-graph.js';
+import { collectLifecycleParticipants } from './manifest-loader.js';
+export function buildStaticRegistry(entries) {
+    const modules = new Map();
+    for (const e of entries) {
+        if (modules.has(e.manifest.id)) {
+            throw new Error(`[static-registry] duplicate manifest id "${e.manifest.id}" — ` +
+                `composition root must declare each module exactly once.`);
+        }
+        modules.set(e.manifest.id, {
+            manifest: e.manifest,
+            filePath: e.filePath ?? '<static>',
+            ...(e.installHook ? { installHook: e.installHook } : {}),
+            ...(e.uninstallHook ? { uninstallHook: e.uninstallHook } : {}),
+            ...(e.lifecycleParticipant ? { lifecycleParticipant: e.lifecycleParticipant } : {}),
+            ...(e.recentActivity ? { recentActivity: e.recentActivity } : {}),
+        });
+    }
+    // Orphan deps: per research §R7, BOOT IS TOLERANT — modules whose
+    // dependencies haven't been retrofitted yet (Pass B is a separate
+    // feature) are accepted with a warning. The orchestrator's install/
+    // enable validation re-checks against the registry at command time
+    // and refuses misconfigured installs.
+    for (const e of modules.values()) {
+        for (const dep of e.manifest.dependencies) {
+            if (!modules.has(dep)) {
+                console.warn(`[static-registry] manifest "${e.manifest.id}" depends on ` +
+                    `"${dep}" which is not in the static registry — ` +
+                    `treating as always-installed (Pass B retrofit pending).`);
+            }
+        }
+    }
+    const graph = new ModuleDepGraph([...modules.values()].map((m) => m.manifest));
+    const cycle = graph.hasCycle();
+    if (cycle) {
+        throw new Error(`[static-registry] cycle in module dependency graph: ` +
+            `[${cycle.cycle.join(' → ')}]`);
+    }
+    return { modules, graph, participants: collectLifecycleParticipants(modules.values()) };
+}
+//# sourceMappingURL=static-registry.js.map

package/dist/lifecycle/services/static-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-registry.js","sourceRoot":"","sources":["../../../src/lifecycle/services/static-registry.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AA+CpE,MAAM,UAAU,mBAAmB,CACjC,OAA2C;IAE3C,MAAM,OAAO,GAAG,IAAI,GAAG,EAA6B,CAAC;IACrD,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CACb,4CAA4C,CAAC,CAAC,QAAQ,CAAC,EAAE,MAAM;gBAC7D,yDAAyD,CAC5D,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE;YACzB,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,QAAQ,EAAE,CAAC,CAAC,QAAQ,IAAI,UAAU;YAClC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACxD,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9D,GAAG,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,oBAAoB,EAAE,CAAC,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACnF,GAAG,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAClE,CAAC,CAAC;IACL,CAAC;IACD,kEAAkE;IAClE,kEAAkE;IAClE,oEAAoE;IACpE,mEAAmE;IACnE,sCAAsC;IACtC,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QACjC,KAAK,MAAM,GAAG,IAAI,CAAC,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAEtB,OAAO,CAAC,IAAI,CACV,+BAA+B,CAAC,CAAC,QAAQ,CAAC,EAAE,eAAe;oBACzD,IAAI,GAAG,0CAA0C;oBACjD,yDAAyD,CAC5D,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,cAAc,CAC9B,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAC7C,CAAC;IACF,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC/B,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACb,sDAAsD;YACpD,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CACjC,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,4BAA4B,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;AAC1F,CAAC"}

package/dist/migrations/20260424T165847_core_foundation_init.d.ts

@@ -0,0 +1,25 @@
+import { Migration } from '@mikro-orm/migrations';
+/**
+ * Initial foundation migration — consolidates Phase 2 (sessions, audit_log_entries)
+ * and Phase 3.4 catalog / assets / inventory tables, plus the M:N bridge tables the
+ * Catalog module needs for category membership and asset attachment.
+ *
+ * It created `sales_channel_products` too until
+ * `specs/120-migration-closure-bridge-ownership/` Phase 2 moved it to `catalog`,
+ * which is the module that owns its far side (D-226).
+ *
+ * Naming follows Principle VI:
+ *   - Plural snake_case table names.
+ *   - snake_case columns.
+ *   - Foreign-key columns named `{singular}_id`.
+ *   - Bridge tables named by joining the two singulars alphabetically
+ *     (e.g. `product_categories` for product ↔ category).
+ *
+ * Generated from entity metadata and then enriched with bridges. Kept in
+ * `src/db/migrations/` (module-agnostic) because it spans several modules.
+ */
+export declare class Migration20260424T165847CoreFoundationInit extends Migration {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}
+//# sourceMappingURL=20260424T165847_core_foundation_init.d.ts.map

package/dist/migrations/20260424T165847_core_foundation_init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260424T165847_core_foundation_init.d.ts","sourceRoot":"","sources":["../../src/migrations/20260424T165847_core_foundation_init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,0CAA2C,SAAQ,SAAS;IACxD,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAwNnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAarC"}