@endora-commerce/mod-delivery-methods 0.100.0

package/dist/backend/services/delivery-method-reconciler.js

@@ -0,0 +1,157 @@
+import { SalesChannel } from '@endora-commerce/platform/kernel';
+import { DeliveryMethod } from '../entities/delivery-method.entity.js';
+/**
+ * DeliveryMethodReconciler (feature 035, FR-002) — the implementation behind
+ * `DeliveryMethodSeedApi`, this module's published install surface
+ * (`../../ports/index.ts`, `createDeliveryMethodSeeder` below).
+ *
+ * A module that must create its `delivery_methods` row from code calls
+ * `ensureMethodForAdapter` from its **install hook**, so installing a
+ * shipping-method module surfaces a configurable entry at `/delivery-methods`
+ * with no core change. Idempotent and prune-safe: an existing row (matched by
+ * `code`) keeps its admin-edited configuration; the reconciler only fills a
+ * missing `adapter` link.
+ *
+ * The row and the adapter are contributed at **different moments, on purpose**.
+ * This row is durable state and is written once, at install; the adapter is an
+ * in-memory entry in a per-process table and is pushed from the contributing
+ * module's boot hook, on every composition (see `shipping-adapter-registry.ts`).
+ * Neither waits for the other: a row whose `adapter` key nothing has contributed
+ * is simply not offered, and the registry is not read until a request reads it.
+ *
+ * **The `EntityManager` is a parameter of every method and is never held**
+ * (feature 134, FR-064; D-169). It used to be a constructor `emFactory`, which is
+ * the shape of a service resolved from a container — and the caller this class
+ * was written for has no container: `ModuleLifecycleContext` is
+ * `{ em, redis, log, module }` and `module:install` composes nothing (D-46). The
+ * hook's own `ctx.em` is therefore what every statement here runs on, handed in
+ * at the call, so the write lands in the transaction the orchestrator will
+ * commit or revert rather than on a fork of it.
+ *
+ * **It no longer rebinds sales-channel membership (issue #96)** — see the
+ * payment twin (`payment_methods/services/payment-method-reconciler.ts`).
+ * `bindToDefaultChannel` exists, and is the seed's own *once, for the rows it
+ * creates* half rather than a reconcile: the caller guards it on
+ * `created === true`. What issue #96 removed was the unconditional call, which
+ * brought a method an operator had deliberately unbound from every channel back
+ * to Default at the next boot, and nothing said so. "Unbound" is a state an
+ * operator is entitled to reach and to keep.
+ */
+export class DeliveryMethodReconciler {
+    async ensureMethodForAdapter(em, adapterKey, defaults) {
+        // command-coverage-ignore: idempotent reconciliation of adapter-backed delivery
+        // methods — a system-invariant repair, not an operator-initiated write.
+        const existing = await em.findOne(DeliveryMethod, { code: defaults.code });
+        if (existing) {
+            // Prune-safe: never clobber admin configuration. Only backfill a missing
+            // adapter link (e.g. a legacy row predating this feature).
+            if (!existing.adapter) {
+                existing.adapter = adapterKey;
+                await em.persistAndFlush(existing);
+            }
+            return { row: recordOf(existing), created: false };
+        }
+        const row = em.create(DeliveryMethod, {
+            code: defaults.code,
+            name: defaults.name,
+            adapter: adapterKey,
+            cost: defaults.cost ?? '0',
+            currency: defaults.currency ?? 'PLN',
+            status: defaults.status ?? 'active',
+            statusOnSuccess: defaults.statusOnSuccess ?? 'shipment_sent',
+            statusOnFailure: defaults.statusOnFailure ?? 'processing',
+        });
+        await em.persistAndFlush(row);
+        return { row: recordOf(row), created: true };
+    }
+    /**
+     * The seed's channel binding — one membership row in the system-default
+     * channel, written against **this module's own** bridge table.
+     *
+     * Not through `SalesChannelMembershipService`, and the reason is structural
+     * rather than a preference: that service needs the `EventBus`, the audit port
+     * and the channel-bridge registry, and the registry is contributed from a boot
+     * hook. An install composes nothing, so at this seam it holds no registration
+     * for `'delivery-method'` and `bridges.require` would refuse (FR-017) before
+     * the database was touched. `sales_channel_delivery_methods` is this module's
+     * since `specs/120-migration-closure-bridge-ownership/` Phase 2 (D-226), so the
+     * statement is the owner's own and crosses no boundary — which is what FR-064
+     * buys by putting the writer here instead of in the seeding module.
+     *
+     * The channel itself is read through the kernel's own `SalesChannel` entity
+     * rather than in SQL — `api_keys` reads it the same way — because a raw
+     * `select … from "sales_channels"` from a module is a `check:module-boundary`
+     * finding against a kernel-owned table, and correctly so: the table is not
+     * this module's and the entity is the platform's published name for it.
+     *
+     * `em.execute` for the insert rather than `em.getConnection().execute`, so the
+     * statement runs inside the caller's transaction (issue #200). The bridge has
+     * no entity class — the kernel's membership service writes it in SQL too.
+     *
+     * **No system-default channel answers `false` rather than raising, and that is
+     * measured rather than defensive.** The default channel is created by
+     * `DefaultChannelReconciler` at **boot**, from `composeApp` — not by a migration
+     * and not by an install — and `module:install` composes nothing (D-46). So a
+     * database that has been migrated and never booted has no default channel, and
+     * a seeding module installed there is the ordinary case, not a broken instance:
+     * `pnpm --filter backend run db:fresh && module:install dhl_parcel` is exactly
+     * it. The seed migration this replaced degraded the same way, silently — its
+     * `cross join "sales_channels" where "system_default"` produced no rows and
+     * inserted no membership — so answering `false` is what keeps a fresh install
+     * and an upgraded one at the same row state in that state too. Raising instead
+     * **aborts the install**, and the hook is not inside a database transaction:
+     * measured on a throwaway database, the first of two rows stayed and the second
+     * never arrived.
+     */
+    async bindToDefaultChannel(em, deliveryMethodId) {
+        // command-coverage-ignore: install-time seed membership for a row this seam
+        // just created — a system-invariant write with no request and no actor.
+        const defaultChannel = await em.findOne(SalesChannel, { systemDefault: true });
+        if (!defaultChannel)
+            return false;
+        const inserted = await em.execute('insert into "sales_channel_delivery_methods" ("sales_channel_id", "delivery_method_id") ' +
+            'values (?, ?) on conflict ("sales_channel_id", "delivery_method_id") do nothing ' +
+            'returning "delivery_method_id"', [defaultChannel.id, deliveryMethodId]);
+        return inserted.length > 0;
+    }
+    /**
+     * The hard-uninstall half. Channel memberships go with the row: the bridge's
+     * foreign key onto `delivery_methods` is `on delete cascade`.
+     */
+    async removeMethodForAdapter(em, code) {
+        // command-coverage-ignore: hard-uninstall removal of an adapter-backed
+        // delivery method — no request, no actor and nothing to attribute an audit
+        // entry to; the operator path is `commands/delivery-method.commands.ts`.
+        const removed = await em.nativeDelete(DeliveryMethod, { code });
+        return removed > 0;
+    }
+}
+/**
+ * The published record, mapped field by field rather than by handing the entity
+ * back (D-168/D-77): a caller reads values off it and cannot persist through it.
+ */
+function recordOf(row) {
+    return {
+        id: row.id,
+        code: row.code,
+        name: row.name,
+        cost: row.cost,
+        currency: row.currency,
+        status: row.status,
+        adapter: row.adapter,
+        statusOnSuccess: row.statusOnSuccess,
+        statusOnFailure: row.statusOnFailure,
+    };
+}
+/**
+ * The runtime half of this module's install surface (feature 134, FR-064).
+ *
+ * A seeding module's `installHook` writes `createDeliveryMethodSeeder()` and
+ * hands `ctx.em` to each call. The factory takes no arguments because the `em`
+ * belongs to the call and not to the seeder: one `em`, named at every statement,
+ * with no second source of truth for which transaction the write lands in.
+ */
+export function createDeliveryMethodSeeder() {
+    return new DeliveryMethodReconciler();
+}
+//# sourceMappingURL=delivery-method-reconciler.js.map

