@endora-commerce/platform 0.100.0

package/dist/overlay/overlay-runtime.js

@@ -0,0 +1,281 @@
+// Overlay resolution — runtime loader used by composition.
+//
+// The resolver (`resolve-overlay.ts`) decides WHICH core units a deployment
+// overrides; this module dynamically imports the overlay implementations so
+// composition can wire them. It runs ONCE at composeApp() startup. For a
+// bare-core build (no DEPLOYMENT / no overlay dir) both loaders return empty and
+// composition is byte-for-byte unchanged (FR-008).
+//
+// **This file derives no path of its own** (`specs/110-instance-repository/`
+// T113/T114). It moved into `@endora-commerce/platform` and takes the overlay
+// root, and the claims already made on a module id, as parameters — both are
+// facts about the *application*, which in an instance is a member the CLI
+// scaffolded and not a tree this package can see.
+// `backend/src/overlay/overlay-runtime.ts` is the binding: it answers "the
+// active deployment's root" from `overlay-roots.ts`' single `import.meta.url`
+// derivation (D115-3) and "who already claims this id" from
+// `packages/claimed-module-ids.ts` (R7.4), and keeps every name and signature
+// its consumers already write.
+//
+// Runtime path mapping: overlay files are authored under `backend/src/apps/…`
+// and compiled to `backend/dist/apps/…`. Which of the two this process reads
+// needs no detection — the binding's root derivation answers `backend/dist`
+// under a compiled run. What did not follow was the **file names**: this module spelled `manifest.ts`
+// and `backend.ts` into `join(...)` and an `existsSync`, and a compiled tree
+// spells both `.js`. `overlayModuleEntriesUnder` therefore skipped every
+// overlay module in production — `if (!existsSync(...)) continue`, no error and
+// no warning. Measured: the same binary with `DEPLOYMENT=example` logs
+// `decoratedBy: 'example_overlay'` under `tsx` and produces zero overlay lines
+// under `node dist/index.js` (feature 080, D-165 step C).
+//
+// So a unit is **resolved** rather than derived — see {@link resolveOverlayUnit}
+// — and the path that comes back is the file that exists, which is what every
+// consumer of `filePath` needs anyway.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertNoModuleIdCollisions, } from '../lifecycle/services/module-id-claims.js';
+import { listOverlayModuleDirs } from './resolve-overlay.js';
+/**
+ * The two spellings one unit has: `<stem>.js` in a compiled tree, `<stem>.ts`
+ * under `tsx` and `vitest`. Compiled first, for the reason
+ * `manifest-locations.ts` gives about the same pair — the compiled tree is the
+ * one where picking up a stray source file would be wrong.
+ */
+const UNIT_EXTENSIONS = ['.js', '.ts'];
+/**
+ * The real path of the overlay unit `<dir>/<stem>`, or `null` when the module
+ * ships neither spelling.
+ *
+ * A **resolution**, never a derivation. The path this returns is a file that
+ * exists, so `existsSync` on it is redundant by construction and a caller
+ * cannot end up importing a name the build never emitted.
+ */
+export function resolveOverlayUnit(dir, stem) {
+    for (const extension of UNIT_EXTENSIONS) {
+        const candidate = join(dir, `${stem}${extension}`);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/** The candidates {@link resolveOverlayUnit} tried, for a message that names them. */
+function unitCandidates(dir, stem) {
+    return UNIT_EXTENSIONS.map((extension) => join(dir, `${stem}${extension}`)).join(' and ');
+}
+/** Convert an absolute path to an importable URL. */
+function importUrlFor(absPath) {
+    return pathToFileURL(absPath).href;
+}
+/**
+ * The overlay module ids under one overlay modules root, **and the one place
+ * their claim on those ids is checked** (feature 103, FR-004).
+ *
+ * Both overlay seams go through here — `overlayModuleManifestsUnder`, which is
+ * what `resolvedManifestEntries()` reads, and `overlayModuleEntriesUnder`,
+ * which is what a composition root composes — so the two cannot answer
+ * differently, which is exactly what they used to do: one dropped a colliding
+ * manifest with a `continue` while the other composed the module, leaving it
+ * with no registry row, no permission-catalogue entry and its routes gated on
+ * the effective state of somebody else's module of the same id.
+ *
+ * The claimed set is derived from what this instance ships and what is
+ * installed in it, never written down — so a module that arrives, moves or
+ * leaves changes the answer in the same run. It arrives as
+ * {@link claimsOutsideTheOverlay}, a **parameter**: its core half comes off the
+ * generated manifest index, which is a fact about one tree (D-104, D-160.3), and
+ * R7.4 is that a relocated platform file receives such a thing rather than
+ * reaching for it. `backend/src/overlay/overlay-runtime.ts` is the binding that
+ * supplies it, and an instance writes the same one.
+ *
+ * This used to be `scanOverlay(root, indexCore(coreModulesRoot())).newModules`
+ * — a file-shadowing scan whose core index resolved `backend/src/modules`,
+ * which has held no module since F4. With the index empty **every** overlay
+ * directory came back as a new module claiming its id, unchecked (D-201).
+ */
+export function overlayModuleIdsUnder(root, claimsOutsideTheOverlay) {
+    const ids = listOverlayModuleDirs(root);
+    assertNoModuleIdCollisions([
+        ...claimsOutsideTheOverlay,
+        ...ids.map((id) => ({
+            id,
+            origin: 'overlay',
+            // The directory, not a manifest that may not be there: an overlay module
+            // with no manifest is refused a few lines down, by a message that names
+            // both candidate spellings, and a claim built from a path that does not
+            // exist would pre-empt it with a worse one.
+            claimedBy: join(root, id),
+        })),
+    ]);
+    return ids;
+}
+/**
+ * Discover overlay MODULE manifests under one root WITHOUT composing them. Used
+ * early in composition to build the deployment-resolved registry the permission
+ * catalogue + lifecycle consume (FR-009, FR-012).
+ *
+ * The **root** is a parameter, not a derivation of this file's own path: which
+ * directory holds `apps/<deployment>/modules` is a fact about the application,
+ * derived once by `backend/src/overlay/overlay-roots.ts` from its own
+ * `import.meta.url` (D115-3), and the platform is not in that tree. The binding
+ * beside that derivation is what answers "the active deployment's" — see
+ * `backend/src/overlay/overlay-runtime.ts`.
+ *
+ * The fixture is therefore a directory on disk, scanned and imported by the code
+ * the deployment path runs, rather than a value handed to the last function in
+ * the chain (issue #130).
+ */
+export async function overlayModuleManifestsUnder(root, ids) {
+    const out = [];
+    for (const id of ids) {
+        const moduleDir = join(root, id);
+        const manifestPath = resolveOverlayUnit(moduleDir, 'manifest');
+        if (manifestPath === null) {
+            // The scan already reported this directory as a module, so an absent
+            // manifest is not "a directory that ships nothing" — it is a module with
+            // no id and no version to compose it under. Refused here rather than left
+            // to `import()`, whose ERR_MODULE_NOT_FOUND names a `.ts` path that never
+            // existed in a compiled tree and sends the reader looking for the wrong
+            // file (D-165 step C).
+            throw new Error(`[overlay] the module directory ${moduleDir} carries no manifest — tried ` +
+                `${unitCandidates(moduleDir, 'manifest')}. An overlay module is discovered by its ` +
+                `directory and identified by its manifest; without one it has no id and no version.`);
+        }
+        const mod = (await import(importUrlFor(manifestPath)));
+        const manifest = mod['manifest'];
+        if (!manifest)
+            continue;
+        // `exactOptionalPropertyTypes`: an absent key is not `{ hook: undefined }`,
+        // and the lifecycle asks `entry.installHook !== undefined`.
+        const installHook = mod['installHook'];
+        const uninstallHook = mod['uninstallHook'];
+        const lifecycleParticipant = mod['lifecycleParticipant'];
+        const cliCommands = mod['cliCommands'];
+        const recentActivity = mod['recentActivity'];
+        out.push({
+            id,
+            manifest,
+            filePath: manifestPath,
+            ...(installHook ? { installHook } : {}),
+            ...(uninstallHook ? { uninstallHook } : {}),
+            ...(lifecycleParticipant ? { lifecycleParticipant } : {}),
+            ...(cliCommands ? { cliCommands } : {}),
+            ...(recentActivity ? { recentActivity } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * One overlay root's converted modules, as composer entries (D-103/D-104).
+ *
+ * The root and the claims are parameters for the reason
+ * {@link overlayModuleManifestsUnder} gives: both are facts about the
+ * application, and `backend/src/overlay/overlay-runtime.ts` is the binding that
+ * answers "the active deployment's" over them.
+ *
+ * This is the **one** composition path for an overlay module: a root appends
+ * these to the core list and passes the single array to `composeModules`, so an
+ * overlay module receives an ordinary `ModuleContext` and reaches every seam a
+ * core module reaches — `ctx.routes` and its lifecycle gate, `ctx.worker`,
+ * `ctx.subscribe`, `ctx.interceptors`, `ctx.onBoot`, ports, and the decoration
+ * exemption. The path it replaces handed a frozen seven-field context to a
+ * `plugin.ts` factory and could gate nothing.
+ *
+ * **Discovered at runtime, not baked into a generated core artefact** (D-104).
+ * A deployment's manifests already resolve this way and for the stated reason:
+ * the answer depends on which deployment the *process* runs as, not on which
+ * tree a generator was run against. Registrations have the identical property
+ * and used to be given the opposite treatment, which made
+ * `composition.generated.ts` and `manifest-index.generated.ts` environment-
+ * dependent — an artefact that is always stale for a deployment is one nobody
+ * can use to detect a genuinely stale one (issue #120, applied to the family it
+ * was missed in).
+ *
+ * `overlay: true` is set **from the root the module was found under**, which is
+ * what `ModuleEntry.overlay`'s own contract requires: it exempts the module
+ * from the rule that a module may decorate only what it registered, so it may
+ * never be a claim a module makes about itself.
+ *
+ * Ordering is deterministic — the entries come back in id order and a root
+ * appends them after a frozen core list — and it decides nothing about
+ * decoration. It used to: this paragraph read "so a deployment's decoration
+ * always wraps a core registration that is already there", which was the
+ * composer's array position doing policy work. Since D-176 every
+ * `ctx.di.decorate` is queued during registration and drained once the last
+ * module has registered, so where a module sits in the array cannot grant or
+ * refuse a wrap; the ownership guard decides, alone.
+ *
+ * A module directory with no backend entry point **in either spelling** is
+ * skipped, not thrown at — a deployment may ship an overlay directory that only
+ * shadows core files. "Either spelling" is the whole of D-165 step C's repair
+ * here: this used to ask `existsSync('backend.ts')`, so a compiled deployment's
+ * every module took the skip and vanished with no error. A `backend.js`/`.ts`
+ * that exports no `registerModule` is a different thing and is refused:
+ * skipping it would compose nothing, and the first symptom would be a 404
+ * nobody connects to this file.
+ */
+export async function overlayModuleEntriesUnder(root, claimsOutsideTheOverlay) {
+    return await overlayModuleEntriesForIds(root, overlayModuleIdsUnder(root, claimsOutsideTheOverlay));
+}
+/**
+ * {@link overlayModuleEntriesUnder} over an id set already derived.
+ *
+ * It exists so a caller that needs **both** seams — the entries it composes and
+ * the manifests the resolved registry is built from — asserts the id-collision
+ * claim set once, over one array, rather than twice over two derivations that
+ * `overlayModuleIdsUnder`'s own contract says must never be able to answer
+ * differently. {@link overlayModulesUnder} is that caller's shape; this stays
+ * private because an id set assembled anywhere but there has not been checked.
+ */
+async function overlayModuleEntriesForIds(root, ids) {
+    const entries = [];
+    for (const id of ids) {
+        const moduleDir = join(root, id);
+        const backendPath = resolveOverlayUnit(moduleDir, 'backend');
+        if (backendPath === null)
+            continue;
+        const mod = (await import(importUrlFor(backendPath)));
+        const registerModule = mod['registerModule'];
+        if (typeof registerModule !== 'function') {
+            throw new Error(`[overlay] ${backendPath} exports no 'registerModule'. A module's backend.ts is its ` +
+                `entry point (see backend/src/apps/example/modules/example_overlay/backend.ts); ` +
+                `rename or remove the file if it is not one. It is not composed as written, and an ` +
+                `overlay module that composes nothing is a 404 with no error behind it.`);
+        }
+        const manifestPath = resolveOverlayUnit(moduleDir, 'manifest');
+        if (manifestPath === null) {
+            throw new Error(`[overlay] ${moduleDir} ships a composable backend entry point and no manifest — ` +
+                `tried ${unitCandidates(moduleDir, 'manifest')}. The module has no id and no ` +
+                `version to compose it under.`);
+        }
+        const manifestMod = (await import(importUrlFor(manifestPath)));
+        const manifest = manifestMod['manifest'];
+        if (!manifest) {
+            throw new Error(`[overlay] ${manifestPath} exports no lifecycle-shape manifest, so ` +
+                `the module has no id and no version to compose it under.`);
+        }
+        entries.push({
+            id,
+            version: manifest.version,
+            registerModule: registerModule,
+            // From the root, never from the module. See the note above.
+            overlay: true,
+        });
+    }
+    return entries;
+}
+export function overlayModulesUnder(root, claimsOutsideTheOverlay) {
+    let derived;
+    const ids = () => {
+        if (derived === undefined) {
+            derived = root === null ? [] : overlayModuleIdsUnder(root, claimsOutsideTheOverlay());
+        }
+        return derived;
+    };
+    return {
+        ids,
+        manifests: async () => (root === null ? [] : await overlayModuleManifestsUnder(root, ids())),
+        entries: async () => (root === null ? [] : await overlayModuleEntriesForIds(root, ids())),
+    };
+}
+//# sourceMappingURL=overlay-runtime.js.map

package/dist/overlay/overlay-runtime.js.map

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

package/dist/overlay/resolve-overlay.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Result of resolving a deployment overlay.
+ *
+ * Declared here rather than in the application's `src/overlay/types.ts`, which
+ * stayed behind: that file is named **by relative path** from every deployment's
+ * generated divergence artefact and may not become a bare specifier, because a
+ * committed artefact under `src/apps/<deployment>/` whose import depends on the
+ * deployment's own dependency graph is the one artefact that stops being
+ * readable in a tree that has not installed the package. So the divergence
+ * shapes stay there and the *resolution* shape, which no artefact names, comes
+ * here with the function that produces it.
+ */
+export interface OverlayResolution {
+    deployment: string | null;
+    newModules: string[];
+}
+/**
+ * Deterministic list of the module directories directly under an overlay root.
+ *
+ * Sorted, dot-prefixed entries skipped, non-directories skipped — the same
+ * listing `deploymentsOnDisk()` makes one level up, and both are sorted for the
+ * same reason: a committed artefact downstream is byte-compared.
+ */
+export declare function listOverlayModuleDirs(root: string): string[];
+/**
+ * Resolve one deployment: the module ids it adds. When `overlayRoot` is `null`
+ * (no deployment, or a deployment that ships no overlay directory) the result
+ * is core-only and empty, and the build behaves byte-for-byte like bare core
+ * (feature 057 FR-008, SC-006).
+ *
+ * It refuses nothing. An overlay module id already claimed by core, by a
+ * workspace module package, by an installed package or by another overlay
+ * module is refused at the seams that discover and compose — one rule, reached
+ * by both readers (feature 103, FR-004) — rather than here, where a build-time
+ * audit artefact is being rendered and no module is about to run.
+ */
+export declare function resolveOverlay(params: {
+    overlayRoot: string | null;
+    deployment: string | null;
+}): OverlayResolution;
+//# sourceMappingURL=resolve-overlay.d.ts.map

package/dist/overlay/resolve-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-overlay.d.ts","sourceRoot":"","sources":["../../src/overlay/resolve-overlay.ts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAY5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GAAG,iBAAiB,CAIpB"}

package/dist/overlay/resolve-overlay.js

@@ -0,0 +1,72 @@
+// Overlay resolution — which modules a deployment adds.
+//
+// That is the whole of it since D-201 retired file shadowing (feature 103). An
+// overlay module owns every file it ships, so there is nothing inside one of
+// these directories for the platform to classify, and no core tree to classify
+// it against: the resolution is a deterministic listing of the module
+// directories under one root.
+//
+// **What used to be here, and why none of it is missed.** A core index, a unit
+// taxonomy (`route` / `config` / `schema` / `other`), a shadowing rule, a
+// conflict policy and three build-time refusals. `git log -S` over this
+// directory's whole history finds exactly one loader for a shadowed file ever
+// written — `loadOverlayServiceClasses`, for `service` — and feature 072
+// deleted it deliberately, replacing it with `ctx.di.decorate`, because a
+// replacement stops receiving core fixes the day it is written. `route` and
+// `config` never had a loader at all: `resolution.overrides` had one consumer
+// in the whole history of the tree, the override-manifest generator, which
+// serialised it into an audit artefact. So a route override never changed what
+// a running platform served, on any deployment, in any tree state.
+//
+// Since F4 the classification could not even run — its core root resolved
+// `backend/src/modules`, which holds no module — so every overlay directory
+// short-circuited to "a new module claiming this id" before a single file was
+// looked at, and the three refusals the documentation promised were
+// unreachable. A deployment could put a migration under an overlay directory
+// and the guard written to refuse it said nothing.
+//
+// What a deployment overrides instead is in
+// `docs/docs/architecture/overlay-pattern.md`.
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Deterministic list of the module directories directly under an overlay root.
+ *
+ * Sorted, dot-prefixed entries skipped, non-directories skipped — the same
+ * listing `deploymentsOnDisk()` makes one level up, and both are sorted for the
+ * same reason: a committed artefact downstream is byte-compared.
+ */
+export function listOverlayModuleDirs(root) {
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root)
+        .filter((name) => !name.startsWith('.'))
+        .filter((name) => {
+        try {
+            return statSync(join(root, name)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .sort();
+}
+/**
+ * Resolve one deployment: the module ids it adds. When `overlayRoot` is `null`
+ * (no deployment, or a deployment that ships no overlay directory) the result
+ * is core-only and empty, and the build behaves byte-for-byte like bare core
+ * (feature 057 FR-008, SC-006).
+ *
+ * It refuses nothing. An overlay module id already claimed by core, by a
+ * workspace module package, by an installed package or by another overlay
+ * module is refused at the seams that discover and compose — one rule, reached
+ * by both readers (feature 103, FR-004) — rather than here, where a build-time
+ * audit artefact is being rendered and no module is about to run.
+ */
+export function resolveOverlay(params) {
+    const { overlayRoot, deployment } = params;
+    if (overlayRoot === null)
+        return { deployment: null, newModules: [] };
+    return { deployment, newModules: listOverlayModuleDirs(overlayRoot) };
+}
+//# sourceMappingURL=resolve-overlay.js.map

package/dist/overlay/resolve-overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-overlay.js","sourceRoot":"","sources":["../../src/overlay/resolve-overlay.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,EAAE;AACF,+EAA+E;AAC/E,6EAA6E;AAC7E,+EAA+E;AAC/E,sEAAsE;AACtE,8BAA8B;AAC9B,EAAE;AACF,+EAA+E;AAC/E,0EAA0E;AAC1E,wEAAwE;AACxE,8EAA8E;AAC9E,yEAAyE;AACzE,0EAA0E;AAC1E,4EAA4E;AAC5E,8EAA8E;AAC9E,2EAA2E;AAC3E,+EAA+E;AAC/E,mEAAmE;AACnE,EAAE;AACF,0EAA0E;AAC1E,4EAA4E;AAC5E,8EAA8E;AAC9E,oEAAoE;AACpE,6EAA6E;AAC7E,mDAAmD;AACnD,EAAE;AACF,4CAA4C;AAC5C,+CAA+C;AAE/C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAmBjC;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY;IAChD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IACjC,OAAO,WAAW,CAAC,IAAI,CAAC;SACrB,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;SACvC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QACf,IAAI,CAAC;YACH,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;QAClD,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC,CAAC;SACD,IAAI,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,MAG9B;IACC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IAC3C,IAAI,WAAW,KAAK,IAAI;QAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IACtE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,qBAAqB,CAAC,WAAW,CAAC,EAAE,CAAC;AACxE,CAAC"}

package/dist/packages/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `./packages` — installed extension-package discovery, and the platform's
+ * tenth subpath (`specs/110-instance-repository/` T113, FR-013).
+ *
+ * ## What is on it
+ *
+ * The answer to *"which Endora module packages did an operator install in this
+ * instance, and what do they compose to?"* — the `node_modules` scan, the
+ * classification that tells a tarball install from a workspace link, the
+ * manifest and `ModuleEntry` readers a composition root appends to its one
+ * `composeModules([...MODULES, ...overlay, ...packages], …)` call, the schema
+ * contribution the ORM configuration merges, and the entity lookup a host
+ * program uses to reach a class it may not import.
+ *
+ * It reads a package; it configures nothing. Merging what it finds into the
+ * execution order and into the ORM configuration is the host's
+ * (`backend/src/db/configured-migrations.ts`, `configured-entities.ts`), so the
+ * merge keeps exactly one implementation and this directory still knows nothing
+ * about a database.
+ *
+ * ## Why the platform carries it, and why an instance cannot
+ *
+ * This is *the* mechanism an instance depends on most (`research.md` §3.1): a
+ * client's whole tree is a composition of packages, and the code that finds them
+ * is not code a client may edit. It lived in `backend/src/packages/` while the
+ * application *was* the platform; an instance's application is a member the CLI
+ * scaffolds, and a scan it holds is a scan that diverges from ours the first
+ * time we correct it.
+ *
+ * ## Why no module may name it
+ *
+ * D-160.14's third state, for `./composition`'s own reason one surface over:
+ * this is the code that decides which packages are composed at all, so a module
+ * that could name it could enumerate — and eventually judge — its siblings. It
+ * is declared by the `exports` map and carried by no published barrel, so `node`
+ * and `tsc` resolve it for the host and the test kit, and
+ * `check:platform-surface` answers a module's reach into it with
+ * `host-internal-subpath`.
+ *
+ * ## What stays in the application, and why
+ *
+ * `backend/src/packages/claimed-module-ids.ts`. It reads the **generated**
+ * manifest index, which is a fact about one repository's tree (D-104, D-160.3),
+ * so R7.4 keeps it out of the package: a relocated platform file may not import
+ * a generated registry, it receives one. That file is a binding of eight lines
+ * over this directory's `installedPackageModuleIdClaims`, and an instance writes
+ * the same eight against its own index.
+ *
+ * The barrel names every symbol explicitly rather than re-exporting a directory:
+ * `check:platform-surface` exits 2 on an `export *`, because a wildcard makes
+ * the published set a property of whatever the files happen to declare rather
+ * than of a decision anybody took.
+ */
+export { INSTANCE_ROOT_ENV, nodeModulesRootsFor, scanNodeModulesRoots, type InstalledPackage, type InstalledPackageScan, type SkippedPackage, } from './installed-packages.js';
+export { discoverPackageModuleManifests, discoverPackageSchema, installedPackageModuleIdClaims, loadPackageModuleEntries, packageModuleEntriesUnder, packageModuleManifestsUnder, packageSchemaContributionsUnder, type EntityClassLike, type MigrationRegistryEntry, type PackageModuleManifest, type PackageSchemaContribution, } from './package-runtime.js';
+export { entityNamed, type EntityRowTypeIsRequired, } from './package-entity-lookup.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/packages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,cAAc,GACpB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,EACrB,8BAA8B,EAC9B,wBAAwB,EACxB,yBAAyB,EACzB,2BAA2B,EAC3B,+BAA+B,EAC/B,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,GAC/B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,WAAW,EACX,KAAK,uBAAuB,GAC7B,MAAM,4BAA4B,CAAC"}

package/dist/packages/index.js

@@ -0,0 +1,57 @@
+/**
+ * `./packages` — installed extension-package discovery, and the platform's
+ * tenth subpath (`specs/110-instance-repository/` T113, FR-013).
+ *
+ * ## What is on it
+ *
+ * The answer to *"which Endora module packages did an operator install in this
+ * instance, and what do they compose to?"* — the `node_modules` scan, the
+ * classification that tells a tarball install from a workspace link, the
+ * manifest and `ModuleEntry` readers a composition root appends to its one
+ * `composeModules([...MODULES, ...overlay, ...packages], …)` call, the schema
+ * contribution the ORM configuration merges, and the entity lookup a host
+ * program uses to reach a class it may not import.
+ *
+ * It reads a package; it configures nothing. Merging what it finds into the
+ * execution order and into the ORM configuration is the host's
+ * (`backend/src/db/configured-migrations.ts`, `configured-entities.ts`), so the
+ * merge keeps exactly one implementation and this directory still knows nothing
+ * about a database.
+ *
+ * ## Why the platform carries it, and why an instance cannot
+ *
+ * This is *the* mechanism an instance depends on most (`research.md` §3.1): a
+ * client's whole tree is a composition of packages, and the code that finds them
+ * is not code a client may edit. It lived in `backend/src/packages/` while the
+ * application *was* the platform; an instance's application is a member the CLI
+ * scaffolds, and a scan it holds is a scan that diverges from ours the first
+ * time we correct it.
+ *
+ * ## Why no module may name it
+ *
+ * D-160.14's third state, for `./composition`'s own reason one surface over:
+ * this is the code that decides which packages are composed at all, so a module
+ * that could name it could enumerate — and eventually judge — its siblings. It
+ * is declared by the `exports` map and carried by no published barrel, so `node`
+ * and `tsc` resolve it for the host and the test kit, and
+ * `check:platform-surface` answers a module's reach into it with
+ * `host-internal-subpath`.
+ *
+ * ## What stays in the application, and why
+ *
+ * `backend/src/packages/claimed-module-ids.ts`. It reads the **generated**
+ * manifest index, which is a fact about one repository's tree (D-104, D-160.3),
+ * so R7.4 keeps it out of the package: a relocated platform file may not import
+ * a generated registry, it receives one. That file is a binding of eight lines
+ * over this directory's `installedPackageModuleIdClaims`, and an instance writes
+ * the same eight against its own index.
+ *
+ * The barrel names every symbol explicitly rather than re-exporting a directory:
+ * `check:platform-surface` exits 2 on an `export *`, because a wildcard makes
+ * the published set a property of whatever the files happen to declare rather
+ * than of a decision anybody took.
+ */
+export { INSTANCE_ROOT_ENV, nodeModulesRootsFor, scanNodeModulesRoots, } from './installed-packages.js';
+export { discoverPackageModuleManifests, discoverPackageSchema, installedPackageModuleIdClaims, loadPackageModuleEntries, packageModuleEntriesUnder, packageModuleManifestsUnder, packageSchemaContributionsUnder, } from './package-runtime.js';
+export { entityNamed, } from './package-entity-lookup.js';
+//# sourceMappingURL=index.js.map

package/dist/packages/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/packages/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,GAIrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,EACrB,8BAA8B,EAC9B,wBAAwB,EACxB,yBAAyB,EACzB,2BAA2B,EAC3B,+BAA+B,GAKhC,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,WAAW,GAEZ,MAAM,4BAA4B,CAAC"}

package/dist/packages/installed-packages.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The environment variable naming the **instance** — the directory whose
+ * `node_modules` holds this platform's installed extension packages.
+ *
+ * Unset is the ordinary case and is not a degraded one: a deployed instance
+ * *is* the directory the platform runs from, so the chain above the running
+ * code already names it. The variable exists for the case where the two are not
+ * the same — a platform executed out of a checkout against an instance built
+ * somewhere else, which is exactly what D-110's acceptance criterion does.
+ */
+export declare const INSTANCE_ROOT_ENV = "ENDORA_INSTANCE_ROOT";
+/** One installed package claiming to be an Endora module. */
+export interface InstalledPackage {
+    /** The module id it claims — `endora.id` (D-142), never the folder name. */
+    readonly id: string;
+    /** The npm package name. Identity for humans; never identity for the platform. */
+    readonly name: string;
+    readonly version: string;
+    /** The package directory as installed, symlinks unfollowed. */
+    readonly directory: string;
+    /** `<directory>/package.json` — the file that claims {@link id}. */
+    readonly manifestPath: string;
+    /** The `node_modules` directory it was found under. */
+    readonly foundUnder: string;
+}
+/** A candidate that was read and not accepted, with the reason. */
+export type SkippedPackage = {
+    readonly kind: 'links-out-of-node-modules';
+    readonly name: string;
+    readonly at: string;
+    readonly realPath: string;
+} | {
+    readonly kind: 'not-an-endora-module';
+    readonly name: string;
+    readonly at: string;
+} | {
+    readonly kind: 'unreadable';
+    readonly at: string;
+    readonly reason: string;
+};
+export interface InstalledPackageScan {
+    /** Accepted packages, ordered by npm name so composition is deterministic. */
+    readonly packages: readonly InstalledPackage[];
+    readonly skipped: readonly SkippedPackage[];
+    /** The roots that existed and were walked — never the roots that were asked for. */
+    readonly rootsRead: readonly string[];
+}
+/**
+ * Every `node_modules` directory this platform reads, nearest first.
+ *
+ * The declared instance root comes first, then the chain above the running
+ * platform — in an instance, `<instance>/node_modules/@endora-commerce/platform`
+ * upward to the instance root; in this checkout, the platform package's own and
+ * the repository's. The chain is Node's own module-resolution directory list,
+ * which is the honest answer to "where would an installed package be": wherever
+ * `import` would find it. Roots that do not exist are dropped, so an empty
+ * result means *nothing to read* rather than *nothing found*.
+ *
+ * **The chain is derived from this file's own location and therefore moved with
+ * it** (`specs/110-instance-repository/` T113). It read from
+ * `backend/src/packages/` until the relocation, so `backend/node_modules` was on
+ * it and the platform package's was not; it now reads from
+ * `@endora-commerce/platform`, which is where the platform actually runs from in
+ * an instance, and is the reading `ENDORA_INSTANCE_ROOT` exists to override. No
+ * discovery is lost in this checkout: every `@endora-commerce/*` entry under
+ * `backend/node_modules` is a workspace link and is refused as one a few
+ * hundred lines down, which is what `installed-packages.test.ts` asserts either
+ * side of the move.
+ */
+export declare function nodeModulesRootsFor(env?: NodeJS.ProcessEnv): string[];
+/**
+ * Scan the given `node_modules` roots for installed Endora module packages.
+ *
+ * A package found in more than one root is taken from the nearest one — the
+ * same precedence Node's resolver applies, so what the platform composes is
+ * what an `import` of that name in the instance would load.
+ */
+export declare function scanNodeModulesRoots(roots: readonly string[]): InstalledPackageScan;
+//# sourceMappingURL=installed-packages.d.ts.map

package/dist/packages/installed-packages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-packages.d.ts","sourceRoot":"","sources":["../../src/packages/installed-packages.ts"],"names":[],"mappings":"AA2EA;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AAExD,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,uDAAuD;IACvD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,mEAAmE;AACnE,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,IAAI,EAAE,2BAA2B,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACrF;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElF,MAAM,WAAW,oBAAoB;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,oFAAoF;IACpF,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAQD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,EAAE,CA0BlF;AAwJD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,oBAAoB,CA8BnF"}