@endora-commerce/mod-delivery-methods 0.100.0

package/dist/backend/services/shipping-method-eligibility.js

@@ -0,0 +1,46 @@
+export class ShippingMethodEligibilityService {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async filter(methods, ctx) {
+        const eligible = [];
+        for (const m of methods) {
+            if (m.status !== 'active')
+                continue;
+            const adapter = this.registry.get(m.adapter);
+            if (!adapter)
+                continue; // unregistered adapter ⇒ not offered (FR-003)
+            const eligCtx = {
+                deliveryMethod: {
+                    id: m.id,
+                    code: m.code,
+                    adapter: m.adapter,
+                    name: m.name,
+                    cost: { amount: Number(m.cost), currency: m.currency },
+                    status: m.status,
+                    statusOnSuccess: m.statusOnSuccess,
+                    statusOnFailure: m.statusOnFailure,
+                    salesChannelIds: [],
+                    rendererKey: adapter.renderers?.storefront ?? null,
+                },
+                // Issue #103 — passed through, `null` included. See the payment twin:
+                // `?? ''` is not a spelling of "platform-wide", it is a value the
+                // settings seam guard rejects.
+                salesChannelId: ctx.salesChannelId,
+                organizationId: ctx.organizationId,
+                customerAccountId: ctx.customerAccountId,
+                surface: ctx.surface,
+            };
+            const ok = ctx.surface === 'admin'
+                ? await adapter.validateUseOnAdmin(eligCtx)
+                : ctx.surface === 'api'
+                    ? await adapter.validateUseInApi(eligCtx)
+                    : await adapter.validateUseOnStorefront(eligCtx);
+            if (ok)
+                eligible.push(m);
+        }
+        return eligible;
+    }
+}
+//# sourceMappingURL=shipping-method-eligibility.js.map

package/dist/backend/services/shipping-method-eligibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipping-method-eligibility.js","sourceRoot":"","sources":["../../../src/backend/services/shipping-method-eligibility.ts"],"names":[],"mappings":"AAoBA,MAAM,OAAO,gCAAgC;IACd;IAA7B,YAA6B,QAAiC;QAAjC,aAAQ,GAAR,QAAQ,CAAyB;IAAG,CAAC;IAElE,KAAK,CAAC,MAAM,CACV,OAAyB,EACzB,GAA+B;QAE/B,MAAM,QAAQ,GAAqB,EAAE,CAAC;QACtC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACxB,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ;gBAAE,SAAS;YACpC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC7C,IAAI,CAAC,OAAO;gBAAE,SAAS,CAAC,8CAA8C;YAEtE,MAAM,OAAO,GAAG;gBACd,cAAc,EAAE;oBACd,EAAE,EAAE,CAAC,CAAC,EAAE;oBACR,IAAI,EAAE,CAAC,CAAC,IAAI;oBACZ,OAAO,EAAE,CAAC,CAAC,OAAO;oBAClB,IAAI,EAAE,CAAC,CAAC,IAAI;oBACZ,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE;oBACtD,MAAM,EAAE,CAAC,CAAC,MAAM;oBAChB,eAAe,EAAE,CAAC,CAAC,eAAe;oBAClC,eAAe,EAAE,CAAC,CAAC,eAAe;oBAClC,eAAe,EAAE,EAAc;oBAC/B,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,UAAU,IAAI,IAAI;iBACnD;gBACD,sEAAsE;gBACtE,kEAAkE;gBAClE,+BAA+B;gBAC/B,cAAc,EAAE,GAAG,CAAC,cAAc;gBAClC,cAAc,EAAE,GAAG,CAAC,cAAc;gBAClC,iBAAiB,EAAE,GAAG,CAAC,iBAAiB;gBACxC,OAAO,EAAE,GAAG,CAAC,OAAO;aACrB,CAAC;YAEF,MAAM,EAAE,GACN,GAAG,CAAC,OAAO,KAAK,OAAO;gBACrB,CAAC,CAAC,MAAM,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC;gBAC3C,CAAC,CAAC,GAAG,CAAC,OAAO,KAAK,KAAK;oBACrB,CAAC,CAAC,MAAM,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC;oBACzC,CAAC,CAAC,MAAM,OAAO,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;YACvD,IAAI,EAAE;gBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF"}