package/dist/backend/services/delivery-method-reconciler.js.map

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

package/dist/backend/services/order-status-registry.port.d.ts

@@ -0,0 +1,50 @@
+import { type OrderStatusOption, type OrderStatusRegistry } from '@endora-commerce/contracts';
+/**
+ * OrderStatusRegistry port (feature 035 — research.md R3).
+ *
+ * `statusOnSuccess` / `statusOnFailure` on a delivery method reference *Order
+ * Statuses*. Those will eventually be an admin-configurable registry owned by
+ * the Orders module; until then this port is backed by the current hard-coded
+ * order `status` enum. Consumers (admin upsert validation, receive-shipment
+ * handler) depend only on this interface, so the future configurable registry
+ * drops in with no change to `delivery_methods`.
+ *
+ * Deliberately a small, isolated duplicate of the payment_methods port rather
+ * than a deep import across modules (constitution Principle I). The port does
+ * NOT touch the Order entity — applying a status is the caller's job.
+ *
+ * The interface moved to `@endora-commerce/contracts` in feature 075's Phase P. It was
+ * declared twice — once here and once in `payment_methods`, in the same words
+ * — because both modules map an outcome onto an order status; one declaration
+ * is what stops the two drifting. Re-exported here for the length of Phase P,
+ * which cuts no consumer.
+ */
+export type { OrderStatusRegistry };
+export declare class OrderStatusRegistryError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/**
+ * Default enum-backed implementation. Seed set = the order `status` enum.
+ *
+ * **The absent-owner policy this registry states (issue #129): honour — and the
+ * reason is that there is nothing to skip.** The delivery twin of
+ * `payment_methods/services/order-status-registry.port.ts`, and the argument is
+ * the same one: no module contributes to it, the option set is
+ * `orderStatusSchema` fixed at compile time, and `shipments` reads `has` as a
+ * guard before moving an order into the status a dispatched shipment names. A
+ * skip would silently leave a shipped order in its old status; every code here
+ * is one live orders are already in, and a status an order is in has to stay
+ * nameable while the module holding this table is off.
+ *
+ * The policy is structural rather than promised: the class takes no presence
+ * input, so no read of it can be made to drop a status without changing the
+ * policy first.
+ */
+export declare class EnumOrderStatusRegistry implements OrderStatusRegistry {
+    private readonly codes;
+    list(): OrderStatusOption[];
+    has(code: string): boolean;
+    assertValid(code: string): void;
+}
+//# sourceMappingURL=order-status-registry.port.d.ts.map

