@objectstack/plugin-webhooks 7.4.1 → 7.6.0

package/dist/schema.js

@@ -1,11 +1,7 @@
 import {
-  SYS_WEBHOOK_DELIVERY,
-  SysWebhook,
-  SysWebhookDelivery
-} from "./chunk-7HS5DLU2.js";
+  SysWebhook
+} from "./chunk-HWFTXTTI.js";
 export {
-  SYS_WEBHOOK_DELIVERY,
-  SysWebhook,
-  SysWebhookDelivery
+  SysWebhook
 };
 //# sourceMappingURL=schema.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/plugin-webhooks",
-  "version": "7.4.1",
+  "version": "7.6.0",
   "license": "Apache-2.0",
   "description": "Persistent, cluster-aware webhook dispatcher. Durable outbox + per-partition cluster.lock for exactly-once-ish delivery across nodes. See content/docs/concepts/webhook-delivery.mdx.",
   "type": "module",
@@ -12,11 +12,6 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./sql": {
-      "types": "./dist/sql-outbox.d.ts",
-      "import": "./dist/sql-outbox.js",
-      "require": "./dist/sql-outbox.cjs"
-    },
     "./schema": {
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.js",
@@ -24,16 +19,14 @@
     }
   },
   "dependencies": {
-    "@objectstack/core": "7.4.1",
-    "@objectstack/platform-objects": "7.4.1",
-    "@objectstack/service-cluster": "7.4.1",
-    "@objectstack/spec": "7.4.1",
-    "@objectstack/types": "7.4.1"
+    "@objectstack/core": "7.6.0",
+    "@objectstack/service-messaging": "7.6.0",
+    "@objectstack/spec": "7.6.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   },
   "keywords": [
     "objectstack",

package/src/auto-enqueuer.test.ts

@@ -3,18 +3,17 @@
 /**
  * AutoEnqueuer end-to-end test.
  *
- * Verifies that the bridge between `IRealtimeService` (data events) and
- * `IWebhookOutbox` (delivery rows) works as documented:
+ * Verifies the bridge between `IRealtimeService` (data events) and the shared
+ * `service-messaging` HTTP outbox (ADR-0018 M3 — enqueue via `messaging.enqueueHttp`):
  *
  *   - On startup, subscription rules are loaded from the engine.
  *   - `data.record.created/updated/deleted` events fan out to matching
- *     `sys_webhook` rows.
+ *     `sys_webhook` rows, enqueued as `source: 'webhook'`.
  *   - The `triggers` CSV column filters which actions fire.
  *   - The `object_name` field scopes events to a specific object.
  *   - Edits to `sys_webhook` self-heal the cache without restart.
  *   - Enqueue is fire-and-forget (handler never throws or blocks).
- *   - The deterministic eventId means two replays of the same event
- *     produce one outbox row (dedup via the underlying outbox).
+ *   - The deterministic dedupKey (`<webhookId>:<eventId>`) collapses replays.
  */
 
 import { describe, expect, it, vi } from 'vitest';
@@ -24,13 +23,31 @@ import type {
     RealtimeEventHandler,
     RealtimeEventPayload,
 } from '@objectstack/spec/contracts';
-import { AutoEnqueuer } from './auto-enqueuer.js';
-import { MemoryWebhookOutbox } from './memory-outbox.js';
+import type { EnqueueHttpInput } from '@objectstack/service-messaging';
+import { AutoEnqueuer, type HttpEnqueueFn } from './auto-enqueuer.js';
 
 // ---------------------------------------------------------------------------
 // Fakes
 // ---------------------------------------------------------------------------
 
+/**
+ * Records `enqueueHttp` calls and dedups on `(source, dedupKey)` — mirroring the
+ * shared outbox's UNIQUE constraint so the replay test still holds.
+ */
+function makeRecorder() {
+    const calls: EnqueueHttpInput[] = [];
+    const seen = new Map<string, string>();
+    const enqueue: HttpEnqueueFn = async (input) => {
+        const key = `${input.source}::${input.dedupKey}`;
+        const existing = seen.get(key);
+        if (existing) return existing;
+        seen.set(key, key);
+        calls.push(input);
+        return key;
+    };
+    return { enqueue, calls };
+}
+
 class FakeRealtime implements IRealtimeService {
     private subs = new Map<string, { handler: RealtimeEventHandler; opts?: any }>();
     private n = 0;
@@ -42,7 +59,7 @@ class FakeRealtime implements IRealtimeService {
             await sub.handler(event);
         }
     }
-    async subscribe(channel: string, handler: any, opts?: any): Promise<string> {
+    async subscribe(_channel: string, handler: any, opts?: any): Promise<string> {
         const id = `s-${++this.n}`;
         this.subs.set(id, { handler, opts });
         return id;
@@ -62,9 +79,7 @@ class FakeEngine implements IDataEngine {
     async find(name: string, q?: any): Promise<any[]> {
         const all = this.rows[name] ?? [];
         if (!q?.where) return all;
-        return all.filter((r) =>
-            Object.entries(q.where).every(([k, v]) => r[k] === v),
-        );
+        return all.filter((r) => Object.entries(q.where).every(([k, v]) => r[k] === v));
     }
     async findOne(name: string, q?: any): Promise<any> {
         return (await this.find(name, q))[0] ?? null;
@@ -77,10 +92,7 @@ class FakeEngine implements IDataEngine {
     async update(name: string, data: any, opts?: any): Promise<any> {
         const arr = this.rows[name] ?? [];
         for (const r of arr) {
-            if (
-                opts?.where &&
-                Object.entries(opts.where).every(([k, v]) => r[k] === v)
-            ) {
+            if (opts?.where && Object.entries(opts.where).every(([k, v]) => r[k] === v)) {
                 Object.assign(r, data);
             }
         }
@@ -90,11 +102,7 @@ class FakeEngine implements IDataEngine {
         const arr = this.rows[name] ?? [];
         const before = arr.length;
         this.rows[name] = arr.filter(
-            (r) =>
-                !(
-                    opts?.where &&
-                    Object.entries(opts.where).every(([k, v]) => r[k] === v)
-                ),
+            (r) => !(opts?.where && Object.entries(opts.where).every(([k, v]) => r[k] === v)),
         );
         return { affected: before - this.rows[name].length };
     }
@@ -139,7 +147,6 @@ function event(
 }
 
 async function flush() {
-    // Let microtasks run — fire-and-forget enqueues return on next tick.
     await new Promise((r) => setTimeout(r, 0));
 }
 
@@ -151,48 +158,41 @@ describe('AutoEnqueuer', () => {
     it('enqueues a delivery when a matching data event fires', async () => {
         const engine = new FakeEngine({ sys_webhook: [webhook()] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1', name: 'Alice' }));
         await flush();
 
-        const rows = await outbox.list();
-        expect(rows).toHaveLength(1);
-        expect(rows[0].url).toBe('https://hooks.example/wh');
-        expect(rows[0].eventType).toBe('data.record.created');
-        expect((rows[0].payload as any).recordId).toBe('c-1');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].source).toBe('webhook');
+        expect(calls[0].refId).toBe('wh-1');
+        expect(calls[0].url).toBe('https://hooks.example/wh');
+        expect(calls[0].label).toBe('data.record.created');
+        expect((calls[0].payload as any).recordId).toBe('c-1');
         await ae.stop();
     });
 
     it('skips events for other objects', async () => {
         const engine = new FakeEngine({ sys_webhook: [webhook({ object_name: 'contact' })] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'lead', { id: 'l-1' }));
         await flush();
 
-        expect(await outbox.list()).toHaveLength(0);
+        expect(calls).toHaveLength(0);
         await ae.stop();
     });
 
     it('respects the triggers CSV (create-only webhook ignores updates)', async () => {
-        const engine = new FakeEngine({
-            sys_webhook: [webhook({ triggers: 'create' })],
-        });
+        const engine = new FakeEngine({ sys_webhook: [webhook({ triggers: 'create' })] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1' }));
@@ -200,9 +200,8 @@ describe('AutoEnqueuer', () => {
         await realtime.publish(event('deleted', 'contact', { id: 'c-1' }, '2026-05-24T00:00:02.000Z'));
         await flush();
 
-        const rows = await outbox.list();
-        expect(rows).toHaveLength(1);
-        expect(rows[0].eventType).toBe('data.record.created');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].label).toBe('data.record.created');
         await ae.stop();
     });
 
@@ -214,18 +213,15 @@ describe('AutoEnqueuer', () => {
             ],
         });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1' }));
         await flush();
 
-        const rows = await outbox.list();
-        expect(rows).toHaveLength(2);
-        expect(rows.map((r) => r.url).sort()).toEqual([
+        expect(calls).toHaveLength(2);
+        expect(calls.map((r) => r.url).sort()).toEqual([
             'https://amplitude.test',
             'https://slack.test',
         ]);
@@ -233,58 +229,44 @@ describe('AutoEnqueuer', () => {
     });
 
     it('skips inactive webhooks', async () => {
-        const engine = new FakeEngine({
-            sys_webhook: [webhook({ active: false })],
-        });
+        const engine = new FakeEngine({ sys_webhook: [webhook({ active: false })] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1' }));
         await flush();
 
-        expect(await outbox.list()).toHaveLength(0);
+        expect(calls).toHaveLength(0);
         await ae.stop();
     });
 
     it('skips manual-only webhooks (no triggers)', async () => {
-        const engine = new FakeEngine({
-            sys_webhook: [webhook({ triggers: '' })],
-        });
+        const engine = new FakeEngine({ sys_webhook: [webhook({ triggers: '' })] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1' }));
         await flush();
 
-        expect(await outbox.list()).toHaveLength(0);
+        expect(calls).toHaveLength(0);
         await ae.stop();
     });
 
     it('self-heals the cache when sys_webhook changes', async () => {
-        // Start with no webhooks; add one via the engine; the next event
-        // should be enqueued without an explicit refresh() call.
         const engine = new FakeEngine({ sys_webhook: [] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1' }));
         await flush();
-        expect(await outbox.list()).toHaveLength(0);
+        expect(calls).toHaveLength(0);
 
-        // Admin adds a webhook through the API and the engine publishes
-        // a data.record.created event for sys_webhook itself.
         await engine.insert('sys_webhook', webhook());
         await realtime.publish({
             type: 'data.record.created',
@@ -295,56 +277,45 @@ describe('AutoEnqueuer', () => {
         await flush();
         await flush(); // Two ticks: the self-heal handler itself awaits refresh
 
-        await realtime.publish(
-            event('created', 'contact', { id: 'c-2' }, '2026-05-24T00:01:01.000Z'),
-        );
+        await realtime.publish(event('created', 'contact', { id: 'c-2' }, '2026-05-24T00:01:01.000Z'));
         await flush();
 
-        const rows = await outbox.list();
-        expect(rows).toHaveLength(1);
-        expect((rows[0].payload as any).recordId).toBe('c-2');
+        expect(calls).toHaveLength(1);
+        expect((calls[0].payload as any).recordId).toBe('c-2');
         await ae.stop();
     });
 
-    it('uses deterministic eventId so dedup catches replays', async () => {
+    it('uses a deterministic dedupKey so replays collapse', async () => {
         const engine = new FakeEngine({ sys_webhook: [webhook()] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-        });
+        const { enqueue, calls } = makeRecorder();
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
-        // Publish identical event twice — outbox dedup must collapse.
         const evt = event('created', 'contact', { id: 'c-1' });
         await realtime.publish(evt);
         await realtime.publish(evt);
         await flush();
 
-        expect(await outbox.list()).toHaveLength(1);
+        expect(calls).toHaveLength(1);
         await ae.stop();
     });
 
     it('handler is fire-and-forget (publish does not block on enqueue)', async () => {
         const engine = new FakeEngine({ sys_webhook: [webhook()] });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
         let slowResolve!: () => void;
         const blocker = new Promise<void>((res) => {
             slowResolve = res;
         });
-
-        // Wrap outbox to make enqueue slow.
-        const slow: typeof outbox = Object.assign(outbox, {
-            enqueue: async (...args: Parameters<typeof outbox.enqueue>) => {
-                await blocker;
-                return MemoryWebhookOutbox.prototype.enqueue.apply(outbox, args);
-            },
-        });
-
-        const ae = new AutoEnqueuer(engine, realtime, slow, {
-            refreshIntervalMs: 0,
-        });
+        const calls: EnqueueHttpInput[] = [];
+        const enqueue: HttpEnqueueFn = async (input) => {
+            await blocker;
+            calls.push(input);
+            return 'id';
+        };
+
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0 });
         await ae.start();
 
         const before = Date.now();
@@ -354,7 +325,7 @@ describe('AutoEnqueuer', () => {
 
         slowResolve();
         await flush();
-        expect(await outbox.list()).toHaveLength(1);
+        expect(calls).toHaveLength(1);
         await ae.stop();
     });
 
@@ -366,25 +337,21 @@ describe('AutoEnqueuer', () => {
             ],
         });
         const realtime = new FakeRealtime();
-        const outbox = new MemoryWebhookOutbox();
-        const orig = outbox.enqueue.bind(outbox);
-        outbox.enqueue = vi.fn(async (input) => {
-            if (input.webhookId === 'wh-bad') throw new Error('boom');
-            return orig(input);
+        const calls: EnqueueHttpInput[] = [];
+        const enqueue: HttpEnqueueFn = vi.fn(async (input) => {
+            if (input.refId === 'wh-bad') throw new Error('boom');
+            calls.push(input);
+            return 'id';
         });
         const warn = vi.fn();
-        const ae = new AutoEnqueuer(engine, realtime, outbox, {
-            refreshIntervalMs: 0,
-            logger: { warn },
-        });
+        const ae = new AutoEnqueuer(engine, realtime, enqueue, { refreshIntervalMs: 0, logger: { warn } });
         await ae.start();
 
         await realtime.publish(event('created', 'contact', { id: 'c-1' }));
         await flush();
 
-        const rows = await outbox.list();
-        expect(rows).toHaveLength(1);
-        expect(rows[0].url).toBe('https://good.test');
+        expect(calls).toHaveLength(1);
+        expect(calls[0].url).toBe('https://good.test');
         expect(warn).toHaveBeenCalled();
         await ae.stop();
     });

package/src/auto-enqueuer.ts

@@ -1,7 +1,14 @@
 // Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
 
 import type { IDataEngine, IRealtimeService, RealtimeEventPayload } from '@objectstack/spec/contracts';
-import type { IWebhookOutbox } from './outbox.js';
+import type { EnqueueHttpInput } from '@objectstack/service-messaging';
+
+/**
+ * Enqueue callback into the shared `service-messaging` HTTP outbox (ADR-0018 M3).
+ * The plugin supplies one bound to `messaging.enqueueHttp(...)`; webhooks no
+ * longer own a delivery outbox/dispatcher — they share the generic substrate.
+ */
+export type HttpEnqueueFn = (input: EnqueueHttpInput) => Promise<string>;
 
 /**
  * Optional logger interface (subset of console / kernel logger).
@@ -98,7 +105,7 @@ export class AutoEnqueuer {
     constructor(
         private readonly engine: IDataEngine,
         private readonly realtime: IRealtimeService,
-        private readonly outbox: IWebhookOutbox,
+        private readonly enqueue: HttpEnqueueFn,
         opts: AutoEnqueuerOptions = {},
     ) {
         this.subscriptionsObject = opts.subscriptionsObject ?? 'sys_webhook';
@@ -274,32 +281,36 @@ export class AutoEnqueuer {
         for (const sub of subs) {
             if (!sub.triggers.has(trigger)) continue;
 
-            // Fire-and-forget — never await on the hot path.
-            void this.outbox
-                .enqueue({
-                    webhookId: sub.id,
+            // Fire-and-forget — never await on the hot path. Map the webhook
+            // delivery onto the generic HTTP-outbox shape (ADR-0018 M3):
+            //  - source 'webhook' + dedupKey '<webhookId>:<eventId>' preserves
+            //    the old (event_id, webhook_id) at-most-once enqueue;
+            //  - refId = webhookId keeps per-webhook partition affinity / ordering;
+            //  - label = event type → X-Objectstack-Event header.
+            void this.enqueue({
+                source: 'webhook',
+                refId: sub.id,
+                dedupKey: `${sub.id}:${eventId}`,
+                label: event.type,
+                url: sub.url,
+                method: sub.method,
+                headers: sub.headers,
+                signingSecret: sub.secret,
+                timeoutMs: sub.timeoutMs,
+                payload: {
+                    object: event.object,
+                    recordId,
+                    action,
+                    timestamp: event.timestamp,
+                    ...payload,
+                },
+            }).catch((err) =>
+                this.logger.warn?.('[webhook-auto-enqueuer] enqueue failed', {
+                    webhook: sub.name,
                     eventId,
-                    eventType: event.type,
-                    url: sub.url,
-                    method: sub.method,
-                    headers: sub.headers,
-                    secret: sub.secret,
-                    timeoutMs: sub.timeoutMs,
-                    payload: {
-                        object: event.object,
-                        recordId,
-                        action,
-                        timestamp: event.timestamp,
-                        ...payload,
-                    },
-                })
-                .catch((err) =>
-                    this.logger.warn?.('[webhook-auto-enqueuer] enqueue failed', {
-                        webhook: sub.name,
-                        eventId,
-                        err: (err as Error)?.message ?? err,
-                    }),
-                );
+                    err: (err as Error)?.message ?? err,
+                }),
+            );
         }
     }
 

package/src/index.ts

@@ -3,23 +3,21 @@
 /**
  * @objectstack/plugin-webhooks
  *
- * Persistent, cluster-aware webhook outbox + dispatcher.
+ * Webhook fan-out on top of the shared outbound-HTTP delivery substrate
+ * (ADR-0018 M3). The durable outbox, cluster-coordinated dispatcher, retry /
+ * backoff / dead-letter, and retention all live in
+ * `@objectstack/service-messaging` (`sys_http_delivery` + `HttpDispatcher`).
  *
- * Implements stages 3–5 of the pipeline in
- * `content/docs/concepts/webhook-delivery.mdx` (Persist · Dispatch ·
- * Retry). Stages 1–2 (Event capture · Match) integrate via the
- * `webhook.outbox.enqueue()` service consumers call after persistence.
+ * This package ships only the webhook-specific concerns:
+ *   - the `sys_webhook` configuration object,
+ *   - the {@link AutoEnqueuer} that turns `data.record.*` events into outbox
+ *     rows (`source: 'webhook'`),
+ *   - the redeliver admin endpoint.
  *
- * The first real cross-node consumer of `cluster.lock`.
+ * **Requires** `MessagingServicePlugin` (a foundational, always-on capability).
  *
  * ## Subpath exports
- * - `@objectstack/plugin-webhooks/sql` — `SqlWebhookOutbox` (production
- *   storage; durable rows via ObjectQL / any driver)
- * - `@objectstack/plugin-webhooks/schema` — `SysWebhookDelivery` object
- *   schema to register in `defineStack({ objects: [...] })`
- *
- * The main entry intentionally ships only the `MemoryWebhookOutbox` so
- * downstream bundles don't pay for the SQL impl unless they import it.
+ * - `@objectstack/plugin-webhooks/schema` — `SysWebhook` object schema.
  */
 
 export {
@@ -27,30 +25,5 @@ export {
     type WebhookOutboxPluginOptions,
 } from './webhook-outbox-plugin.js';
 
-export { WebhookDispatcher, type DispatcherOptions } from './dispatcher.js';
-export { MemoryWebhookOutbox } from './memory-outbox.js';
-export { AutoEnqueuer, type AutoEnqueuerOptions } from './auto-enqueuer.js';
-export {
-    DeliveryRetentionSweeper,
-    type DeliveryRetentionOptions,
-} from './retention.js';
-export { hashPartition } from './partition.js';
-export {
-    sendOnce,
-    classifyAttempt,
-    nextRetryDelayMs,
-    DEFAULT_TIMEOUT_MS,
-    type AttemptOutcome,
-    type FetchImpl,
-} from './http-sender.js';
-export type {
-    AckFailure,
-    AckResult,
-    AckSuccess,
-    ClaimOptions,
-    DeliveryStatus,
-    EnqueueInput,
-    IWebhookOutbox,
-    WebhookDelivery,
-} from './outbox.js';
-export { RedeliverError } from './outbox.js';
+export { AutoEnqueuer, type AutoEnqueuerOptions, type HttpEnqueueFn } from './auto-enqueuer.js';
+export { SysWebhook } from './sys-webhook.object.js';

package/src/schema.ts

@@ -3,24 +3,19 @@
 /**
  * Public schema subpath: `@objectstack/plugin-webhooks/schema`.
  *
- * Thin re-export barrel kept stable across refactors. The actual object
- * definitions live in `sys-webhook.object.ts` and
- * `sys-webhook-delivery.object.ts` (matching the `*.object.ts` convention
- * used everywhere else in the monorepo for `sys_*` schemas).
+ * Thin re-export barrel kept stable across refactors. The object definition
+ * lives in `sys-webhook.object.ts` (matching the `*.object.ts` convention used
+ * everywhere else in the monorepo for `sys_*` schemas).
  *
- * `sys_webhook` moved here from `@objectstack/platform-objects` per
- * ADR-0029 (K2.a) so this plugin owns both of its objects.
+ * `sys_webhook` moved here from `@objectstack/platform-objects` per ADR-0029
+ * (K2.a) so this plugin owns its configuration object. Delivery telemetry is no
+ * longer a webhook-owned object: post-ADR-0018 M3 deliveries are rows in the
+ * shared `sys_http_delivery` outbox owned by `@objectstack/service-messaging`.
  *
- * Note: callers that just need the runtime should import from the
- * package root (`@objectstack/plugin-webhooks`), which auto-registers
- * `sys_webhook` + `sys_webhook_delivery` via the plugin manifest. This
- * subpath exists for the rare case where you want the schema without
- * installing the dispatcher plugin (e.g. read-only inspection from a
- * different runtime).
+ * Note: callers that just need the runtime should import from the package root
+ * (`@objectstack/plugin-webhooks`), which auto-registers `sys_webhook` via the
+ * plugin manifest. This subpath exists for read-only inspection from a
+ * different runtime.
  */
 
 export { SysWebhook } from './sys-webhook.object.js';
-export {
-  SysWebhookDelivery,
-  SYS_WEBHOOK_DELIVERY,
-} from './sys-webhook-delivery.object.js';