package/dist/install/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The **install surface** this module publishes: one factory, on a subpath whose
+ * declared meaning is foreign consumption (feature 134, FR-064;
+ * `module-package-layout.md` R11).
+ *
+ * A module that ships its own carrier seeds its `delivery_methods` row from its
+ * `installHook` through `createDeliveryMethodSeeder()`, handing `ctx.em` to every
+ * call; the interface it returns is published type-only on this package's
+ * `./ports`. `inpost`, `dhl_parcel` and the example deployment's
+ * `carrier_fixture` are its three consumers today, and wave 2 gives
+ * `payment_methods` the twin surface for five payment gateways.
+ *
+ * ## Why this is a subpath of its own rather than a line on `./backend`
+ *
+ * Three reasons, and the checker is not one of them.
+ *
+ * **The npm edge coincides with a declared lifecycle dependency rather than
+ * substituting for one.** R4 in `backend/scripts/lib/module-package-manifest.ts`
+ * refuses a module package importing another because a package edge is one *"the
+ * lifecycle, the migration order and an operator switching the owner off all know
+ * nothing about"* — D-11 rule 3's mirror false positive. Both carriers already
+ * declare `dependencies: ['…', 'delivery_methods', '…']` in their manifests, so
+ * the lifecycle, the migration order and the operator's switch all know about this
+ * edge; the npm declaration says the same thing a second way, in the only
+ * vocabulary a published tarball has. That is what puts this seam **inside** R4's
+ * reason rather than beside it.
+ *
+ * **`./backend` is deliberately discriminating and must stay so.**
+ * `module-package-layout.md` R7: after D-168, *"every reach into `<pkg>/backend`
+ * really is a wiring reach"*. A factory there would make one subpath mean either
+ * "this consumer is wiring `delivery_methods`", a real Principle I violation, or
+ * "this consumer seeds its own row through the sanctioned surface" — two findings
+ * with opposite remedies behind one name, for as many modules as adopt the seam.
+ *
+ * **The import is evaluated at every boot, and it is measured.**
+ * `manifest-index.generated.ts` imports every module's manifest statically and
+ * eagerly, in the server, the CLI and every worker — so a consumer's `installHook`
+ * is *called* at install and its `import` is *loaded* at boot. Measured on the
+ * emitted artefact, and both measurement points are given because the split moved
+ * one of them: with the factory on the barrel, `dist/backend/index.js` pulled **12
+ * emitted files and 7 external specifiers**, `@endora-commerce/platform/http`
+ * among them; after the split it pulls **11 and 7**, because the reconciler left
+ * it, and `dist/install/index.js` pulls **3 and 4 — this file, the reconciler, the
+ * entity — with no HTTP layer**. So a consumer that had to name the barrel loaded
+ * twelve modules and the HTTP layer where it now loads three and none of it,
+ * per process, for as many modules as adopt the seam.
+ *
+ * ## It is a pure re-export, and that is a rule
+ *
+ * No behaviour is added here and none may be. The install hook is **not** inside a
+ * database transaction — measured: a hook that threw half-way left the first of
+ * two seeded rows behind and never wrote the second — so every behaviour placed on
+ * this path is a new partial-write surface. The write stays in
+ * `../backend/services/delivery-method-reconciler.ts`, where its tests, its
+ * `command-coverage-ignore` classification and its Constitution XIII reasoning
+ * already live.
+ */
+export { createDeliveryMethodSeeder } from '../backend/services/delivery-method-reconciler.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/install/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,EAAE,0BAA0B,EAAE,MAAM,mDAAmD,CAAC"}