package/dist/backend/services/order-status-registry.port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-status-registry.port.d.ts","sourceRoot":"","sources":["../../../src/backend/services/order-status-registry.port.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACzB,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC,qBAAa,wBAAyB,SAAQ,KAAK;aACrB,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAIzC;AAQD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IACjE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgD;IAEtE,IAAI,IAAI,iBAAiB,EAAE;IAI3B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAKhC"}

package/dist/backend/services/order-status-registry.port.js

@@ -0,0 +1,45 @@
+import { orderStatusSchema, } from '@endora-commerce/contracts';
+export class OrderStatusRegistryError extends Error {
+    code;
+    constructor(code) {
+        super(`Unknown order status reference: "${code}".`);
+        this.code = code;
+        this.name = 'OrderStatusRegistryError';
+    }
+}
+const humanize = (code) => code
+    .split('_')
+    .map((part) => (part.length > 0 ? part[0].toUpperCase() + part.slice(1) : part))
+    .join(' ');
+/**
+ * Default enum-backed implementation. Seed set = the order `status` enum.
+ *
+ * **The absent-owner policy this registry states (issue #129): honour — and the
+ * reason is that there is nothing to skip.** The delivery twin of
+ * `payment_methods/services/order-status-registry.port.ts`, and the argument is
+ * the same one: no module contributes to it, the option set is
+ * `orderStatusSchema` fixed at compile time, and `shipments` reads `has` as a
+ * guard before moving an order into the status a dispatched shipment names. A
+ * skip would silently leave a shipped order in its old status; every code here
+ * is one live orders are already in, and a status an order is in has to stay
+ * nameable while the module holding this table is off.
+ *
+ * The policy is structural rather than promised: the class takes no presence
+ * input, so no read of it can be made to drop a status without changing the
+ * policy first.
+ */
+export class EnumOrderStatusRegistry {
+    codes = orderStatusSchema.options;
+    list() {
+        return this.codes.map((code) => ({ code, label: humanize(code) }));
+    }
+    has(code) {
+        return this.codes.includes(code);
+    }
+    assertValid(code) {
+        if (!this.has(code)) {
+            throw new OrderStatusRegistryError(code);
+        }
+    }
+}
+//# sourceMappingURL=order-status-registry.port.js.map

