@bett3r-dev/pv3 1.0.0 → 2.5.1

package/build/libraries/deployment-units/computeMDUs.test.js

@@ -0,0 +1,996 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const computeMDUs_1 = require("./computeMDUs");
+// ---------------------------------------------------------------------------
+// Helper to build minimal registeredEndpoints
+// ---------------------------------------------------------------------------
+const emptyEndpoints = () => ({
+    aggregates: {},
+    systems: {},
+    policies: {},
+    projectors: {}
+});
+const SERVICE_NAME = 'test-service';
+const SERVICE_ROOT = '/app/services/test-service';
+describe('computeMDUs', () => {
+    // -------------------------------------------------------------------------
+    // 1. Aggregate with createCommand policy (commandHandlerName) -> same MDU
+    // -------------------------------------------------------------------------
+    describe('aggregate with createCommand policy', () => {
+        it('places them in the same deployment unit', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['FooAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateFoo: { route: '/foo', events: ['FooCreated'] } },
+                filePath: '/app/services/test-service/src/modules/foo/foo.aggregate.ts',
+                subdomain: 'foo'
+            };
+            endpoints.policies['FooCreationPolicy'] = {
+                route: '/foo-creation-policy',
+                events: ['FooCreated'],
+                filePath: '/app/services/test-service/src/modules/foo/fooCreation.policy.ts',
+                subdomain: 'foo',
+                commandHandlerName: 'FooAggregate'
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            const unitKeys = Object.keys(manifest.units);
+            expect(unitKeys).toHaveLength(1);
+            const unit = manifest.units[unitKeys[0]];
+            expect(unit.type).toBe('command-group');
+            expect(unit.artifacts.map(a => a.name).sort()).toEqual(['FooAggregate', 'FooCreationPolicy'].sort());
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 2. Aggregate with linkedTo policy -> same MDU
+    // -------------------------------------------------------------------------
+    describe('aggregate with linkedTo policy', () => {
+        it('places them in the same deployment unit', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['BarAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateBar: { route: '/bar', events: ['BarCreated'] } },
+                filePath: '/app/services/test-service/src/modules/bar/bar.aggregate.ts',
+                subdomain: 'bar'
+            };
+            endpoints.policies['BarSyncPolicy'] = {
+                route: '/bar-sync-policy',
+                events: ['SomethingHappened'],
+                filePath: '/app/services/test-service/src/modules/bar/barSync.policy.ts',
+                subdomain: 'bar',
+                linkedTo: ['BarAggregate']
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            const unitKeys = Object.keys(manifest.units);
+            expect(unitKeys).toHaveLength(1);
+            const unit = manifest.units[unitKeys[0]];
+            expect(unit.type).toBe('command-group');
+            expect(unit.artifacts.map(a => a.name)).toContain('BarAggregate');
+            expect(unit.artifacts.map(a => a.name)).toContain('BarSyncPolicy');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 3. Standalone policy -> own MDU
+    // -------------------------------------------------------------------------
+    describe('standalone policy', () => {
+        it('gets its own deployment unit', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.policies['NotificationPolicy'] = {
+                route: '/notification-policy',
+                events: ['OrderPlaced'],
+                filePath: '/app/services/test-service/src/modules/notifications/notification.policy.ts',
+                subdomain: 'notifications',
+                isStandalone: true
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            const unitKeys = Object.keys(manifest.units);
+            expect(unitKeys).toHaveLength(1);
+            const unit = manifest.units[unitKeys[0]];
+            expect(unit.type).toBe('command-group');
+            expect(unit.artifacts).toHaveLength(1);
+            expect(unit.artifacts[0].name).toBe('NotificationPolicy');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 4. Readmodel (projector) -> independent MDU of type 'readmodel'
+    // -------------------------------------------------------------------------
+    describe('readmodel projector', () => {
+        it('produces an independent readmodel deployment unit', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.projectors['OrdersReadmodel'] = {
+                route: '/orders/:id?',
+                events: ['OrderPlaced', 'OrderCancelled'],
+                filePath: '/app/services/test-service/src/modules/sales/orders.readmodel.ts',
+                subdomain: 'sales'
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            const unitKeys = Object.keys(manifest.units);
+            expect(unitKeys).toHaveLength(1);
+            const unit = manifest.units[unitKeys[0]];
+            expect(unit.type).toBe('readmodel');
+            expect(unit.artifacts).toHaveLength(1);
+            expect(unit.artifacts[0].name).toBe('OrdersReadmodel');
+            expect(unit.consumes).toEqual(['OrderCancelled', 'OrderPlaced']);
+        });
+        // TV1-2275. A QUERY-ONLY readmodel — one with a query route and no events
+        // namespace — is registered as a projector with an empty `events`, and is a
+        // deployment artifact like any other: it simply consumes nothing. Before pv3
+        // registered it at all, there was no node here, so its GET route had no artifact
+        // to ride and belonged to no unit.
+        it('produces a unit for a readmodel that subscribes to nothing', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.projectors['OrderStatusesReadmodel'] = {
+                route: '',
+                events: [],
+                filePath: '/app/services/test-service/src/modules/sales/orderStatuses.readmodel.ts',
+                subdomain: 'sales'
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            const unitKeys = Object.keys(manifest.units);
+            expect(unitKeys).toEqual(['sales:OrderStatusesReadmodel']);
+            const unit = manifest.units['sales:OrderStatusesReadmodel'];
+            expect(unit.type).toBe('readmodel');
+            expect(unit.artifacts.map(a => a.name)).toEqual(['OrderStatusesReadmodel']);
+            // No `consumes` at all, rather than an empty array: the unit subscribes to
+            // nothing, which is exactly the shape a topology consumer must tolerate.
+            expect(unit.consumes).toBeUndefined();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 5. Endpoint linking two aggregates -> merges MDUs
+    // -------------------------------------------------------------------------
+    describe('endpoint linking two aggregates from different modules', () => {
+        it('merges them into one command-group', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['AlphaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateAlpha: { route: '/alpha', events: ['AlphaCreated'] } },
+                filePath: '/app/services/test-service/src/modules/alpha/alpha.aggregate.ts',
+                subdomain: 'alpha'
+            };
+            endpoints.aggregates['BetaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateBeta: { route: '/beta', events: ['BetaCreated'] } },
+                filePath: '/app/services/test-service/src/modules/beta/beta.aggregate.ts',
+                subdomain: 'beta'
+            };
+            const customEndpoints = [
+                {
+                    name: 'BridgeEndpoint',
+                    route: '/alpha/bridge',
+                    method: 'POST',
+                    filePath: '/app/services/test-service/src/modules/alpha/bridge.endpoint.ts',
+                    subdomain: 'alpha',
+                    linkedTo: ['AlphaAggregate', 'BetaAggregate'],
+                    exportName: 'BridgeEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            const unitKeys = Object.keys(manifest.units);
+            expect(unitKeys).toHaveLength(1);
+            const unit = manifest.units[unitKeys[0]];
+            expect(unit.type).toBe('command-group');
+            const artifactNames = unit.artifacts.map(a => a.name);
+            expect(artifactNames).toContain('AlphaAggregate');
+            expect(artifactNames).toContain('BetaAggregate');
+            expect(artifactNames).toContain('BridgeEndpoint');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 6. Cross-module merge detected in merges[]
+    // -------------------------------------------------------------------------
+    describe('cross-module merge detection', () => {
+        it('populates merges[] with reason when modules are merged', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['AlphaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateAlpha: { route: '/alpha', events: ['AlphaCreated'] } },
+                filePath: '/app/services/test-service/src/modules/alpha/alpha.aggregate.ts',
+                subdomain: 'alpha'
+            };
+            endpoints.aggregates['BetaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateBeta: { route: '/beta', events: ['BetaCreated'] } },
+                filePath: '/app/services/test-service/src/modules/beta/beta.aggregate.ts',
+                subdomain: 'beta'
+            };
+            const customEndpoints = [
+                {
+                    name: 'BridgeEndpoint',
+                    route: '/alpha/bridge',
+                    method: 'POST',
+                    filePath: '/app/services/test-service/src/modules/alpha/bridge.endpoint.ts',
+                    subdomain: 'alpha',
+                    linkedTo: ['AlphaAggregate', 'BetaAggregate'],
+                    exportName: 'BridgeEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            expect(manifest.merges.length).toBeGreaterThanOrEqual(1);
+            const merge = manifest.merges[0];
+            expect(merge.trigger).toBe('BridgeEndpoint');
+            expect(merge.mergedUnits).toHaveLength(2);
+            expect(merge.mergedUnits).toContain('alpha:AlphaAggregate');
+            expect(merge.mergedUnits).toContain('beta:BetaAggregate');
+            expect(merge.reason).toContain('alpha');
+            expect(merge.reason).toContain('beta');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 7. Undeclared policy -> build error
+    // -------------------------------------------------------------------------
+    describe('undeclared policy (no commandHandlerName, linkedTo, or isStandalone)', () => {
+        it('throws a validation error', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.policies['OrphanPolicy'] = {
+                route: '/orphan-policy',
+                events: ['SomeEvent'],
+                filePath: '/app/services/test-service/src/modules/misc/orphan.policy.ts',
+                subdomain: 'misc'
+            };
+            expect(() => (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT)).toThrow(/no dependency declaration/i);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 8. Deterministic output
+    // -------------------------------------------------------------------------
+    describe('deterministic output', () => {
+        it('produces identical JSON for the same input across multiple runs', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['ZetaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateZeta: { route: '/zeta', events: ['ZetaCreated'] } },
+                filePath: '/app/services/test-service/src/modules/zeta/zeta.aggregate.ts',
+                subdomain: 'zeta'
+            };
+            endpoints.aggregates['AlfaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateAlfa: { route: '/alfa', events: ['AlfaCreated'] } },
+                filePath: '/app/services/test-service/src/modules/alfa/alfa.aggregate.ts',
+                subdomain: 'alfa'
+            };
+            endpoints.policies['ZetaSyncPolicy'] = {
+                route: '/zeta-sync',
+                events: ['AlfaCreated'],
+                filePath: '/app/services/test-service/src/modules/zeta/zetaSync.policy.ts',
+                subdomain: 'zeta',
+                commandHandlerName: 'ZetaAggregate'
+            };
+            endpoints.projectors['AlfaReadmodel'] = {
+                route: '/alfa/:id?',
+                events: ['AlfaCreated'],
+                filePath: '/app/services/test-service/src/modules/alfa/alfa.readmodel.ts',
+                subdomain: 'alfa'
+            };
+            const result1 = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            const result2 = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            // Exclude generatedAt since it uses new Date()
+            const normalize = (m) => {
+                const { generatedAt, ...rest } = m;
+                return rest;
+            };
+            expect(JSON.stringify(normalize(result1))).toBe(JSON.stringify(normalize(result2)));
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Additional: manifest metadata
+    // -------------------------------------------------------------------------
+    describe('manifest metadata', () => {
+        it('includes version, service name, and generatedAt', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['SimpleAggregate'] = {
+                getEndpoints: {},
+                commands: {},
+                filePath: '/app/services/test-service/src/modules/simple/simple.aggregate.ts',
+                subdomain: 'simple'
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            expect(manifest.version).toBe('1.0');
+            expect(manifest.service).toBe(SERVICE_NAME);
+            expect(manifest.generatedAt).toBeDefined();
+            expect(typeof manifest.generatedAt).toBe('string');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 9. Module label is derived from the artifact's /modules/<name>/ path
+    // -------------------------------------------------------------------------
+    describe('module label derivation', () => {
+        it('labels an artifact that declares an empty subdomain by its module directory', () => {
+            const endpoints = emptyEndpoints();
+            // billing declares .withSubdomain('') on purpose (ADR-026) so its routes
+            // carry no x-subdomain and the gateway authorizes them through the admin
+            // path. The deployment unit must still be addressable as `billing:*`.
+            endpoints.aggregates['BillingAccounts'] = {
+                getEndpoints: {},
+                commands: { RegisterBillingAccount: { route: '/billing-accounts', events: ['BillingAccountRegistered'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/billing/billingAccounts/billingAccounts.aggregate.ts`,
+                subdomain: ''
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            expect(Object.keys(manifest.units)).toEqual(['billing:BillingAccounts']);
+            expect(manifest.units['billing:BillingAccounts'].module).toBe('billing');
+        });
+        it('derives the module for policies, readmodels and endpoints alike', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['Payments'] = {
+                getEndpoints: {},
+                commands: { CapturePayment: { route: '/payments', events: ['PaymentCaptured'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/billing/payments/payments.aggregate.ts`,
+                subdomain: ''
+            };
+            endpoints.policies['PaymentSettlement'] = {
+                route: '/payment-settlement',
+                events: ['PaymentCaptured'],
+                filePath: `${SERVICE_ROOT}/src/modules/billing/payments/paymentSettlement.policy.ts`,
+                subdomain: '',
+                commandHandlerName: 'Payments'
+            };
+            endpoints.projectors['PaymentsReadmodel'] = {
+                route: '/payments/:id?',
+                events: ['PaymentCaptured'],
+                filePath: `${SERVICE_ROOT}/src/modules/billing/payments/payments.readmodel.ts`,
+                subdomain: ''
+            };
+            const customEndpoints = [
+                {
+                    name: 'PaySubscriptionEndpoints',
+                    route: '/billing/pay-my-subscription',
+                    method: 'POST',
+                    filePath: `${SERVICE_ROOT}/src/modules/billing/payments/paySubscription.endpoints.ts`,
+                    subdomain: '',
+                    linkedTo: ['Payments'],
+                    exportName: 'PaySubscriptionEndpoints'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            expect(Object.keys(manifest.units).sort()).toEqual(['billing:Payments', 'billing:PaymentsReadmodel']);
+            expect(manifest.units['billing:Payments'].artifacts.map(a => a.name).sort()).toEqual(['PaySubscriptionEndpoints', 'PaymentSettlement', 'Payments'].sort());
+            // Same module directory on every node ⇒ nothing to record as a merge.
+            expect(manifest.merges).toEqual([]);
+        });
+        it('falls back to the declared subdomain when the file sits outside any module directory', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.projectors['PlatformStatsReadmodel'] = {
+                route: '/platform-stats/:id?',
+                events: ['StatsRecorded'],
+                filePath: `${SERVICE_ROOT}/src/shared/platformStats.readmodel.ts`,
+                subdomain: 'platform'
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            expect(Object.keys(manifest.units)).toEqual(['platform:PlatformStatsReadmodel']);
+            expect(manifest.units['platform:PlatformStatsReadmodel'].module).toBe('platform');
+        });
+        it('falls back to "unknown" when neither the path nor the subdomain names a module', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.projectors['OrphanReadmodel'] = {
+                route: '/orphan/:id?',
+                events: ['SomethingHappened'],
+                filePath: `${SERVICE_ROOT}/src/shared/orphan.readmodel.ts`,
+                subdomain: ''
+            };
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT);
+            expect(Object.keys(manifest.units)).toEqual(['unknown:OrphanReadmodel']);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Additional: policy referencing non-existent aggregate -> validation error
+    // -------------------------------------------------------------------------
+    describe('policy referencing non-existent command handler', () => {
+        it('throws a validation error', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.policies['BrokenPolicy'] = {
+                route: '/broken-policy',
+                events: ['SomeEvent'],
+                filePath: '/app/services/test-service/src/modules/misc/broken.policy.ts',
+                subdomain: 'misc',
+                commandHandlerName: 'NonExistentAggregate'
+            };
+            expect(() => (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT)).toThrow(/does not exist/i);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 10. Endpoint artifacts: one per declaring file, joined to their targets
+    // -------------------------------------------------------------------------
+    describe('endpoint artifacts', () => {
+        const itemsAndStock = () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['Items'] = {
+                getEndpoints: {},
+                commands: { RegisterItem: { route: '/items', events: ['ItemRegistered'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/items-publishing/items/items.aggregate.ts`,
+                subdomain: 'items-publishing'
+            };
+            endpoints.aggregates['WarehouseStockAvailability'] = {
+                getEndpoints: {},
+                commands: { SetStock: { route: '/stock', events: ['StockSet'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/stock-management/warehouseStockAvailability.aggregate.ts`,
+                subdomain: 'stock-management'
+            };
+            return endpoints;
+        };
+        it('places an endpoint with a multi-target linkedTo in the unit its targets merge into', () => {
+            const endpoints = itemsAndStock();
+            // The real shape of createItemWithStock.ts: one route that writes to two
+            // aggregates in two modules, so exactly one pod must own both.
+            const customEndpoints = [
+                {
+                    name: 'registerCreateItemWithStockEndpoint',
+                    route: '/items-publishing/items/create-with-stock',
+                    method: 'POST',
+                    filePath: `${SERVICE_ROOT}/src/modules/items-publishing/items/createItemWithStock.ts`,
+                    subdomain: 'items-publishing',
+                    linkedTo: ['ItemsAggregate', 'WarehouseStockAvailabilityAggregate']
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            // One merged unit, not two — the endpoint is the join.
+            expect(Object.keys(manifest.units)).toEqual(['items-publishing:Items']);
+            const unit = manifest.units['items-publishing:Items'];
+            const endpointArtifacts = unit.artifacts.filter(a => a.type === 'endpoint');
+            expect(endpointArtifacts).toHaveLength(1);
+            expect(endpointArtifacts[0].linkedTo).toEqual(['ItemsAggregate', 'WarehouseStockAvailabilityAggregate']);
+            expect(unit.artifacts.map(a => a.name)).toEqual(expect.arrayContaining(['Items', 'WarehouseStockAvailability']));
+        });
+        it('collapses every endpoint declared in one file into a single artifact', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.systems['SystemsIntegrationsInboundMessages'] = {
+                getEndpoints: {},
+                commands: { Receive: { route: '/inbound', events: ['MessageReceived'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/systems-integrations/inboundMessages.system.ts`,
+                subdomain: 'systems-integrations'
+            };
+            // The real shape of systemsIntegrations.endpoints.ts: the GET and the POST
+            // webhook are two registrations in one file, declared by one factory.
+            const filePath = `${SERVICE_ROOT}/src/modules/systems-integrations/systemsIntegrations.endpoints.ts`;
+            const customEndpoints = [
+                {
+                    name: 'Systems Integrations Webhooks (GET)',
+                    route: '/systems-integrations/webhooks',
+                    method: 'GET',
+                    filePath,
+                    subdomain: 'systems-integrations',
+                    linkedTo: ['SystemsIntegrationsInboundMessagesSystem']
+                },
+                {
+                    name: 'Systems Integrations Webhooks (POST)',
+                    route: '/systems-integrations/webhooks',
+                    method: 'POST',
+                    filePath,
+                    subdomain: 'systems-integrations',
+                    linkedTo: ['SystemsIntegrationsInboundMessagesSystem']
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            const unit = manifest.units['systems-integrations:SystemsIntegrationsInboundMessages'];
+            const endpointArtifacts = unit.artifacts.filter(a => a.type === 'endpoint');
+            // One file, one artifact — otherwise the loader requires the same file
+            // once per route and re-runs every registration in it.
+            expect(endpointArtifacts).toHaveLength(1);
+            expect(endpointArtifacts[0].filePath).toBe('src/modules/systems-integrations/systemsIntegrations.endpoints.ts');
+            expect(endpointArtifacts[0].linkedTo).toEqual(['SystemsIntegrationsInboundMessagesSystem']);
+        });
+        it('lists every route the declaring file registers, sorted', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.systems['SystemsIntegrationsInboundMessages'] = {
+                getEndpoints: {},
+                commands: { Receive: { route: '/inbound', events: ['MessageReceived'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/systems-integrations/inboundMessages.system.ts`,
+                subdomain: 'systems-integrations'
+            };
+            // Declared POST-first on purpose: `.deployment-units.json` is committed and
+            // drift-watched, so a list that follows declaration order reorders the moment
+            // someone moves a registration and dirties the tree for nothing.
+            const filePath = `${SERVICE_ROOT}/src/modules/systems-integrations/systemsIntegrations.endpoints.ts`;
+            const customEndpoints = [
+                {
+                    name: 'Systems Integrations Webhook',
+                    route: '/systems-integrations/:connectorId/webhook',
+                    method: 'POST',
+                    filePath,
+                    subdomain: 'systems-integrations',
+                    linkedTo: ['SystemsIntegrationsInboundMessagesSystem']
+                },
+                {
+                    name: 'Systems Integrations Accessible Channels',
+                    route: '/systems-integrations-accessible-channels',
+                    method: 'GET',
+                    filePath,
+                    subdomain: 'systems-integrations',
+                    linkedTo: ['SystemsIntegrationsInboundMessagesSystem']
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            const unit = manifest.units['systems-integrations:SystemsIntegrationsInboundMessages'];
+            const [endpointArtifact] = unit.artifacts.filter(a => a.type === 'endpoint');
+            // One file is one artifact, so the one artifact carries BOTH registrars'
+            // routes — that is exactly what a pod lifting this unit brings up.
+            expect(endpointArtifact.routes).toEqual([
+                'GET /systems-integrations-accessible-channels',
+                'POST /systems-integrations/:connectorId/webhook'
+            ]);
+        });
+        it('lists a route registered under an optional path parameter once, per method', () => {
+            const endpoints = itemsAndStock();
+            const filePath = `${SERVICE_ROOT}/src/modules/items-publishing/items/itemDrafts.endpoints.ts`;
+            const declaredIn = {
+                filePath,
+                subdomain: 'items-publishing',
+                linkedTo: ['ItemsAggregate']
+            };
+            // `registerEndpoint` stores `/x/:id?` under TWO keys (`/x/:id` and `/x`), so a
+            // caller reading the route table hands the same route in twice — the first two
+            // rows. The POST is the negative control: a same-path sibling on another verb
+            // is a DIFFERENT route and must survive the dedup.
+            //
+            // The method-less row carries a route NO OTHER ROW DECLARES, so the only way
+            // `GET /items-publishing/item-drafts-legacy` can appear is the key's GET
+            // default. That default is the one component of the join key that can diverge
+            // from teselly's `checkManifestCoverage.routeId` with no other symptom, so it
+            // needs a row it alone can produce: sharing a path with an explicit verb makes
+            // the row inert, since any other default just collapses it into that sibling.
+            const customEndpoints = [
+                { name: 'Item Drafts', route: '/items-publishing/item-drafts/:id?', method: 'GET', ...declaredIn },
+                { name: 'Item Drafts', route: '/items-publishing/item-drafts/:id?', method: 'GET', ...declaredIn },
+                { name: 'Save Item Draft', route: '/items-publishing/item-drafts/:id?', method: 'POST', ...declaredIn },
+                { name: 'Item Drafts Legacy', route: '/items-publishing/item-drafts-legacy', ...declaredIn }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            const [endpointArtifact] = manifest.units['items-publishing:Items'].artifacts
+                .filter(a => a.type === 'endpoint');
+            expect(endpointArtifact.routes).toEqual([
+                'GET /items-publishing/item-drafts-legacy',
+                'GET /items-publishing/item-drafts/:id?',
+                'POST /items-publishing/item-drafts/:id?'
+            ]);
+        });
+        it('throws when one file\'s endpoints resolve to different deployment units', () => {
+            const endpoints = itemsAndStock();
+            // Two unrelated routes sharing a file. Grouping them would silently merge
+            // two units that nothing in the domain says belong together — the file
+            // has to be split instead.
+            const filePath = `${SERVICE_ROOT}/src/modules/items-publishing/items/mixed.endpoints.ts`;
+            const customEndpoints = [
+                {
+                    name: 'Item Conflict Resolution',
+                    route: '/items-publishing/items/resolve-conflict',
+                    method: 'POST',
+                    filePath,
+                    subdomain: 'items-publishing',
+                    linkedTo: ['ItemsAggregate']
+                },
+                {
+                    name: 'Stock Recount',
+                    route: '/stock-management/recount',
+                    method: 'POST',
+                    filePath,
+                    subdomain: 'items-publishing',
+                    linkedTo: ['WarehouseStockAvailabilityAggregate']
+                }
+            ];
+            expect(() => (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints)).toThrow(/resolve to different deployment units/i);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 11. Undeclared endpoints: one `<module>:Endpoints` unit per module
+    // -------------------------------------------------------------------------
+    describe('undeclared endpoints', () => {
+        const declaredIn = (filePath) => ({ filePath, subdomain: 'systems-integrations' });
+        const inboundMessagesSystem = () => {
+            const endpoints = emptyEndpoints();
+            endpoints.systems['SystemsIntegrationsInboundMessages'] = {
+                getEndpoints: {},
+                commands: { Receive: { route: '/inbound', events: ['MessageReceived'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/systems-integrations/inboundMessages.system.ts`,
+                subdomain: 'systems-integrations'
+            };
+            return endpoints;
+        };
+        it('joins every undeclared file in a module into one <module>:Endpoints unit', () => {
+            const endpoints = inboundMessagesSystem();
+            // Three files, no `linkedTo` anywhere: none of them names an aggregate it
+            // has to sit with, and none of them should have to invent one.
+            const customEndpoints = [
+                {
+                    name: 'registerErpStockImportEndpoints',
+                    route: '/systems-integrations/erp/stock-import',
+                    method: 'POST',
+                    exportName: 'registerErpStockImportEndpoints',
+                    ...declaredIn(`${SERVICE_ROOT}/src/modules/systems-integrations/erpStockImport.endpoints.ts`)
+                },
+                {
+                    name: 'registerErpPriceImportEndpoints',
+                    route: '/systems-integrations/erp/price-import',
+                    method: 'POST',
+                    exportName: 'registerErpPriceImportEndpoints',
+                    ...declaredIn(`${SERVICE_ROOT}/src/modules/systems-integrations/erpPriceImport.endpoints.ts`)
+                },
+                {
+                    name: 'registerChannelImportPreviewEndpoints',
+                    route: '/systems-integrations/channel-import-preview',
+                    method: 'GET',
+                    exportName: 'registerChannelImportPreviewEndpoints',
+                    ...declaredIn(`${SERVICE_ROOT}/src/modules/systems-integrations/channelImportPreview.endpoints.ts`)
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            // The id is `<module>:Endpoints` — hand-written into topology-intent.yaml
+            // and unchanged when any of the three files is renamed. Deriving it from
+            // the first endpoint's name would make a rename rewrite a persisted
+            // deployment identifier.
+            expect(Object.keys(manifest.units).sort()).toEqual([
+                'systems-integrations:Endpoints',
+                'systems-integrations:SystemsIntegrationsInboundMessages'
+            ]);
+            const unit = manifest.units['systems-integrations:Endpoints'];
+            expect(unit.module).toBe('systems-integrations');
+            expect(unit.artifacts.map(a => a.filePath).sort()).toEqual([
+                'src/modules/systems-integrations/channelImportPreview.endpoints.ts',
+                'src/modules/systems-integrations/erpPriceImport.endpoints.ts',
+                'src/modules/systems-integrations/erpStockImport.endpoints.ts'
+            ]);
+            expect(unit.artifacts.every(a => a.type === 'endpoint')).toBe(true);
+            // One artifact per FILE, not per route: the loader requires each file once
+            // and runs its factory once, however many routes it registers.
+            expect(unit.artifacts.map(a => a.routes)).toEqual([
+                ['GET /systems-integrations/channel-import-preview'],
+                ['POST /systems-integrations/erp/price-import'],
+                ['POST /systems-integrations/erp/stock-import']
+            ]);
+        });
+        it('places a file that declares linkedTo anywhere wholly in its linked unit', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['Items'] = {
+                getEndpoints: {},
+                commands: { RegisterItem: { route: '/items', events: ['ItemRegistered'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/items-publishing/items/items.aggregate.ts`,
+                subdomain: 'items-publishing'
+            };
+            const mixedFile = `${SERVICE_ROOT}/src/modules/items-publishing/items/itemMerge.endpoints.ts`;
+            const undeclaredFile = `${SERVICE_ROOT}/src/modules/items-publishing/items/generateSku.ts`;
+            const customEndpoints = [
+                {
+                    name: 'Merge Items',
+                    route: '/items-publishing/items/merge',
+                    method: 'POST',
+                    filePath: mixedFile,
+                    subdomain: 'items-publishing',
+                    linkedTo: ['ItemsAggregate'],
+                    exportName: 'registerItemMergeEndpoints'
+                },
+                {
+                    // Same file, no declaration of its own. A file in two units means two
+                    // pods requiring it and both registering all of its routes.
+                    name: 'Merge Preview',
+                    route: '/items-publishing/items/merge-preview',
+                    method: 'GET',
+                    filePath: mixedFile,
+                    subdomain: 'items-publishing',
+                    exportName: 'registerItemMergeEndpoints'
+                },
+                {
+                    name: 'Generate Sku',
+                    route: '/items-publishing/items/generate-sku',
+                    method: 'POST',
+                    filePath: undeclaredFile,
+                    subdomain: 'items-publishing',
+                    exportName: 'registerGenerateSkuEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            const linkedUnit = manifest.units['items-publishing:Items'];
+            const [mergeArtifact] = linkedUnit.artifacts.filter(a => a.type === 'endpoint');
+            expect(linkedUnit.artifacts.filter(a => a.type === 'endpoint')).toHaveLength(1);
+            expect(mergeArtifact.filePath).toBe('src/modules/items-publishing/items/itemMerge.endpoints.ts');
+            // The undeclared sibling rides along — one file, one artifact, and the
+            // pod that requires it brings up both routes.
+            expect(mergeArtifact.routes).toEqual([
+                'GET /items-publishing/items/merge-preview',
+                'POST /items-publishing/items/merge'
+            ]);
+            // ...and it is NOT also in the Endpoints unit.
+            expect(manifest.units['items-publishing:Endpoints'].artifacts.map(a => a.filePath)).toEqual([
+                'src/modules/items-publishing/items/generateSku.ts'
+            ]);
+        });
+        it('gives a module with nothing but endpoints its own unit', () => {
+            const endpoints = emptyEndpoints();
+            // dev-utils is the live case: endpoint files and no aggregate, readmodel
+            // or policy at all. Without a unit its routes exist in the monolith and
+            // in no lifted pod — which is the whole defect this design closes.
+            const customEndpoints = [
+                {
+                    name: 'registerEchoAuthHeadersEndpoint',
+                    route: '/dev-utils/echo-auth-headers',
+                    method: 'GET',
+                    filePath: `${SERVICE_ROOT}/src/modules/dev-utils/echo-auth-headers.endpoint.ts`,
+                    exportName: 'registerEchoAuthHeadersEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            expect(Object.keys(manifest.units)).toEqual(['dev-utils:Endpoints']);
+            // Not `readmodel`: nothing here projects an event, and teselly's topology
+            // generator reads this label to decide what a module wildcard expands to.
+            expect(manifest.units['dev-utils:Endpoints'].type).toBe('command-group');
+            expect(manifest.units['dev-utils:Endpoints'].consumes).toBeUndefined();
+        });
+        it('never pulls an Endpoints unit into a cross-module merge', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['AlphaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateAlpha: { route: '/alpha', events: ['AlphaCreated'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/alpha/alpha.aggregate.ts`,
+                subdomain: 'alpha'
+            };
+            endpoints.aggregates['BetaAggregate'] = {
+                getEndpoints: {},
+                commands: { CreateBeta: { route: '/beta', events: ['BetaCreated'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/beta/beta.aggregate.ts`,
+                subdomain: 'beta'
+            };
+            const customEndpoints = [
+                {
+                    name: 'BridgeEndpoint',
+                    route: '/alpha/bridge',
+                    method: 'POST',
+                    filePath: `${SERVICE_ROOT}/src/modules/alpha/bridge.endpoint.ts`,
+                    subdomain: 'alpha',
+                    linkedTo: ['AlphaAggregate', 'BetaAggregate'],
+                    exportName: 'BridgeEndpoint'
+                },
+                {
+                    // Same module as the merge trigger, and declares nothing. Being in
+                    // the module a merge passes through must not drag it in.
+                    name: 'AlphaStatusEndpoint',
+                    route: '/alpha/status',
+                    method: 'GET',
+                    filePath: `${SERVICE_ROOT}/src/modules/alpha/alphaStatus.endpoints.ts`,
+                    subdomain: 'alpha',
+                    exportName: 'registerAlphaStatusEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            expect(Object.keys(manifest.units).sort()).toEqual(['alpha:AlphaAggregate', 'alpha:Endpoints']);
+            // Named after the function that registered it, not the route or the file.
+            expect(manifest.units['alpha:Endpoints'].artifacts.map(a => a.name)).toEqual(['registerAlphaStatusEndpoint']);
+            expect(manifest.merges).toHaveLength(1);
+            expect(manifest.merges[0].mergedUnits).toEqual(['alpha:AlphaAggregate', 'beta:BetaAggregate']);
+            expect(manifest.merges[0].resultUnit).toBe('alpha:AlphaAggregate');
+        });
+        it('attaches routes to the artifact that already owns the file, rather than emitting a second one', () => {
+            const endpoints = emptyEndpoints();
+            // The live shape of `feature-flags/featureFlags.readmodel.ts` (and three
+            // more): a projector file that ALSO registers manual routes, declaring
+            // nothing. A second artifact for the same file would put that file in two
+            // units — two pods requiring it, both running the same factory, both
+            // registering `/public-flags`. Two pods serving one route.
+            const readmodelFile = `${SERVICE_ROOT}/src/modules/feature-flags/featureFlags.readmodel.ts`;
+            endpoints.projectors['FeatureFlagsReadmodel'] = {
+                route: '/feature-flags/:id?',
+                events: ['FeatureFlagSet'],
+                filePath: readmodelFile,
+                subdomain: 'feature-flags'
+            };
+            // The registrations sit at the top level of the exported factory, so V8
+            // names the frame after the factory — the endpoint's exportName is the
+            // readmodel's own export, which is why a second artifact would collide on
+            // name AND exportName AND filePath and still not be deduplicated across
+            // two pods.
+            const declaredIn = {
+                filePath: readmodelFile,
+                subdomain: 'feature-flags',
+                exportName: 'FeatureFlagsReadmodel'
+            };
+            const customEndpoints = [
+                { name: 'FeatureFlagsReadmodel', route: '/public-flags', method: 'GET', ...declaredIn },
+                { name: 'FeatureFlagsReadmodel', route: '/feature-flags-by-key', method: 'GET', ...declaredIn },
+                // A genuine endpoint-only file in the same module: absorbing the
+                // readmodel's routes must not also swallow this one.
+                {
+                    name: 'registerFeatureFlagSeedEndpoint',
+                    route: '/feature-flags/seed',
+                    method: 'POST',
+                    filePath: `${SERVICE_ROOT}/src/modules/feature-flags/featureFlagSeed.ts`,
+                    subdomain: 'feature-flags',
+                    exportName: 'registerFeatureFlagSeedEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            expect(Object.keys(manifest.units).sort()).toEqual([
+                'feature-flags:Endpoints',
+                'feature-flags:FeatureFlagsReadmodel'
+            ]);
+            // EXACTLY ONE unit claims the file. This is the assertion the whole case
+            // exists for: a second claimant is a second pod requiring the same file
+            // and re-registering every route in it.
+            const claimants = Object.entries(manifest.units).filter(([, unit]) => unit.artifacts.some(a => a.filePath === 'src/modules/feature-flags/featureFlags.readmodel.ts'));
+            expect(claimants.map(([key]) => key)).toEqual(['feature-flags:FeatureFlagsReadmodel']);
+            // One file, one artifact — the readmodel's own, now carrying the routes it
+            // registers so a route -> unit lookup still finds them.
+            const readmodelUnit = manifest.units['feature-flags:FeatureFlagsReadmodel'];
+            expect(readmodelUnit.artifacts).toHaveLength(1);
+            expect(readmodelUnit.artifacts[0].type).toBe('readmodel');
+            expect(readmodelUnit.artifacts[0].routes).toEqual([
+                'GET /feature-flags-by-key',
+                'GET /public-flags'
+            ]);
+            // Still a plain readmodel unit: one artifact, of type readmodel.
+            expect(readmodelUnit.type).toBe('readmodel');
+            // The endpoint-only file keeps its own unit.
+            expect(manifest.units['feature-flags:Endpoints'].artifacts.map(a => a.filePath)).toEqual([
+                'src/modules/feature-flags/featureFlagSeed.ts'
+            ]);
+        });
+        it('leaves an endpoint artifact unnameable by another artifact\'s linkedTo', () => {
+            const endpoints = inboundMessagesSystem();
+            // The command-handler lookup indexes aggregates and external systems.
+            // Nothing else may join an Endpoints group, so nothing else may name one
+            // — widening that lookup (readmodels are next) must not reach endpoints.
+            endpoints.policies['ErpImportRetryPolicy'] = {
+                route: '/erp-import-retry-policy',
+                events: ['ErpImportFailed'],
+                filePath: `${SERVICE_ROOT}/src/modules/systems-integrations/erpImportRetry.policy.ts`,
+                subdomain: 'systems-integrations',
+                linkedTo: ['registerErpStockImportEndpoints']
+            };
+            const customEndpoints = [
+                {
+                    name: 'registerErpStockImportEndpoints',
+                    route: '/systems-integrations/erp/stock-import',
+                    method: 'POST',
+                    exportName: 'registerErpStockImportEndpoints',
+                    ...declaredIn(`${SERVICE_ROOT}/src/modules/systems-integrations/erpStockImport.endpoints.ts`)
+                }
+            ];
+            expect(() => (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints)).toThrow(/linkedTo "registerErpStockImportEndpoints" which does not exist/i);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 12. An endpoint pinned to a query pod
+    // -------------------------------------------------------------------------
+    describe('endpoint linked to a readmodel', () => {
+        const warehousesReadmodel = () => {
+            const endpoints = emptyEndpoints();
+            endpoints.projectors['WarehousesReadmodel'] = {
+                route: '/stock-management/warehouses/:id?',
+                events: ['WarehouseCreated', 'WarehouseEdited'],
+                filePath: `${SERVICE_ROOT}/src/modules/stock-management/warehouses.readmodel.ts`,
+                subdomain: 'stock-management'
+            };
+            return endpoints;
+        };
+        // The registrar is named so it sorts BEFORE the readmodel
+        // (`registerStockReportEndpoint` < `WarehousesReadmodel` under
+        // `localeCompare`), which is what the `register*` convention produces for
+        // most readmodel names. The unit key is therefore the readmodel's only
+        // because a readmodel is chosen as the component's primary — with the
+        // alphabetical fallthrough the same fixture keys the unit
+        // `stock-management:registerStockReportEndpoint`, and `--lift
+        // 'stock-management:WarehousesReadmodel'` no longer names the pod its own
+        // readmodel is in.
+        const stockReportEndpoint = (linkedTo) => ({
+            name: 'Stock Report',
+            route: '/stock-management/stock-report',
+            method: 'GET',
+            filePath: `${SERVICE_ROOT}/src/modules/stock-management/stockReport.endpoints.ts`,
+            subdomain: 'stock-management',
+            linkedTo,
+            exportName: 'registerStockReportEndpoint'
+        });
+        it('places the endpoint in that readmodel\'s unit, not its module\'s Endpoints unit', () => {
+            const endpoints = warehousesReadmodel();
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, [stockReportEndpoint(['WarehousesReadmodel'])]);
+            // ONE unit. A second (`stock-management:Endpoints`) means the pin did
+            // nothing and the route rides its module's block after all — the wall
+            // this escape hatch exists to open.
+            expect(Object.keys(manifest.units)).toEqual(['stock-management:WarehousesReadmodel']);
+            const unit = manifest.units['stock-management:WarehousesReadmodel'];
+            expect(unit.type).toBe('readmodel');
+            expect(unit.module).toBe('stock-management');
+            expect(unit.artifacts.map(a => `${a.type}:${a.name}`)).toEqual([
+                'endpoint:registerStockReportEndpoint',
+                'readmodel:WarehousesReadmodel'
+            ]);
+            const [endpointArtifact] = unit.artifacts.filter(a => a.type === 'endpoint');
+            expect(endpointArtifact.linkedTo).toEqual(['WarehousesReadmodel']);
+            expect(endpointArtifact.routes).toEqual(['GET /stock-management/stock-report']);
+            // The pod is still the projector's: it subscribes to exactly what the
+            // readmodel did before an endpoint joined it.
+            expect(unit.consumes).toEqual(['WarehouseCreated', 'WarehouseEdited']);
+        });
+        it('still refuses the same name from a POLICY, with the same error', () => {
+            const endpoints = warehousesReadmodel();
+            // Same readmodel, same manifest, two declarers, opposite outcomes. A
+            // policy's `linkedTo` asserts "I dispatch commands here" — a readmodel
+            // cannot receive a command — so widening the ENDPOINT lookup must leave
+            // this one narrow. The endpoint beside it resolves, which is what rules
+            // out an implementation that widens by teaching the shared command-handler
+            // lookup about readmodels the first time an endpoint names one.
+            endpoints.policies['WarehouseRebalancePolicy'] = {
+                route: '/warehouse-rebalance-policy',
+                events: ['StockMoved'],
+                filePath: `${SERVICE_ROOT}/src/modules/stock-management/warehouseRebalance.policy.ts`,
+                subdomain: 'stock-management',
+                linkedTo: ['WarehousesReadmodel']
+            };
+            expect(() => (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, [stockReportEndpoint(['WarehousesReadmodel'])])).toThrow(/Policy "WarehouseRebalancePolicy" has linkedTo "WarehousesReadmodel" which does not exist in registeredEndpoints/);
+        });
+        it('stops at readmodels — an endpoint still cannot name another endpoint', () => {
+            const endpoints = warehousesReadmodel();
+            // The sibling control one describe up pins that a POLICY cannot name an
+            // endpoint, and it catches a widening made in the shared command-handler
+            // lookup. It does NOT catch one made in the endpoint resolver, which is
+            // the lookup this slice touched — so the same absence needs pinning from
+            // the endpoint side too. An Endpoints group is a module's block of
+            // unowned routes; a route that could name one would drag that whole block
+            // into someone else's unit.
+            const customEndpoints = [
+                stockReportEndpoint(['WarehousesReadmodel']),
+                {
+                    name: 'Stock Report Export',
+                    route: '/stock-management/stock-report/export',
+                    method: 'GET',
+                    filePath: `${SERVICE_ROOT}/src/modules/stock-management/stockReportExport.endpoints.ts`,
+                    subdomain: 'stock-management',
+                    linkedTo: ['registerStockReportEndpoint'],
+                    exportName: 'registerStockReportExportEndpoint'
+                }
+            ];
+            expect(() => (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints)).toThrow(/Endpoint "Stock Report Export" has linkedTo "registerStockReportEndpoint" which does not exist in registeredEndpoints/);
+        });
+        it('names the endpoint that reached across modules for a readmodel in the merge record', () => {
+            const endpoints = emptyEndpoints();
+            endpoints.aggregates['Items'] = {
+                getEndpoints: {},
+                commands: { RegisterItem: { route: '/items', events: ['ItemRegistered'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/items-publishing/items/items.aggregate.ts`,
+                subdomain: 'items-publishing'
+            };
+            endpoints.aggregates['WarehouseStockAvailability'] = {
+                getEndpoints: {},
+                commands: { SetStock: { route: '/stock', events: ['StockSet'] } },
+                filePath: `${SERVICE_ROOT}/src/modules/stock-management/warehouseStockAvailability.aggregate.ts`,
+                subdomain: 'stock-management'
+            };
+            endpoints.projectors['WarehousesReadmodel'] = {
+                route: '/stock-management/warehouses/:id?',
+                events: ['WarehouseCreated'],
+                filePath: `${SERVICE_ROOT}/src/modules/stock-management/warehouses.readmodel.ts`,
+                subdomain: 'stock-management'
+            };
+            // Two aggregates in two modules, merged only THROUGH the readmodel both
+            // endpoints name. The items-publishing one is the sole cross-module
+            // reacher, and its only cross-module reference is the readmodel — so a
+            // merge-record trigger resolved with the narrow command-handler lookup
+            // reads `unknown` and blames nobody for a merge that has an author.
+            const customEndpoints = [
+                {
+                    name: 'Item Stock Summary',
+                    route: '/items-publishing/items/stock-summary',
+                    method: 'GET',
+                    filePath: `${SERVICE_ROOT}/src/modules/items-publishing/items/itemStockSummary.endpoints.ts`,
+                    subdomain: 'items-publishing',
+                    linkedTo: ['ItemsAggregate', 'WarehousesReadmodel'],
+                    exportName: 'registerItemStockSummaryEndpoint'
+                },
+                {
+                    name: 'Warehouse Report',
+                    route: '/stock-management/warehouse-report',
+                    method: 'GET',
+                    filePath: `${SERVICE_ROOT}/src/modules/stock-management/warehouseReport.endpoints.ts`,
+                    subdomain: 'stock-management',
+                    linkedTo: ['WarehouseStockAvailabilityAggregate', 'WarehousesReadmodel'],
+                    exportName: 'registerWarehouseReportEndpoint'
+                }
+            ];
+            const manifest = (0, computeMDUs_1.computeMDUs)(endpoints, SERVICE_NAME, SERVICE_ROOT, customEndpoints);
+            expect(Object.keys(manifest.units)).toEqual(['items-publishing:Items']);
+            expect(manifest.merges).toHaveLength(1);
+            expect(manifest.merges[0].mergedUnits).toEqual([
+                'items-publishing:Items',
+                'stock-management:WarehouseStockAvailability'
+            ]);
+            expect(manifest.merges[0].trigger).toBe('registerItemStockSummaryEndpoint');
+            expect(manifest.merges[0].reason).toBe('endpoint "registerItemStockSummaryEndpoint" links to aggregates in modules: items-publishing, stock-management');
+        });
+    });
+});
+//# sourceMappingURL=computeMDUs.test.js.map