package/dist/install/index.js

@@ -0,0 +1,59 @@
+/**
+ * The **install surface** this module publishes: one factory, on a subpath whose
+ * declared meaning is foreign consumption (feature 134, FR-064;
+ * `module-package-layout.md` R11).
+ *
+ * A module that ships its own carrier seeds its `delivery_methods` row from its
+ * `installHook` through `createDeliveryMethodSeeder()`, handing `ctx.em` to every
+ * call; the interface it returns is published type-only on this package's
+ * `./ports`. `inpost`, `dhl_parcel` and the example deployment's
+ * `carrier_fixture` are its three consumers today, and wave 2 gives
+ * `payment_methods` the twin surface for five payment gateways.
+ *
+ * ## Why this is a subpath of its own rather than a line on `./backend`
+ *
+ * Three reasons, and the checker is not one of them.
+ *
+ * **The npm edge coincides with a declared lifecycle dependency rather than
+ * substituting for one.** R4 in `backend/scripts/lib/module-package-manifest.ts`
+ * refuses a module package importing another because a package edge is one *"the
+ * lifecycle, the migration order and an operator switching the owner off all know
+ * nothing about"* — D-11 rule 3's mirror false positive. Both carriers already
+ * declare `dependencies: ['…', 'delivery_methods', '…']` in their manifests, so
+ * the lifecycle, the migration order and the operator's switch all know about this
+ * edge; the npm declaration says the same thing a second way, in the only
+ * vocabulary a published tarball has. That is what puts this seam **inside** R4's
+ * reason rather than beside it.
+ *
+ * **`./backend` is deliberately discriminating and must stay so.**
+ * `module-package-layout.md` R7: after D-168, *"every reach into `<pkg>/backend`
+ * really is a wiring reach"*. A factory there would make one subpath mean either
+ * "this consumer is wiring `delivery_methods`", a real Principle I violation, or
+ * "this consumer seeds its own row through the sanctioned surface" — two findings
+ * with opposite remedies behind one name, for as many modules as adopt the seam.
+ *
+ * **The import is evaluated at every boot, and it is measured.**
+ * `manifest-index.generated.ts` imports every module's manifest statically and
+ * eagerly, in the server, the CLI and every worker — so a consumer's `installHook`
+ * is *called* at install and its `import` is *loaded* at boot. Measured on the
+ * emitted artefact, and both measurement points are given because the split moved
+ * one of them: with the factory on the barrel, `dist/backend/index.js` pulled **12
+ * emitted files and 7 external specifiers**, `@endora-commerce/platform/http`
+ * among them; after the split it pulls **11 and 7**, because the reconciler left
+ * it, and `dist/install/index.js` pulls **3 and 4 — this file, the reconciler, the
+ * entity — with no HTTP layer**. So a consumer that had to name the barrel loaded
+ * twelve modules and the HTTP layer where it now loads three and none of it,
+ * per process, for as many modules as adopt the seam.
+ *
+ * ## It is a pure re-export, and that is a rule
+ *
+ * No behaviour is added here and none may be. The install hook is **not** inside a
+ * database transaction — measured: a hook that threw half-way left the first of
+ * two seeded rows behind and never wrote the second — so every behaviour placed on
+ * this path is a new partial-write surface. The write stays in
+ * `../backend/services/delivery-method-reconciler.ts`, where its tests, its
+ * `command-coverage-ignore` classification and its Constitution XIII reasoning
+ * already live.
+ */
+export { createDeliveryMethodSeeder } from '../backend/services/delivery-method-reconciler.js';
+//# sourceMappingURL=index.js.map

package/dist/install/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/install/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,EAAE,0BAA0B,EAAE,MAAM,mDAAmD,CAAC"}