package/dist/backend/services/order-status-registry.port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-status-registry.port.js","sourceRoot":"","sources":["../../../src/backend/services/order-status-registry.port.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,GAGlB,MAAM,4BAA4B,CAAC;AAwBpC,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACrB;IAA5B,YAA4B,IAAY;QACtC,KAAK,CAAC,oCAAoC,IAAI,IAAI,CAAC,CAAC;QAD1B,SAAI,GAAJ,IAAI,CAAQ;QAEtC,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AAED,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAU,EAAE,CACxC,IAAI;KACD,KAAK,CAAC,GAAG,CAAC;KACV,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAE,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;KAChF,IAAI,CAAC,GAAG,CAAC,CAAC;AAEf;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,uBAAuB;IACjB,KAAK,GAAsB,iBAAiB,CAAC,OAAO,CAAC;IAEtE,IAAI;QACF,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IACrE,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACpB,MAAM,IAAI,wBAAwB,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;CACF"}

package/dist/backend/services/registry-singleton.d.ts

@@ -0,0 +1,20 @@
+import { ShippingAdapterRegistry } from './shipping-adapter-registry.js';
+/**
+ * Process-wide ShippingAdapterRegistry (feature 035).
+ *
+ * `delivery_methods` pushes the two bundled offline adapters into this instance
+ * from its boot hook; a carrier module contributes its own the same way, naming
+ * itself as it does. One instance per process, so an adapter contributed by any
+ * module is immediately recognised by the live eligibility, admin-upsert and
+ * order-placement paths.
+ *
+ * Those paths read this table **per request**, never during composition — so a
+ * contributor's boot hook pushes and returns, with nothing to wait for, nothing
+ * to verify and no absence to react to. See the class doc block for the full
+ * push/pull shape and for why a throw there costs the next start.
+ *
+ * The presence probe is wired here rather than in the class — see the payment
+ * twin (issue #96).
+ */
+export declare const shippingAdapterRegistry: ShippingAdapterRegistry;
+//# sourceMappingURL=registry-singleton.d.ts.map

package/dist/backend/services/registry-singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-singleton.d.ts","sourceRoot":"","sources":["../../../src/backend/services/registry-singleton.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEzE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB,yBAEnC,CAAC"}

package/dist/backend/services/registry-singleton.js

@@ -0,0 +1,21 @@
+import { effectiveState } from '@endora-commerce/platform/kernel';
+import { ShippingAdapterRegistry } from './shipping-adapter-registry.js';
+/**
+ * Process-wide ShippingAdapterRegistry (feature 035).
+ *
+ * `delivery_methods` pushes the two bundled offline adapters into this instance
+ * from its boot hook; a carrier module contributes its own the same way, naming
+ * itself as it does. One instance per process, so an adapter contributed by any
+ * module is immediately recognised by the live eligibility, admin-upsert and
+ * order-placement paths.
+ *
+ * Those paths read this table **per request**, never during composition — so a
+ * contributor's boot hook pushes and returns, with nothing to wait for, nothing
+ * to verify and no absence to react to. See the class doc block for the full
+ * push/pull shape and for why a throw there costs the next start.
+ *
+ * The presence probe is wired here rather than in the class — see the payment
+ * twin (issue #96).
+ */
+export const shippingAdapterRegistry = new ShippingAdapterRegistry(undefined, (moduleId) => effectiveState.isPresent(moduleId));
+//# sourceMappingURL=registry-singleton.js.map

package/dist/backend/services/registry-singleton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-singleton.js","sourceRoot":"","sources":["../../../src/backend/services/registry-singleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEzE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,uBAAuB,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,EAAE,CACzF,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,CACnC,CAAC"}

package/dist/backend/services/shipment-usage-guard.d.ts

