@objectstack/plugin-webhooks 7.5.0 → 7.7.0

package/dist/index.cjs

@@ -1,23 +1,13 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-
-
-var _chunkHF7CCDPBcjs = require('./chunk-HF7CCDPB.cjs');
-
-
-
-
-var _chunkTDSI7UHYcjs = require('./chunk-TDSI7UHY.cjs');
-
-// src/webhook-outbox-plugin.ts
-var _types = require('@objectstack/types');
+var _chunkKPKLAXNAcjs = require('./chunk-KPKLAXNA.cjs');
 
 // src/auto-enqueuer.ts
 var AutoEnqueuer = class {
-  constructor(engine, realtime, outbox, opts = {}) {
+  constructor(engine, realtime, enqueue, opts = {}) {
     this.engine = engine;
     this.realtime = realtime;
-    this.outbox = outbox;
+    this.enqueue = enqueue;
     this.subscriptions = /* @__PURE__ */ new Map();
     this.running = false;
     this.subscriptionsObject = _nullishCoalesce(opts.subscriptionsObject, () => ( "sys_webhook"));
@@ -112,7 +102,7 @@ var AutoEnqueuer = class {
     if (typeof row.definition_json === "string" && row.definition_json.length > 0) {
       try {
         defn = _nullishCoalesce(JSON.parse(row.definition_json), () => ( {}));
-      } catch (e2) {
+      } catch (e) {
         defn = {};
       }
     }
@@ -152,14 +142,15 @@ var AutoEnqueuer = class {
     const eventId = `${event.object}:${recordId}:${action}:${event.timestamp}`;
     for (const sub of subs) {
       if (!sub.triggers.has(trigger)) continue;
-      void this.outbox.enqueue({
-        webhookId: sub.id,
-        eventId,
-        eventType: event.type,
+      void this.enqueue({
+        source: "webhook",
+        refId: sub.id,
+        dedupKey: `${sub.id}:${eventId}`,
+        label: event.type,
         url: sub.url,
         method: sub.method,
         headers: sub.headers,
-        secret: sub.secret,
+        signingSecret: sub.secret,
         timeoutMs: sub.timeoutMs,
         payload: {
           object: event.object,
@@ -204,436 +195,16 @@ function mapActionToTrigger(action) {
   }
 }
 
-// src/http-sender.ts
-var _crypto = require('crypto');
-var DEFAULT_TIMEOUT_MS = 15e3;
-var RESPONSE_BODY_CAP = 16 * 1024;
-async function sendOnce(delivery, fetchImpl) {
-  const body = typeof delivery.payload === "string" ? delivery.payload : JSON.stringify(delivery.payload);
-  const headers = {
-    "Content-Type": "application/json",
-    "User-Agent": "ObjectStack-Webhooks/1.0",
-    "X-Objectstack-Event": delivery.eventType,
-    "X-Objectstack-Delivery": delivery.id,
-    "X-Objectstack-Attempt": String(delivery.attempts + 1),
-    ..._nullishCoalesce(delivery.headers, () => ( {}))
-  };
-  if (delivery.secret) {
-    const sig = _crypto.createHmac.call(void 0, "sha256", delivery.secret).update(body).digest("hex");
-    headers["X-Objectstack-Signature"] = `sha256=${sig}`;
-  }
-  const timeoutMs = _nullishCoalesce(delivery.timeoutMs, () => ( DEFAULT_TIMEOUT_MS));
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  const start = Date.now();
-  try {
-    const res = await fetchImpl(delivery.url, {
-      method: _nullishCoalesce(delivery.method, () => ( "POST")),
-      headers,
-      body,
-      signal: controller.signal
-    });
-    clearTimeout(timer);
-    const responseText = await safeReadBody(res);
-    const durationMs = Date.now() - start;
-    if (res.ok) {
-      return { success: true, httpStatus: res.status, responseBody: responseText, durationMs };
-    }
-    const retriable = res.status === 408 || res.status === 429 || res.status >= 500;
-    return {
-      success: false,
-      retriable,
-      httpStatus: res.status,
-      responseBody: responseText,
-      error: `HTTP ${res.status}`,
-      durationMs
-    };
-  } catch (err) {
-    clearTimeout(timer);
-    const durationMs = Date.now() - start;
-    const e = err;
-    const error = _optionalChain([e, 'optionalAccess', _32 => _32.name]) === "AbortError" ? `timeout after ${timeoutMs}ms` : _nullishCoalesce(_optionalChain([e, 'optionalAccess', _33 => _33.message]), () => ( String(err)));
-    return { success: false, retriable: true, error, durationMs };
-  }
-}
-async function safeReadBody(res) {
-  try {
-    const text = await res.text();
-    return text.length > RESPONSE_BODY_CAP ? text.slice(0, RESPONSE_BODY_CAP) : text;
-  } catch (e3) {
-    return void 0;
-  }
-}
-function nextRetryDelayMs(attemptsSoFar, rng = Math.random) {
-  const SCHEDULE = [1e3, 1e4, 6e4, 6e5, 36e5, 216e5, 864e5];
-  if (attemptsSoFar < 1 || attemptsSoFar > SCHEDULE.length) return null;
-  const base = SCHEDULE[attemptsSoFar - 1];
-  const jitter = 0.8 + rng() * 0.4;
-  return Math.floor(base * jitter);
-}
-function classifyAttempt(outcome, attemptsSoFar, now = Date.now(), rng) {
-  if (outcome.success) return outcome;
-  if (!outcome.retriable) {
-    return {
-      success: false,
-      httpStatus: outcome.httpStatus,
-      responseBody: outcome.responseBody,
-      error: outcome.error,
-      durationMs: outcome.durationMs,
-      dead: true
-    };
-  }
-  const delay = nextRetryDelayMs(attemptsSoFar + 1, rng);
-  if (delay === null) {
-    return {
-      success: false,
-      httpStatus: outcome.httpStatus,
-      responseBody: outcome.responseBody,
-      error: outcome.error,
-      durationMs: outcome.durationMs,
-      dead: true
-    };
-  }
-  return {
-    success: false,
-    httpStatus: outcome.httpStatus,
-    responseBody: outcome.responseBody,
-    error: outcome.error,
-    durationMs: outcome.durationMs,
-    nextRetryAt: now + delay
-  };
-}
-
-// src/dispatcher.ts
-var WebhookDispatcher = class {
-  constructor(options) {
-    this.running = false;
-    const intervalMs = _nullishCoalesce(options.intervalMs, () => ( 250));
-    const lockTtlMs = _nullishCoalesce(options.lockTtlMs, () => ( intervalMs * 5));
-    this.opts = {
-      nodeId: options.nodeId,
-      cluster: options.cluster,
-      outbox: options.outbox,
-      partitionCount: _nullishCoalesce(options.partitionCount, () => ( 8)),
-      batchSize: _nullishCoalesce(options.batchSize, () => ( 32)),
-      intervalMs,
-      lockTtlMs,
-      claimTtlMs: _nullishCoalesce(options.claimTtlMs, () => ( lockTtlMs * 2)),
-      onAttempt: options.onAttempt,
-      fetchImpl: options.fetchImpl,
-      rng: options.rng,
-      logger: options.logger
-    };
-  }
-  /** Begin the periodic loop. Safe to call once; subsequent calls are no-ops. */
-  start() {
-    if (this.running) return;
-    this.running = true;
-    this.scheduleTick();
-    this.timer = setInterval(() => this.scheduleTick(), this.opts.intervalMs);
-  }
-  /** Stop the loop and wait for the in-flight tick to drain. */
-  async stop() {
-    if (!this.running) return;
-    this.running = false;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = void 0;
-    }
-    if (this.inflightTick) {
-      try {
-        await this.inflightTick;
-      } catch (e4) {
-      }
-    }
-  }
-  /**
-   * Run one full tick (all partitions, single attempt each). Exposed for
-   * deterministic tests that want to step the dispatcher manually.
-   */
-  async tick() {
-    await this.runTick();
-  }
-  scheduleTick() {
-    if (this.inflightTick) return;
-    this.inflightTick = this.runTick().catch((err) => {
-      _optionalChain([this, 'access', _34 => _34.opts, 'access', _35 => _35.logger, 'optionalAccess', _36 => _36.warn, 'optionalCall', _37 => _37("webhook-dispatcher: tick failed", {
-        nodeId: this.opts.nodeId,
-        error: _nullishCoalesce(_optionalChain([err, 'optionalAccess', _38 => _38.message]), () => ( String(err)))
-      })]);
-    }).finally(() => {
-      this.inflightTick = void 0;
-    });
-  }
-  async runTick() {
-    const partitionCount = this.opts.partitionCount;
-    const offset = stableNodeOffset(this.opts.nodeId, partitionCount);
-    for (let step = 0; step < partitionCount; step++) {
-      const i = (offset + step) % partitionCount;
-      await this.runPartition(i);
-    }
-  }
-  async runPartition(index) {
-    const key = `webhook.dispatcher.partition.${index}`;
-    const handle = await this.opts.cluster.lock.acquire(key, {
-      ttlMs: this.opts.lockTtlMs,
-      // waitMs=0 → fail-fast; we'll try this partition again next tick.
-      waitMs: 0
-    });
-    if (!handle) return;
-    try {
-      const claimed = await this.opts.outbox.claim({
-        nodeId: this.opts.nodeId,
-        limit: this.opts.batchSize,
-        partition: { index, count: this.opts.partitionCount },
-        claimTtlMs: this.opts.claimTtlMs
-      });
-      if (claimed.length === 0) return;
-      await handle.renew(this.opts.lockTtlMs);
-      for (const row of claimed) {
-        if (!handle.isHeld()) break;
-        await this.processRow(row);
-      }
-    } finally {
-      await handle.release();
-    }
-  }
-  async processRow(row) {
-    const fetchImpl = _nullishCoalesce(this.opts.fetchImpl, () => ( globalThis.fetch));
-    if (!fetchImpl) {
-      _optionalChain([this, 'access', _39 => _39.opts, 'access', _40 => _40.logger, 'optionalAccess', _41 => _41.warn, 'optionalCall', _42 => _42("webhook-dispatcher: no fetch impl available", {
-        rowId: row.id
-      })]);
-      await this.opts.outbox.ack(row.id, {
-        success: false,
-        error: "no fetch implementation",
-        durationMs: 0,
-        dead: true
-      });
-      return;
-    }
-    const outcome = await sendOnce(row, fetchImpl);
-    const result = classifyAttempt(outcome, row.attempts, Date.now(), this.opts.rng);
-    await this.opts.outbox.ack(row.id, result);
-    _optionalChain([this, 'access', _43 => _43.opts, 'access', _44 => _44.onAttempt, 'optionalCall', _45 => _45(row, result.success)]);
-  }
-};
-function stableNodeOffset(nodeId, partitionCount) {
-  let h = 0;
-  for (let i = 0; i < nodeId.length; i++) {
-    h = h * 31 + nodeId.charCodeAt(i) | 0;
-  }
-  return Math.abs(h) % partitionCount;
-}
-
-// src/memory-outbox.ts
-
-var MemoryWebhookOutbox = class {
-  constructor() {
-    this.rows = /* @__PURE__ */ new Map();
-    /** Dedup index keyed by `${eventId}::${webhookId}` -> row id. */
-    this.dedup = /* @__PURE__ */ new Map();
-  }
-  async enqueue(input) {
-    const dedupKey = `${input.eventId}::${input.webhookId}`;
-    const existing = this.dedup.get(dedupKey);
-    if (existing) return existing;
-    const id = _crypto.randomUUID.call(void 0, );
-    const now = Date.now();
-    const row = {
-      id,
-      webhookId: input.webhookId,
-      eventId: input.eventId,
-      eventType: input.eventType,
-      url: input.url,
-      method: _nullishCoalesce(input.method, () => ( "POST")),
-      headers: input.headers,
-      secret: input.secret,
-      timeoutMs: input.timeoutMs,
-      payload: input.payload,
-      status: "pending",
-      attempts: 0,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.rows.set(id, row);
-    this.dedup.set(dedupKey, id);
-    return id;
-  }
-  async claim(opts) {
-    const now = _nullishCoalesce(opts.now, () => ( Date.now()));
-    const claimed = [];
-    for (const row of this.rows.values()) {
-      if (row.status === "in_flight" && row.claimedAt !== void 0 && now - row.claimedAt > opts.claimTtlMs) {
-        row.status = "pending";
-        row.claimedBy = void 0;
-        row.claimedAt = void 0;
-        row.updatedAt = now;
-      }
-    }
-    for (const row of this.rows.values()) {
-      if (claimed.length >= opts.limit) break;
-      if (row.status !== "pending") continue;
-      if (row.nextRetryAt !== void 0 && row.nextRetryAt > now) continue;
-      if (opts.partition) {
-        const p = _chunkHF7CCDPBcjs.hashPartition.call(void 0, row.webhookId, opts.partition.count);
-        if (p !== opts.partition.index) continue;
-      }
-      row.status = "in_flight";
-      row.claimedBy = opts.nodeId;
-      row.claimedAt = now;
-      row.updatedAt = now;
-      claimed.push({ ...row });
-    }
-    return claimed;
-  }
-  async ack(id, result) {
-    const row = this.rows.get(id);
-    if (!row) return;
-    const now = Date.now();
-    row.attempts += 1;
-    row.lastAttemptedAt = now;
-    row.updatedAt = now;
-    row.claimedBy = void 0;
-    row.claimedAt = void 0;
-    row.responseCode = result.httpStatus;
-    row.responseBody = result.responseBody;
-    let status;
-    if (result.success) {
-      status = "success";
-      row.nextRetryAt = void 0;
-      row.error = void 0;
-    } else if (result.dead) {
-      status = "dead";
-      row.error = result.error;
-      row.nextRetryAt = void 0;
-    } else {
-      status = "pending";
-      row.error = result.error;
-      row.nextRetryAt = result.nextRetryAt;
-    }
-    row.status = status;
-  }
-  async list(filter) {
-    const all = Array.from(this.rows.values()).map((r) => ({ ...r }));
-    return _optionalChain([filter, 'optionalAccess', _46 => _46.status]) ? all.filter((r) => r.status === filter.status) : all;
-  }
-  async redeliver(id) {
-    const row = this.rows.get(id);
-    if (!row) {
-      throw new (0, _chunkHF7CCDPBcjs.RedeliverError)(
-        `Delivery row '${id}' not found`,
-        "not_found"
-      );
-    }
-    if (row.status !== "success" && row.status !== "failed" && row.status !== "dead") {
-      throw new (0, _chunkHF7CCDPBcjs.RedeliverError)(
-        `Delivery row '${id}' is '${row.status}', expected one of: success, failed, dead`,
-        "not_eligible"
-      );
-    }
-    const now = Date.now();
-    row.status = "pending";
-    row.attempts = 0;
-    row.claimedBy = void 0;
-    row.claimedAt = void 0;
-    row.nextRetryAt = void 0;
-    row.error = void 0;
-    row.responseCode = void 0;
-    row.responseBody = void 0;
-    row.updatedAt = now;
-    return { ...row };
-  }
-};
-
-// src/retention.ts
-var DEFAULTS = {
-  successTtlMs: 7 * 24 * 60 * 60 * 1e3,
-  deadTtlMs: 30 * 24 * 60 * 60 * 1e3,
-  sweepIntervalMs: 60 * 60 * 1e3
-};
-var DeliveryRetentionSweeper = class {
-  constructor(engine, opts = {}) {
-    this.engine = engine;
-    this.running = false;
-    this.objectName = _nullishCoalesce(opts.objectName, () => ( _chunkTDSI7UHYcjs.SYS_WEBHOOK_DELIVERY));
-    this.successTtlMs = _nullishCoalesce(opts.successTtlMs, () => ( DEFAULTS.successTtlMs));
-    this.deadTtlMs = _nullishCoalesce(opts.deadTtlMs, () => ( DEFAULTS.deadTtlMs));
-    this.sweepIntervalMs = _nullishCoalesce(opts.sweepIntervalMs, () => ( DEFAULTS.sweepIntervalMs));
-    this.logger = _nullishCoalesce(opts.logger, () => ( {}));
-  }
-  start() {
-    if (this.running) return;
-    this.running = true;
-    this.timer = setInterval(() => {
-      this.sweep().catch(
-        (err) => _optionalChain([this, 'access', _47 => _47.logger, 'access', _48 => _48.warn, 'optionalCall', _49 => _49("[webhook-retention] sweep failed", err)])
-      );
-    }, this.sweepIntervalMs);
-    _optionalChain([this, 'access', _50 => _50.timer, 'access', _51 => _51.unref, 'optionalCall', _52 => _52()]);
-  }
-  stop() {
-    if (!this.running) return;
-    this.running = false;
-    if (this.timer) clearInterval(this.timer);
-    this.timer = void 0;
-  }
-  /** Run one sweep immediately. Returns the number of rows deleted. */
-  async sweep(now = Date.now()) {
-    let successDeleted = 0;
-    let deadDeleted = 0;
-    if (this.successTtlMs > 0) {
-      try {
-        const res = await this.engine.delete(this.objectName, {
-          where: {
-            status: "success",
-            updated_at: { $lt: now - this.successTtlMs }
-          }
-        });
-        successDeleted = _nullishCoalesce(_optionalChain([res, 'optionalAccess', _53 => _53.affected]), () => ( 0));
-      } catch (err) {
-        _optionalChain([this, 'access', _54 => _54.logger, 'access', _55 => _55.warn, 'optionalCall', _56 => _56("[webhook-retention] success sweep failed", err)]);
-      }
-    }
-    if (this.deadTtlMs > 0) {
-      try {
-        const res = await this.engine.delete(this.objectName, {
-          where: {
-            status: "dead",
-            updated_at: { $lt: now - this.deadTtlMs }
-          }
-        });
-        deadDeleted = _nullishCoalesce(_optionalChain([res, 'optionalAccess', _57 => _57.affected]), () => ( 0));
-      } catch (err) {
-        _optionalChain([this, 'access', _58 => _58.logger, 'access', _59 => _59.warn, 'optionalCall', _60 => _60("[webhook-retention] dead sweep failed", err)]);
-      }
-    }
-    if (successDeleted + deadDeleted > 0) {
-      _optionalChain([this, 'access', _61 => _61.logger, 'access', _62 => _62.info, 'optionalCall', _63 => _63("[webhook-retention] sweep complete", {
-        success: successDeleted,
-        dead: deadDeleted
-      })]);
-    }
-    return { success: successDeleted, dead: deadDeleted };
-  }
-};
-
 // src/webhook-outbox-plugin.ts
 var WebhookOutboxPlugin = class {
   constructor(options = {}) {
     this.options = options;
     this.name = "com.objectstack.plugin-webhook-outbox";
-    this.version = "1.1.0";
+    this.version = "2.0.0";
     this.type = "standard";
-    this.dependencies = ["com.objectstack.service.cluster"];
+    this.dependencies = ["com.objectstack.service.messaging"];
   }
   async init(ctx) {
-    const cluster = ctx.getService("cluster");
-    if (!cluster) {
-      throw new Error(
-        'WebhookOutboxPlugin: required service "cluster" not found \u2014 register ClusterServicePlugin first'
-      );
-    }
     const manifest = ctx.getService("manifest");
     if (manifest && typeof manifest.register === "function") {
       manifest.register({
@@ -642,13 +213,9 @@ var WebhookOutboxPlugin = class {
         version: this.version,
         type: "plugin",
         scope: "system",
-        name: "Webhook Outbox Schemas",
-        description: "Registers sys_webhook (configuration) and sys_webhook_delivery (durable outbox telemetry).",
-        objects: [_chunkTDSI7UHYcjs.SysWebhook, _chunkTDSI7UHYcjs.SysWebhookDelivery],
-        // ADR-0029 D7 — contribute the Webhooks entries into the
-        // Setup app's `group_integrations` slot. The plugin owns these
-        // objects (K2.a), so it ships their menu too; when the plugin
-        // isn't installed the slot stays empty.
+        name: "Webhook Schemas",
+        description: "Registers sys_webhook (configuration). Deliveries use messaging's sys_http_delivery outbox.",
+        objects: [_chunkKPKLAXNAcjs.SysWebhook],
         navigationContributions: [
           {
             app: "setup",
@@ -656,14 +223,14 @@ var WebhookOutboxPlugin = class {
             priority: 100,
             items: [
               { id: "nav_webhooks", type: "object", label: "Webhooks", objectName: "sys_webhook", icon: "webhook", requiresObject: "sys_webhook" },
-              { id: "nav_webhook_deliveries", type: "object", label: "Webhook Deliveries", objectName: "sys_webhook_delivery", icon: "send", requiresObject: "sys_webhook_delivery" }
+              { id: "nav_http_deliveries", type: "object", label: "HTTP Deliveries", objectName: "sys_http_delivery", icon: "send", requiresObject: "sys_http_delivery" }
             ]
           }
         ]
       });
     } else {
-      _optionalChain([ctx, 'access', _64 => _64.logger, 'access', _65 => _65.warn, 'optionalCall', _66 => _66(
-        "[webhook-outbox] manifest service unavailable \u2014 sys_webhook / sys_webhook_delivery will NOT appear in REST or Studio nav. Register MetadataService before WebhookOutboxPlugin."
+      _optionalChain([ctx, 'access', _32 => _32.logger, 'access', _33 => _33.warn, 'optionalCall', _34 => _34(
+        "[webhook-outbox] manifest service unavailable \u2014 sys_webhook will NOT appear in REST or Studio nav. Register MetadataService before WebhookOutboxPlugin."
       )]);
     }
     if (typeof ctx.hook === "function") {
@@ -676,235 +243,122 @@ var WebhookOutboxPlugin = class {
               i18n.loadTranslations(locale, data);
             }
           }
-        } catch (e5) {
+        } catch (e2) {
         }
       });
     }
-    const outbox = this.resolveOutbox(ctx);
-    this.outboxInstance = outbox;
-    const nodeId = _nullishCoalesce(_nullishCoalesce(this.options.nodeId, () => ( _types.readEnvWithDeprecation.call(void 0, "OS_NODE_ID", "OBJECTSTACK_NODE_ID"))), () => ( `node-${Math.random().toString(36).slice(2, 10)}`));
-    const dispatcher = new WebhookDispatcher({
-      nodeId,
-      cluster,
-      outbox,
-      partitionCount: this.options.partitionCount,
-      batchSize: this.options.batchSize,
-      intervalMs: this.options.intervalMs,
-      lockTtlMs: this.options.lockTtlMs,
-      claimTtlMs: this.options.claimTtlMs,
-      fetchImpl: this.options.fetchImpl,
-      onAttempt: this.options.onAttempt,
-      rng: this.options.rng,
-      logger: ctx.logger
-    });
-    this.dispatcher = dispatcher;
-    ctx.registerService("webhook.outbox", outbox);
-    ctx.registerService("webhook.dispatcher", dispatcher);
-    if (this.options.autoStart !== false) {
-      dispatcher.start();
-    }
-    const usingMemoryOutbox = outbox instanceof MemoryWebhookOutbox;
-    if (usingMemoryOutbox && process.env.NODE_ENV === "production") {
-      _optionalChain([ctx, 'access', _67 => _67.logger, 'access', _68 => _68.warn, 'optionalCall', _69 => _69(
-        "[webhook-outbox] MemoryWebhookOutbox in production \u2014 webhook deliveries WILL be lost on process exit. Ensure ObjectQL is registered before WebhookOutboxPlugin so the SQL outbox can auto-select."
-      )]);
-    }
     const autoEnqueueOpt = _nullishCoalesce(this.options.autoEnqueue, () => ( true));
-    const retentionOpt = _nullishCoalesce(this.options.retention, () => ( true));
-    const needsReadyHook = autoEnqueueOpt !== false || retentionOpt !== false;
-    if (needsReadyHook && typeof ctx.hook === "function") {
+    if (typeof ctx.hook === "function") {
       ctx.hook("kernel:ready", async () => {
         await this.bootAutoEnqueue(ctx, autoEnqueueOpt);
-        this.bootRetention(ctx, retentionOpt);
-      });
-    }
-    if (typeof ctx.hook === "function") {
-      ctx.hook("kernel:ready", () => {
         this.registerAdminRoutes(ctx);
       });
     }
-    _optionalChain([ctx, 'access', _70 => _70.logger, 'access', _71 => _71.info, 'optionalCall', _72 => _72("[webhook-outbox] initialised", {
-      nodeId,
-      partitions: _nullishCoalesce(this.options.partitionCount, () => ( 8)),
-      interval: _nullishCoalesce(this.options.intervalMs, () => ( 250)),
-      autoEnqueue: autoEnqueueOpt !== false,
-      retention: retentionOpt !== false
+    _optionalChain([ctx, 'access', _35 => _35.logger, 'access', _36 => _36.info, 'optionalCall', _37 => _37("[webhook-outbox] initialised (delivery via shared messaging HTTP outbox)", {
+      autoEnqueue: autoEnqueueOpt !== false
     })]);
   }
   async dispose() {
-    await _optionalChain([this, 'access', _73 => _73.autoEnqueuer, 'optionalAccess', _74 => _74.stop, 'call', _75 => _75()]);
-    _optionalChain([this, 'access', _76 => _76.retention, 'optionalAccess', _77 => _77.stop, 'call', _78 => _78()]);
-    await _optionalChain([this, 'access', _79 => _79.dispatcher, 'optionalAccess', _80 => _80.stop, 'call', _81 => _81()]);
+    await _optionalChain([this, 'access', _38 => _38.autoEnqueuer, 'optionalAccess', _39 => _39.stop, 'call', _40 => _40()]);
   }
-  resolveOutbox(ctx) {
-    const opt = this.options.outbox;
-    if (opt) {
-      return typeof opt === "function" ? opt(ctx) : opt;
-    }
-    const engine = this.tryGetService(ctx, ["objectql", "data"]);
-    if (engine) {
-      const partitionCount = _nullishCoalesce(this.options.partitionCount, () => ( 8));
-      const sql = new (0, _chunkHF7CCDPBcjs.SqlWebhookOutbox)(engine, { partitionCount });
-      _optionalChain([ctx, 'access', _82 => _82.logger, 'access', _83 => _83.info, 'optionalCall', _84 => _84(
-        "[webhook-outbox] auto-selected SqlWebhookOutbox (objectql engine detected)",
-        { partitionCount }
-      )]);
-      return sql;
-    }
-    _optionalChain([ctx, 'access', _85 => _85.logger, 'access', _86 => _86.warn, 'optionalCall', _87 => _87(
-      "[webhook-outbox] no IDataEngine available \u2014 falling back to MemoryWebhookOutbox. Deliveries will NOT survive process restart and the redeliver REST endpoint will not see rows written through ObjectQL."
-    )]);
-    return new MemoryWebhookOutbox();
+  getMessaging(ctx) {
+    const svc = this.tryGetService(ctx, ["messaging"]);
+    return svc && typeof svc.enqueueHttp === "function" ? svc : void 0;
   }
   async bootAutoEnqueue(ctx, opt) {
     if (opt === false) return;
     const engine = this.tryGetService(ctx, ["objectql", "data"]);
     const realtime = this.tryGetService(ctx, ["realtime"]);
-    if (!engine || !realtime) {
-      _optionalChain([ctx, 'access', _88 => _88.logger, 'access', _89 => _89.warn, 'optionalCall', _90 => _90(
-        "[webhook-auto-enqueuer] disabled \u2014 ObjectQL or Realtime service not available",
-        { hasEngine: !!engine, hasRealtime: !!realtime }
+    const messaging = this.getMessaging(ctx);
+    if (!engine || !realtime || !messaging) {
+      _optionalChain([ctx, 'access', _41 => _41.logger, 'access', _42 => _42.warn, 'optionalCall', _43 => _43(
+        "[webhook-auto-enqueuer] disabled \u2014 ObjectQL, Realtime, or Messaging service not available",
+        { hasEngine: !!engine, hasRealtime: !!realtime, hasMessaging: !!messaging }
       )]);
       return;
     }
-    if (!this.outboxInstance) return;
+    if (!messaging.isHttpDeliveryReady()) {
+      _optionalChain([ctx, 'access', _44 => _44.logger, 'access', _45 => _45.warn, 'optionalCall', _46 => _46(
+        "[webhook-auto-enqueuer] messaging HTTP outbox not ready (no data engine / reliableDelivery off) \u2014 webhook deliveries will not be durable"
+      )]);
+    }
     const enqOpts = typeof opt === "object" ? opt : {};
     this.autoEnqueuer = new AutoEnqueuer(
       engine,
       realtime,
-      this.outboxInstance,
+      (input) => messaging.enqueueHttp(input),
       { ...enqOpts, logger: ctx.logger }
     );
     await this.autoEnqueuer.start();
     ctx.registerService("webhook.autoEnqueuer", this.autoEnqueuer);
-    _optionalChain([ctx, 'access', _91 => _91.logger, 'access', _92 => _92.info, 'optionalCall', _93 => _93("[webhook-auto-enqueuer] started")]);
-  }
-  bootRetention(ctx, opt) {
-    if (opt === false) return;
-    if (this.outboxInstance instanceof MemoryWebhookOutbox) return;
-    const engine = this.tryGetService(ctx, ["objectql", "data"]);
-    if (!engine) {
-      _optionalChain([ctx, 'access', _94 => _94.logger, 'access', _95 => _95.warn, 'optionalCall', _96 => _96(
-        "[webhook-retention] disabled \u2014 ObjectQL service not available"
-      )]);
-      return;
-    }
-    const retOpts = typeof opt === "object" ? opt : {};
-    this.retention = new DeliveryRetentionSweeper(engine, {
-      ...retOpts,
-      logger: ctx.logger
-    });
-    this.retention.start();
-    ctx.registerService("webhook.retention", this.retention);
-    _optionalChain([ctx, 'access', _97 => _97.logger, 'access', _98 => _98.info, 'optionalCall', _99 => _99("[webhook-retention] sweeper started")]);
+    _optionalChain([ctx, 'access', _47 => _47.logger, 'access', _48 => _48.info, 'optionalCall', _49 => _49("[webhook-auto-enqueuer] started (enqueues source=webhook onto sys_http_delivery)")]);
   }
   tryGetService(ctx, names) {
     for (const n of names) {
       try {
         const svc = ctx.getService(n);
         if (svc) return svc;
-      } catch (e6) {
+      } catch (e3) {
       }
     }
     return void 0;
   }
   /**
-   * Mount POST /api/v1/webhooks/redeliver on the host Hono app, if one
-   * is available. Silently no-ops in environments without an HTTP
-   * server (MSW, edge tests, pure library use). Auth is delegated to
-   * the better-auth session cookie — every authenticated user counts.
+   * Mount POST /api/v1/webhooks/redeliver on the host Hono app, if one is
+   * available. Delegates to `messaging.redeliverHttp(deliveryId)`. Auth is the
+   * better-auth session cookie — every authenticated user counts.
    */
   registerAdminRoutes(ctx) {
     const http = this.tryGetService(ctx, ["http-server"]);
     if (!http || typeof http.getRawApp !== "function") {
-      _optionalChain([ctx, 'access', _100 => _100.logger, 'access', _101 => _101.debug, 'optionalCall', _102 => _102(
-        "[webhook-outbox] HTTP server not available; redeliver REST endpoint not mounted"
-      )]);
+      _optionalChain([ctx, 'access', _50 => _50.logger, 'access', _51 => _51.debug, 'optionalCall', _52 => _52("[webhook-outbox] HTTP server not available; redeliver endpoint not mounted")]);
       return;
     }
     const rawApp = http.getRawApp();
-    const outbox = this.outboxInstance;
-    if (!rawApp || !outbox) return;
+    const messaging = this.getMessaging(ctx);
+    if (!rawApp || !messaging) return;
     rawApp.post("/api/v1/webhooks/redeliver", async (c) => {
       const userId = await this.resolveSessionUserId(ctx, c);
       if (!userId) {
         return c.json(
-          {
-            success: false,
-            error: "unauthenticated",
-            message: "Sign in to redeliver webhook deliveries."
-          },
+          { success: false, error: "unauthenticated", message: "Sign in to redeliver webhook deliveries." },
           401
         );
       }
       let body;
       try {
         body = await c.req.json();
-      } catch (e7) {
-        return c.json(
-          {
-            success: false,
-            error: "invalid_body",
-            message: "Request body must be JSON."
-          },
-          400
-        );
+      } catch (e4) {
+        return c.json({ success: false, error: "invalid_body", message: "Request body must be JSON." }, 400);
       }
-      const deliveryId = typeof _optionalChain([body, 'optionalAccess', _103 => _103.deliveryId]) === "string" ? body.deliveryId.trim() : "";
+      const deliveryId = typeof _optionalChain([body, 'optionalAccess', _53 => _53.deliveryId]) === "string" ? body.deliveryId.trim() : "";
       if (!deliveryId) {
         return c.json(
-          {
-            success: false,
-            error: "missing_delivery_id",
-            message: "Body must include `deliveryId: string`."
-          },
+          { success: false, error: "missing_delivery_id", message: "Body must include `deliveryId: string`." },
           400
         );
       }
       try {
-        const row = await outbox.redeliver(deliveryId);
-        _optionalChain([ctx, 'access', _104 => _104.logger, 'access', _105 => _105.info, 'optionalCall', _106 => _106("[webhook-outbox] redelivered", {
-          deliveryId,
-          requestedBy: userId
-        })]);
+        const row = await messaging.redeliverHttp(deliveryId);
+        _optionalChain([ctx, 'access', _54 => _54.logger, 'access', _55 => _55.info, 'optionalCall', _56 => _56("[webhook-outbox] redelivered", { deliveryId, requestedBy: userId })]);
         return c.json({ success: true, data: { id: row.id, status: row.status } });
       } catch (err) {
-        const code = _optionalChain([err, 'optionalAccess', _107 => _107.code]);
+        const code = _optionalChain([err, 'optionalAccess', _57 => _57.code]);
         if (code === "not_found") {
-          return c.json(
-            { success: false, error: "not_found", message: err.message },
-            404
-          );
+          return c.json({ success: false, error: "not_found", message: err.message }, 404);
         }
         if (code === "not_eligible") {
-          return c.json(
-            { success: false, error: "not_eligible", message: err.message },
-            409
-          );
+          return c.json({ success: false, error: "not_eligible", message: err.message }, 409);
         }
-        _optionalChain([ctx, 'access', _108 => _108.logger, 'access', _109 => _109.error, 'optionalCall', _110 => _110(
-          "[webhook-outbox] redeliver failed",
-          err
-        )]);
+        _optionalChain([ctx, 'access', _58 => _58.logger, 'access', _59 => _59.error, 'optionalCall', _60 => _60("[webhook-outbox] redeliver failed", err)]);
         return c.json(
-          {
-            success: false,
-            error: "internal_error",
-            message: _nullishCoalesce(_optionalChain([err, 'optionalAccess', _111 => _111.message]), () => ( String(err)))
-          },
+          { success: false, error: "internal_error", message: _nullishCoalesce(_optionalChain([err, 'optionalAccess', _61 => _61.message]), () => ( String(err))) },
           500
         );
       }
     });
-    _optionalChain([ctx, 'access', _112 => _112.logger, 'access', _113 => _113.info, 'optionalCall', _114 => _114(
-      "[webhook-outbox] redeliver endpoint mounted at POST /api/v1/webhooks/redeliver"
-    )]);
+    _optionalChain([ctx, 'access', _62 => _62.logger, 'access', _63 => _63.info, 'optionalCall', _64 => _64("[webhook-outbox] redeliver endpoint mounted at POST /api/v1/webhooks/redeliver")]);
   }
-  /**
-   * Resolve the requesting user's id from a better-auth session cookie.
-   * Returns `undefined` for anonymous callers — the caller decides
-   * whether that's a 401.
-   */
   async resolveSessionUserId(ctx, c) {
     try {
       const authService = this.tryGetService(ctx, ["auth"]);
@@ -913,11 +367,11 @@ var WebhookOutboxPlugin = class {
       if (!api && typeof authService.getApi === "function") {
         api = await authService.getApi();
       }
-      if (!_optionalChain([api, 'optionalAccess', _115 => _115.getSession])) return void 0;
+      if (!_optionalChain([api, 'optionalAccess', _65 => _65.getSession])) return void 0;
       const session = await api.getSession({ headers: c.req.raw.headers });
-      const uid = _optionalChain([session, 'optionalAccess', _116 => _116.user, 'optionalAccess', _117 => _117.id]);
+      const uid = _optionalChain([session, 'optionalAccess', _66 => _66.user, 'optionalAccess', _67 => _67.id]);
       return typeof uid === "string" && uid.length > 0 ? uid : void 0;
-    } catch (e8) {
+    } catch (e5) {
       return void 0;
     }
   }
@@ -926,13 +380,5 @@ var WebhookOutboxPlugin = class {
 
 
 
-
-
-
-
-
-
-
-
-exports.AutoEnqueuer = AutoEnqueuer; exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS; exports.DeliveryRetentionSweeper = DeliveryRetentionSweeper; exports.MemoryWebhookOutbox = MemoryWebhookOutbox; exports.RedeliverError = _chunkHF7CCDPBcjs.RedeliverError; exports.WebhookDispatcher = WebhookDispatcher; exports.WebhookOutboxPlugin = WebhookOutboxPlugin; exports.classifyAttempt = classifyAttempt; exports.hashPartition = _chunkHF7CCDPBcjs.hashPartition; exports.nextRetryDelayMs = nextRetryDelayMs; exports.sendOnce = sendOnce;
+exports.AutoEnqueuer = AutoEnqueuer; exports.SysWebhook = _chunkKPKLAXNAcjs.SysWebhook; exports.WebhookOutboxPlugin = WebhookOutboxPlugin;
 //# sourceMappingURL=index.cjs.map