package/dist/manifest.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Delivery Methods module — manifest backfill (Module Lifecycle, feature 018);
+ * the shipping-method adapter framework host (feature 035).
+ *
+ * Predates the lifecycle system; the core module's schema is owned by
+ * platform-wide migrations (delivery_methods table + feature-035 columns in
+ * migration 052). The core module itself has no install/uninstall hook.
+ *
+ * Recognition condition (feature 035, FR-001): a *separate* platform module is
+ * recognised as a shipping-method adapter iff it registers a `ShippingAdapter`
+ * in the process-wide `shippingAdapterRegistry` (see
+ * services/registry-singleton.ts) from its **boot hook**, naming itself as the
+ * contributing module. Not from `installHook`: the registry is an in-memory
+ * table per process, install runs once in the CLI process, and the serving
+ * process reads what its own composition pushed.
+ *
+ * The `delivery_methods` **row** is the other half, and since feature 134's
+ * FR-064 it is written from the contributing module's `installHook` through this
+ * module's published install surface — `createDeliveryMethodSeeder()` on
+ * `./backend`, typed by `DeliveryMethodSeedApi` on `./ports`. It used to ship as
+ * that module's own migration, which was an `insert` into this module's table
+ * from another module's migration: three `migration-foreign-writes` ledger keys,
+ * and once the seeding module lives in another repository, a schema dependency
+ * with no version range and no compile-time signal
+ * (`specs/134-paid-module-extraction/contracts/foreign-write-repair.md`).
+ *
+ * No `uninstallHook` withdraws the adapter, and none should: the registry
+ * records the contributing module on every entry and filters its enumeration on
+ * that module's effective state, so an absent contributor is answered at the
+ * read. The row and its Shipments are preserved either way (FR-003). See
+ * docs/docs/modules/delivery_methods.md § *When the registry is read*.
+ */
+export declare const manifest: {
+    id: string;
+    name: string;
+    version: string;
+    dependencies: string[];
+    description?: string | undefined;
+    acknowledgedDependencies?: {
+        moduleId: string;
+        port: string;
+        reason: string;
+    }[] | undefined;
+    nonBindingDependencies?: {
+        moduleId: string;
+        name: string;
+        kind: "contributes-to" | "degrades-without" | "refuses-without";
+        reason: string;
+        whenAbsent?: string | undefined;
+    }[] | undefined;
+    activation?: {
+        settingCode: string;
+        default: boolean;
+    } | {
+        nonDeactivatable: true;
+        reason: string;
+    } | undefined;
+    settings?: {
+        moduleCode: string;
+        groups: {
+            code: string;
+            name: string;
+            salesChannelCodes?: string[] | undefined;
+            isSystemProtected?: boolean | undefined;
+        }[];
+        settings: {
+            code: string;
+            name: string;
+            valueType: "string" | "number" | "boolean" | "json" | "string_list" | "secret" | "credential_ref";
+            defaultValue: unknown;
+            description?: string | undefined;
+            groupCode?: string | undefined;
+            previousDefaultValues?: unknown[] | undefined;
+            salesChannelCodes?: string[] | undefined;
+            enumOptions?: string[] | undefined;
+            configurationType?: string | undefined;
+            hidden?: boolean | undefined;
+        }[];
+    } | undefined;
+    i18n?: {
+        bundlesDir: string;
+    } | undefined;
+    docs?: false | {
+        dir: string;
+    } | undefined;
+    demo?: false | {
+        summary: string;
+        seed: (context: import("@endora-commerce/contracts").ModuleDemoContext<never>) => Promise<import("@endora-commerce/contracts").DemoSeedResult>;
+        reset: (context: import("@endora-commerce/contracts").ModuleDemoContext<never>) => Promise<import("@endora-commerce/contracts").DemoResetResult>;
+        after?: readonly string[] | undefined;
+        package?: string | undefined;
+    } | undefined;
+    actions?: {
+        id: string;
+        labelKey: string;
+        icon: "Plus" | "Sparkles" | "Settings" | "Search" | "Boxes" | "Layers" | "Menu" | "PlusCircle" | "PlusSquare" | "FilePlus" | "FolderPlus" | "Upload" | "FileUp" | "CloudUpload" | "Download" | "FileDown" | "FileText" | "BookOpen" | "Rss" | "Package" | "Tag" | "ShoppingCart" | "Receipt" | "CreditCard" | "Users" | "UserPlus" | "Inbox" | "ListChecks" | "ClipboardList" | "Image" | "Video" | "LayoutDashboard" | "PanelLeft" | "KeyRound" | "ShieldCheck" | "Edit" | "Archive" | "Box" | "Truck" | "CircleDollarSign" | "Activity" | "LineChart" | "Smartphone" | "Webhook" | "Scale" | "PlugZap" | "PercentDiamond" | "Newspaper" | "Languages" | "Eraser" | "Warehouse" | "TrendingDown" | "Bell" | "PackageOpen" | "Building2" | "Store" | "ClipboardCheck";
+        targetRoute: string;
+        keywords: string[];
+        weight: number;
+        descriptionKey?: string | undefined;
+        requiredPermission?: string | undefined;
+    }[] | undefined;
+    permissions?: {
+        code: string;
+        label: string;
+        module?: string | undefined;
+        description?: string | undefined;
+        requires?: string[] | undefined;
+    }[] | undefined;
+    transactionalEmails?: {
+        code: string;
+        name: string;
+        variables: {
+            key: string;
+            label: string;
+            sampleValue?: string | undefined;
+            description?: string | undefined;
+        }[];
+        description?: string | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    capabilities?: string[] | undefined;
+    exclusiveCapabilities?: {
+        key: string;
+        errorCode: string;
+    }[] | undefined;
+    errorCodes?: {
+        code: string;
+        tokens?: string[] | undefined;
+    }[] | undefined;
+    blocks?: {
+        name: string;
+        labelKey: string;
+        category: string;
+        contexts: ("invoice" | "email" | "cms" | "newsletter")[];
+        fields: Record<string, {
+            type: "number" | "object" | "array" | "uuid" | "text" | "textarea" | "select" | "radio" | "external" | "richtext";
+            label?: string | undefined;
+            required?: boolean | undefined;
+            options?: {
+                label: string;
+                value: string | number;
+            }[] | undefined;
+            refKind?: string | undefined;
+        }>;
+        descriptionKey?: string | undefined;
+        defaultProps?: Record<string, unknown> | undefined;
+        responsiveFields?: string[] | undefined;
+        previewIcon?: string | undefined;
+        weight?: number | undefined;
+    }[] | undefined;
+    blockCategories?: {
+        key: string;
+        titleKey: string;
+        contexts: ("invoice" | "email" | "cms" | "newsletter")[];
+        weight?: number | undefined;
+        visible?: boolean | undefined;
+    }[] | undefined;
+    env?: {
+        name: string;
+        describes: {
+            en: string;
+            pl: string;
+        };
+        requirement: {
+            kind: "required";
+        } | {
+            kind: "requiredWhen";
+            input: string;
+            equals: string;
+        } | {
+            kind: "optional";
+            without: {
+                en: string;
+                pl: string;
+            };
+        };
+        secret: boolean;
+        generable: boolean;
+        owner: {
+            kind: "platform";
+        } | {
+            kind: "application";
+            application: "admin" | "backend" | "storefront";
+        } | {
+            kind: "module";
+            moduleId: string;
+        };
+        consumers: ("admin" | "backend" | "storefront")[];
+        addressOf: "admin" | "backend" | "storefront" | null;
+    }[] | undefined;
+};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuInB,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,185 @@
+import { defineModuleManifest } from '@endora-commerce/contracts';
+/**
+ * The demo data this module owns (feature 113, T220 — contract §1.3).
+ *
+ * A typed `const` rather than an inline object literal: declared inline the
+ * parameter infers from the schema and is `never`, so the author loses
+ * `context.ctx: ModuleContext`.
+ *
+ * Both bodies are reached by a **relative `await import()`** (§1.4), in
+ * `cliCommands.run`'s shape and for `cliCommands`' reason: a manifest is loaded
+ * by every process that composes the platform and by the check scripts that
+ * import the generated index, so a demo body imported at the top of this file
+ * would be a service graph pulled into all of them. It needs no `exports`
+ * subpath and no `files` entry (§1.5).
+ */
+const demo = {
+    summary: 'A free in-person pickup method, so the demo shop can be checked out.',
+    seed: async (context) => (await import('./backend/demo/seed.js')).seedDemo(context),
+    reset: async (context) => (await import('./backend/demo/reset.js')).resetDemo(context),
+};
+/**
+ * Delivery Methods module — manifest backfill (Module Lifecycle, feature 018);
+ * the shipping-method adapter framework host (feature 035).
+ *
+ * Predates the lifecycle system; the core module's schema is owned by
+ * platform-wide migrations (delivery_methods table + feature-035 columns in
+ * migration 052). The core module itself has no install/uninstall hook.
+ *
+ * Recognition condition (feature 035, FR-001): a *separate* platform module is
+ * recognised as a shipping-method adapter iff it registers a `ShippingAdapter`
+ * in the process-wide `shippingAdapterRegistry` (see
+ * services/registry-singleton.ts) from its **boot hook**, naming itself as the
+ * contributing module. Not from `installHook`: the registry is an in-memory
+ * table per process, install runs once in the CLI process, and the serving
+ * process reads what its own composition pushed.
+ *
+ * The `delivery_methods` **row** is the other half, and since feature 134's
+ * FR-064 it is written from the contributing module's `installHook` through this
+ * module's published install surface — `createDeliveryMethodSeeder()` on
+ * `./backend`, typed by `DeliveryMethodSeedApi` on `./ports`. It used to ship as
+ * that module's own migration, which was an `insert` into this module's table
+ * from another module's migration: three `migration-foreign-writes` ledger keys,
+ * and once the seeding module lives in another repository, a schema dependency
+ * with no version range and no compile-time signal
+ * (`specs/134-paid-module-extraction/contracts/foreign-write-repair.md`).
+ *
+ * No `uninstallHook` withdraws the adapter, and none should: the registry
+ * records the contributing module on every entry and filters its enumeration on
+ * that module's effective state, so an absent contributor is answered at the
+ * read. The row and its Shipments are preserved either way (FR-003). See
+ * docs/docs/modules/delivery_methods.md § *When the registry is read*.
+ */
+export const manifest = defineModuleManifest({
+    id: 'delivery_methods',
+    name: 'Delivery Methods',
+    description: 'Shipping/delivery method definitions and per-channel availability.',
+    version: '1.0.0',
+    // `auth` owns the `requireAdmin` port the admin routes are gated by; the
+    // edge became real with the conversion (feature 072, T095).
+    // `organizations` since feature 072 (T138) — see the payment twin.
+    dependencies: ['auth', 'organizations'],
+    /**
+     * D-44 — real to the container, binding on no operator (feature 075, the
+     * `delivery_methods` boundary shard).
+     *
+     * `shipments` declares this module, so the ordinary declaration closes a
+     * manifest cycle, and acknowledging the edge would put `delivery_methods` —
+     * present in every deployment that ships anything — among the dependents that
+     * refuse the flip, making shipments permanently unswitchable. The delete
+     * guard has a defined behaviour instead: it probes
+     * `effectiveState.isPresent('shipments')` before it resolves the port and
+     * refuses the delete when the answer is no, so nothing catches
+     * `ModuleDisabledError` and the degrade is declared rather than laundered out
+     * of a closed gate.
+     *
+     * Refusing rather than proceeding is the whole point of the entry.
+     * `shipments.delivery_method_id` carries no foreign key, so this count is the
+     * only thing between a delete and permanently orphaned shipment history — and
+     * a switched-off module is exactly when no screen would show the operator
+     * that the history exists. Switching a module off is meant to be reversible;
+     * a delete taken while it was off is not. Every row, binding and setting stays
+     * where it was, so the delete becomes available again the moment shipments
+     * comes back.
+     */
+    nonBindingDependencies: [
+        {
+            moduleId: 'shipments',
+            name: 'shipmentUsagePort',
+            kind: 'degrades-without',
+            whenAbsent: 'Deleting a delivery method is refused, naming the shipments module. Every other ' +
+                'surface — the catalog, the channel bindings, the storefront list, the writes — is ' +
+                'unaffected.',
+            reason: 'The FR-003 delete guard counts the shipments created against a method before it ' +
+                'removes the row, and those rows belong to `shipments`. It was a raw ' +
+                '`select count(*) from "shipments"` on this module\'s own transaction until feature ' +
+                '075 — a boundary crossing that named no import specifier and so compiled. The ' +
+                'ordinary declaration closes a cycle (`shipments` depends on this module for the ' +
+                'method row, the adapter registry and the order-status registry) and an acknowledged ' +
+                'edge would refuse every attempt to switch shipments off, which is a capability ' +
+                'operators are meant to have.',
+        },
+    ],
+    /**
+     * The module's own authority (2026-08-28).
+     *
+     * All three admin routes used to enforce `catalog:read` / `catalog:write`, so
+     * whoever could edit a product could read the delivery-method configuration,
+     * rewrite it — which methods a checkout offers, their surcharge, and which
+     * order status a shipment outcome moves an order to — and delete a method
+     * outright. Both codes were real, declared and enforced, so the permission
+     * inventory's two directions were clean over the site, and
+     * `check:action-route-permissions` never looked at all: this module declares
+     * no manifest action, so the check has nothing of its own to compare.
+     *
+     * A pair and no third code, spelled `<module id>:<read|write>` like the five
+     * gateway modules, `payment_methods`, `returns` and `invoices`. A prefix that
+     * is not its owner's id is the mistake `PERMISSION_CATALOGUE` comments on
+     * twice (`integrations:manage`, `audit_log:read`), both frozen because they
+     * are persisted in role rows; getting it right on a code that does not exist
+     * yet is free. The codes stay here rather than in `PERMISSION_CATALOGUE`,
+     * which is for codes spanning modules — this module owns these outright.
+     *
+     * No data migration: see
+     * `test/contract/delivery_methods/permission-authority.test.ts`.
+     */
+    permissions: [
+        { code: 'delivery_methods:read', label: 'View delivery methods' },
+        { code: 'delivery_methods:write', label: 'Configure delivery methods' },
+    ],
+    settings: {
+        moduleCode: 'delivery_methods',
+        groups: [{ code: 'delivery_methods', name: 'Delivery methods' }],
+        settings: [
+            {
+                // Feature 073 — the operator's activation control. Platform-wide.
+                code: 'delivery_methods.enabled',
+                name: 'Delivery methods enabled',
+                // The consequence sentence was missing the same way the payments one
+                // was: "the public list a checkout picks from" is accurate and stops
+                // short of what it means for the shop. With no method to pick, order
+                // placement answers "Delivery method is not active" and no order can be
+                // completed at all.
+                description: 'Switches the delivery-method catalog on or off: the admin screens that define methods and their per-channel availability, and the public list a checkout picks from. With no method to pick, checkout cannot be completed and the shop stops taking orders. Nothing is dropped — every method, its channel bindings and the shipments already created against it stay in the database, and the catalog returns exactly as configured when you switch it back on.',
+                groupCode: 'delivery_methods',
+                valueType: 'boolean',
+                defaultValue: true,
+            },
+        ],
+    },
+    // Feature 073, Amendment A1 (Constitution XVII) — deactivatable, because the
+    // reason it used to give does not hold. "The platform cannot take an order"
+    // rests on an edge that is not in the graph: `orders` declares `addresses`,
+    // `api_keys`, `carts`, `credit_limits`, `organizations`, `promotions`,
+    // `settings` and `transactional_emails`, and neither this module nor
+    // `payment_methods`. The dependents that do declare it — `payments`,
+    // `quick_order`, `shipments` — fail closed when it is off, which is the
+    // intended meaning of switching a delivery catalog off, not an accident.
+    // Feature 091 (Phase 4, batch 8) — this module ships a bundle now: its
+    // sidebar entry's `labelKey` is module-relative (R8) and resolves in this
+    // module's own namespace. Its screen's copy stays in `_i18n`'s `core`
+    // scope, which is batch 4's shape and not a new one.
+    i18n: { bundlesDir: 'i18n' },
+    docs: { dir: 'docs' },
+    // Feature 091 (Phase 4, batch 8) — the palette row `AppShell.tsx` carried by
+    // hand, arriving as the declaration Principle XVI names, for the reason
+    // recorded on `credit_limits`' entry: a `PALETTE_ITEMS` literal is a copy of
+    // an advertisement nothing filtered by the effective enabled-set.
+    // `delivery_methods:read` is what gates `GET /api/v1/admin/delivery-methods`,
+    // so the palette never advertises a 403.
+    actions: [
+        {
+            id: 'open-delivery-methods',
+            labelKey: 'actions.openDeliveryMethods.label',
+            descriptionKey: 'actions.openDeliveryMethods.description',
+            icon: 'Truck',
+            targetRoute: '/delivery-methods',
+            requiredPermission: 'delivery_methods:read',
+            keywords: ['delivery', 'shipping', 'methods', 'courier', 'metody dostawy', 'wysyłka', 'kurier'],
+            weight: 300,
+        },
+    ],
+    demo,
+    activation: { settingCode: 'delivery_methods.enabled', default: true },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

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

package/dist/migrations/20260611T140354_delivery_methods_shipping_methods_adapter_and_shipments.d.ts

@@ -0,0 +1,30 @@
+import { Migration } from '@mikro-orm/migrations';
+/**
+ * Shipping-method adapter framework + Shipment record (feature 035 — Metoda
+ * Dostawy).
+ *
+ * Extends the existing `delivery_methods` entry into a configurable,
+ * adapter-backed shipping method and introduces the `shipments` record:
+ *
+ *   delivery_methods:
+ *     + adapter            — registry key of the ShippingAdapter realising the
+ *                            logic (backfilled from the existing `code`)
+ *     + status_on_success  — Order-status reference applied on a successful
+ *                            shipment generation (seed `shipped`)
+ *     + status_on_failure  — Order-status reference applied on a failed
+ *                            shipment generation (seed `in_fulfilment`)
+ *
+ *   shipments (new):
+ *     a first-class generation attempt against an Order — order_id,
+ *     delivery_method_id, status (pending|success|failure), external_reference,
+ *     provider_details, failure_reason, attempt_no, timestamps.
+ *
+ * `price` reuses the existing `delivery_methods.cost` column (no new column).
+ * Seed status mappings reuse the current hard-coded order `status` enum until
+ * the Orders module ships a configurable registry (see research.md R3/R10).
+ */
+export declare class Migration20260611T140354DeliveryMethodsShippingMethodsAdapterAndShipments extends Migration {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}
+//# sourceMappingURL=20260611T140354_delivery_methods_shipping_methods_adapter_and_shipments.d.ts.map

package/dist/migrations/20260611T140354_delivery_methods_shipping_methods_adapter_and_shipments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260611T140354_delivery_methods_shipping_methods_adapter_and_shipments.d.ts","sourceRoot":"","sources":["../../src/migrations/20260611T140354_delivery_methods_shipping_methods_adapter_and_shipments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,yEAA0E,SAAQ,SAAS;IACvF,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAqCnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CASrC"}