@@ -0,0 +1,31 @@
+import { type ShipmentUsagePort } from '@endora-commerce/contracts';
+import type { ShipmentUsageCounter } from '../commands/delivery-method.commands.js';
+/** What the counter needs, so a test supplies both halves without a container. */
+export interface ShipmentUsageCounterDeps {
+    /** `effectiveState.isPresent('shipments')`, injected so this stays testable. */
+    readonly isShipmentsPresent: () => boolean;
+    /** `lazyPort<ShipmentUsagePort>(ctx, 'shipmentUsagePort')`, resolved per call. */
+    readonly shipmentUsage: () => ShipmentUsagePort;
+}
+/**
+ * "How many shipments were created against this delivery method?" — asked of
+ * `shipments`, which owns the rows (feature 075, the `delivery_methods` shard).
+ *
+ * **Presence is decided before the port is resolved**, which is the
+ * `auth`/`api_keys` shape and the reason this edge is declared as
+ * `nonBindingDependencies` rather than as an ordinary dependency: `shipments`
+ * declares this module, so declaring it back closes a manifest cycle, and
+ * acknowledging it would put `delivery_methods` among the dependents that
+ * refuse the flip — making the shipment module unswitchable for as long as a
+ * shop offers delivery. There is deliberately no `catch` anywhere near the
+ * resolution: a caught gate is a fail-open degrade nobody declared.
+ *
+ * **The degradation is a refusal, not a shortcut.** `shipments.delivery_method_id`
+ * carries no foreign key, so this count is the only thing standing between a
+ * delete and permanently orphaned shipment history — and switching the module
+ * off is exactly when nothing on the operator's screen would show that the
+ * history exists. Off is meant to be reversible; a delete taken blind here is
+ * not. So the operator is told which switch to flip and nothing is destroyed.
+ */
+export declare function makeShipmentUsageCounter(deps: ShipmentUsageCounterDeps): ShipmentUsageCounter;
+//# sourceMappingURL=shipment-usage-guard.d.ts.map

package/dist/backend/services/shipment-usage-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipment-usage-guard.d.ts","sourceRoot":"","sources":["../../../src/backend/services/shipment-usage-guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEjF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAEpF,kFAAkF;AAClF,MAAM,WAAW,wBAAwB;IACvC,gFAAgF;IAChF,QAAQ,CAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAC3C,kFAAkF;IAClF,QAAQ,CAAC,aAAa,EAAE,MAAM,iBAAiB,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,wBAAwB,GAAG,oBAAoB,CAa7F"}

package/dist/backend/services/shipment-usage-guard.js

@@ -0,0 +1,33 @@
+import { ERROR_CODES } from '@endora-commerce/contracts';
+import { HttpError } from '@endora-commerce/platform/http';
+/**
+ * "How many shipments were created against this delivery method?" — asked of
+ * `shipments`, which owns the rows (feature 075, the `delivery_methods` shard).
+ *
+ * **Presence is decided before the port is resolved**, which is the
+ * `auth`/`api_keys` shape and the reason this edge is declared as
+ * `nonBindingDependencies` rather than as an ordinary dependency: `shipments`
+ * declares this module, so declaring it back closes a manifest cycle, and
+ * acknowledging it would put `delivery_methods` among the dependents that
+ * refuse the flip — making the shipment module unswitchable for as long as a
+ * shop offers delivery. There is deliberately no `catch` anywhere near the
+ * resolution: a caught gate is a fail-open degrade nobody declared.
+ *
+ * **The degradation is a refusal, not a shortcut.** `shipments.delivery_method_id`
+ * carries no foreign key, so this count is the only thing standing between a
+ * delete and permanently orphaned shipment history — and switching the module
+ * off is exactly when nothing on the operator's screen would show that the
+ * history exists. Off is meant to be reversible; a delete taken blind here is
+ * not. So the operator is told which switch to flip and nothing is destroyed.
+ */
+export function makeShipmentUsageCounter(deps) {
+    return async (deliveryMethodId) => {
+        if (!deps.isShipmentsPresent()) {
+            throw new HttpError(409, ERROR_CODES.VALIDATION_FAILED, 'Cannot delete delivery method: the "shipments" module is switched off, so the ' +
+                'platform cannot tell whether any shipment was created against this method. ' +
+                'Switch shipments on and try again, or set this method\'s status to "inactive".');
+        }
+        return deps.shipmentUsage().countForDeliveryMethod(deliveryMethodId);
+    };
+}
+//# sourceMappingURL=shipment-usage-guard.js.map

package/dist/backend/services/shipment-usage-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipment-usage-guard.js","sourceRoot":"","sources":["../../../src/backend/services/shipment-usage-guard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA0B,MAAM,4BAA4B,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAW3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAA8B;IACrE,OAAO,KAAK,EAAE,gBAAwB,EAAmB,EAAE;QACzD,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC/B,MAAM,IAAI,SAAS,CACjB,GAAG,EACH,WAAW,CAAC,iBAAiB,EAC7B,gFAAgF;gBAC9E,6EAA6E;gBAC7E,gFAAgF,CACnF,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;IACvE,CAAC,CAAC;AACJ,CAAC"}

package/dist/backend/services/shipping-adapter-registry.d.ts

@@ -0,0 +1,98 @@
+import type { ShippingAdapter, ShippingAdapterRegistryPort } from '@endora-commerce/contracts';
+/**
+ * ShippingAdapterRegistry (feature 035) — in-memory map of adapter key →
+ * implementation. A module is recognised as a shipping-method adapter iff it
+ * registers a `ShippingAdapter` here (FR-001). The bundled offline adapters
+ * (manual_courier / personal_pickup) are the first entries; a carrier module
+ * contributes its own from its boot hook.
+ *
+ * Owner-stamped and presence-filtered, exactly like the payment twin — see
+ * `payment_methods/services/payment-adapter-registry.ts` for the reasoning
+ * (issue #96, D-39). The mechanism is identical; the exposure is not, because
+ * today the only contributor is `delivery_methods` itself. Keeping the two
+ * registries the same shape is what stops a carrier module from landing on the
+ * defect the payment side just paid to remove.
+ *
+ * Collision policy mirrors the PaymentAdapterRegistry: last-writer-wins with a
+ * warning, so a re-registration during a hot reload or re-enable does not throw.
+ *
+ * **The push happens once, during composition; every read happens later, per
+ * operation.** That half was written down only for the payment twin, and the
+ * omission is what a contributor infers a rule from: nothing here is read while
+ * modules are being composed, so an adapter that is not in the table yet — or
+ * whose owner is switched off — is not a fault a contributor can observe, let
+ * alone react to. The reads are `ShippingMethodEligibilityService.filter` on
+ * `GET /api/v1/delivery-methods`, the `isRegistered` guard on the admin upsert
+ * `PUT /api/v1/admin/delivery-methods/:code`, `orders` re-validating the chosen
+ * method and firing `onOrderCreated` at placement, `ShipmentService.create`
+ * firing `onShipmentCreated`, and the order-confirmation e-mail resolving
+ * `renderers.email`. Each of those runs inside a request, after every boot hook
+ * has run.
+ *
+ * So a contributor's boot hook **pushes and returns**: it does not check that
+ * the table already holds anything, does not verify that `delivery_methods` is
+ * present, and never treats an absent adapter as fatal. A throw there is not a
+ * delivery method dropping out — `runBootHooks` attributes the failure to the
+ * module and re-throws `ModuleCompositionError`, and `index.ts` turns that into
+ * `process.exit(1)`, so an operator's switch takes down the next start instead
+ * of one adapter. Nor may the push probe presence (D-67/D-68): the enumeration
+ * here already answers that question, per read, and a probe at the push would
+ * make switching a carrier back on require a restart. A hook that also *does
+ * work* is split in two before either rule applies — the working half probes,
+ * the contributing half never does.
+ *
+ * There is likewise no order to get right between contributors. Every push
+ * lands in one process-wide table (`registry-singleton.ts`) during composition,
+ * and no read of it happens until a request does; an adapter a colleague
+ * contributes is visible to the first read either way.
+ */
+export interface RegistryLogger {
+    warn(message: string): void;
+}
+/** One contributed adapter, with the module that contributed it. */
+export interface ShippingAdapterEntry {
+    readonly adapter: ShippingAdapter;
+    readonly module: string;
+}
+/**
+ * `implements` the shape feature 075's Phase P published, which is what stops
+ * the registry and its contract drifting: `orders` and `shipments` read the
+ * published type, and `tsc` refuses the day a method here stops matching.
+ */
+export declare class ShippingAdapterRegistry implements ShippingAdapterRegistryPort {
+    private readonly log;
+    private readonly isModulePresent;
+    private readonly entries;
+    constructor(log?: RegistryLogger, isModulePresent?: (moduleId: string) => boolean);
+    register(adapter: ShippingAdapter, moduleId: string): void;
+    unregister(adapterKey: string): void;
+    /** Whether any module has contributed this key — presence-blind. */
+    isRegistered(adapterKey: string): boolean;
+    /** The contributed entry, presence-blind. Admin and diagnostics read this. */
+    entry(adapterKey: string): ShippingAdapterEntry | undefined;
+    /** The module that contributed `adapterKey`, or `null` when nobody did. */
+    ownerOf(adapterKey: string): string | null;
+    /**
+     * The module that contributed `adapterKey` and is **not** effectively
+     * present, or `null` when the adapter is available or was never contributed.
+     *
+     * The fourth reader, and the only one that answers the question instead of
+     * exposing the table. `get()` returns `undefined` for two situations an
+     * operator cannot act on identically — a key nobody ever contributed, and a
+     * key whose carrier module is switched off — so `shipments` asks this one to
+     * tell them apart before it decides what state to open the row in (issue
+     * #250). Its payment twin is `GatewayRefundRegistry.absentOwnerFor` (D-71).
+     */
+    absentOwnerFor(adapterKey: string): string | null;
+    /** Registered AND its owner effectively present. */
+    isAvailable(adapterKey: string): boolean;
+    /** The adapter, or `undefined` when unregistered or its owner is absent. */
+    get(adapterKey: string): ShippingAdapter | undefined;
+    /** The adapter, or a throw — see the payment twin for the two cases. */
+    resolve(adapterKey: string): ShippingAdapter;
+    /** Adapter keys whose owner is present (stable insertion order). */
+    list(): string[];
+    /** Every registered adapter key, presence-blind. */
+    listAll(): string[];
+}
+//# sourceMappingURL=shipping-adapter-registry.d.ts.map

package/dist/backend/services/shipping-adapter-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipping-adapter-registry.d.ts","sourceRoot":"","sources":["../../../src/backend/services/shipping-adapter-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAG/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAMD,oEAAoE;AACpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,2BAA2B;IAIvE,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAJlC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;gBAGhD,GAAG,GAAE,cAA8B,EACnC,eAAe,GAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAoB;IAG9E,QAAQ,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAW1D,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIpC,oEAAoE;IACpE,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIzC,8EAA8E;IAC9E,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAI3D,2EAA2E;IAC3E,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI1C;;;;;;;;;;OAUG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAMjD,oDAAoD;IACpD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAKxC,4EAA4E;IAC5E,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAMpD,wEAAwE;IACxE,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe;IAW5C,oEAAoE;IACpE,IAAI,IAAI,MAAM,EAAE;IAMhB,oDAAoD;IACpD,OAAO,IAAI,MAAM,EAAE;CAGpB"}

package/dist/backend/services/shipping-adapter-registry.js

@@ -0,0 +1,92 @@
+import { ModuleDisabledError } from '@endora-commerce/platform/kernel';
+const consoleLogger = {
+    warn: (message) => console.warn(message),
+};
+/**
+ * `implements` the shape feature 075's Phase P published, which is what stops
+ * the registry and its contract drifting: `orders` and `shipments` read the
+ * published type, and `tsc` refuses the day a method here stops matching.
+ */
+export class ShippingAdapterRegistry {
+    log;
+    isModulePresent;
+    entries = new Map();
+    constructor(log = consoleLogger, isModulePresent = () => true) {
+        this.log = log;
+        this.isModulePresent = isModulePresent;
+    }
+    register(adapter, moduleId) {
+        const existing = this.entries.get(adapter.adapterKey);
+        if (existing && existing.module !== moduleId) {
+            this.log.warn(`ShippingAdapterRegistry: adapter "${adapter.adapterKey}" re-registered by ` +
+                `module "${moduleId}" (was "${existing.module}"); overwriting previous registration.`);
+        }
+        this.entries.set(adapter.adapterKey, { adapter, module: moduleId });
+    }
+    unregister(adapterKey) {
+        this.entries.delete(adapterKey);
+    }
+    /** Whether any module has contributed this key — presence-blind. */
+    isRegistered(adapterKey) {
+        return this.entries.has(adapterKey);
+    }
+    /** The contributed entry, presence-blind. Admin and diagnostics read this. */
+    entry(adapterKey) {
+        return this.entries.get(adapterKey);
+    }
+    /** The module that contributed `adapterKey`, or `null` when nobody did. */
+    ownerOf(adapterKey) {
+        return this.entries.get(adapterKey)?.module ?? null;
+    }
+    /**
+     * The module that contributed `adapterKey` and is **not** effectively
+     * present, or `null` when the adapter is available or was never contributed.
+     *
+     * The fourth reader, and the only one that answers the question instead of
+     * exposing the table. `get()` returns `undefined` for two situations an
+     * operator cannot act on identically — a key nobody ever contributed, and a
+     * key whose carrier module is switched off — so `shipments` asks this one to
+     * tell them apart before it decides what state to open the row in (issue
+     * #250). Its payment twin is `GatewayRefundRegistry.absentOwnerFor` (D-71).
+     */
+    absentOwnerFor(adapterKey) {
+        const entry = this.entries.get(adapterKey);
+        if (!entry || this.isModulePresent(entry.module))
+            return null;
+        return entry.module;
+    }
+    /** Registered AND its owner effectively present. */
+    isAvailable(adapterKey) {
+        const entry = this.entries.get(adapterKey);
+        return entry !== undefined && this.isModulePresent(entry.module);
+    }
+    /** The adapter, or `undefined` when unregistered or its owner is absent. */
+    get(adapterKey) {
+        const entry = this.entries.get(adapterKey);
+        if (!entry || !this.isModulePresent(entry.module))
+            return undefined;
+        return entry.adapter;
+    }
+    /** The adapter, or a throw — see the payment twin for the two cases. */
+    resolve(adapterKey) {
+        const entry = this.entries.get(adapterKey);
+        if (!entry) {
+            throw new Error(`ShippingAdapterRegistry: no adapter registered for key "${adapterKey}".`);
+        }
+        if (!this.isModulePresent(entry.module)) {
+            throw new ModuleDisabledError(entry.module);
+        }
+        return entry.adapter;
+    }
+    /** Adapter keys whose owner is present (stable insertion order). */
+    list() {
+        return [...this.entries.entries()]
+            .filter(([, entry]) => this.isModulePresent(entry.module))
+            .map(([key]) => key);
+    }
+    /** Every registered adapter key, presence-blind. */
+    listAll() {
+        return [...this.entries.keys()];
+    }
+}
+//# sourceMappingURL=shipping-adapter-registry.js.map

package/dist/backend/services/shipping-adapter-registry.js.map

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

package/dist/backend/services/shipping-method-eligibility.d.ts

@@ -0,0 +1,24 @@
+import type { ShippingSurface } from '@endora-commerce/contracts';
+import type { DeliveryMethod } from '../entities/delivery-method.entity.js';
+import type { ShippingAdapterRegistry } from './shipping-adapter-registry.js';
+/**
+ * ShippingMethodEligibilityService (feature 035, FR-011/FR-012/FR-013/FR-014).
+ *
+ * Given the active methods (already filtered by status and the per-Organization
+ * allow-list at the route), keeps only those whose adapter is currently
+ * registered (FR-003 — a disabled adapter drops out) and whose surface
+ * validator returns true. Sales-channel-assignment filtering is applied by the
+ * caller via the membership bridge.
+ */
+export interface ShippingEligibilityContext {
+    salesChannelId: string | null;
+    organizationId: string | null;
+    customerAccountId: string | null;
+    surface: ShippingSurface;
+}
+export declare class ShippingMethodEligibilityService {
+    private readonly registry;
+    constructor(registry: ShippingAdapterRegistry);
+    filter(methods: DeliveryMethod[], ctx: ShippingEligibilityContext): Promise<DeliveryMethod[]>;
+}
+//# sourceMappingURL=shipping-method-eligibility.d.ts.map

package/dist/backend/services/shipping-method-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipping-method-eligibility.d.ts","sourceRoot":"","sources":["../../../src/backend/services/shipping-method-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAE9E;;;;;;;;GAQG;AACH,MAAM,WAAW,0BAA0B;IACzC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,OAAO,EAAE,eAAe,CAAC;CAC1B;AAED,qBAAa,gCAAgC;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,uBAAuB;IAExD,MAAM,CACV,OAAO,EAAE,cAAc,EAAE,EACzB,GAAG,EAAE,0BAA0B,GAC9B,OAAO,CAAC,cAAc,EAAE,CAAC;CAuC7B"}