@objectstack/plugin-webhooks 7.5.0 → 7.6.0

package/dist/index.js

@@ -1,23 +1,13 @@
 import {
-  RedeliverError,
-  SqlWebhookOutbox,
-  hashPartition
-} from "./chunk-KNGLLSSP.js";
-import {
-  SYS_WEBHOOK_DELIVERY,
-  SysWebhook,
-  SysWebhookDelivery
-} from "./chunk-7HS5DLU2.js";
-
-// src/webhook-outbox-plugin.ts
-import { readEnvWithDeprecation } from "@objectstack/types";
+  SysWebhook
+} from "./chunk-HWFTXTTI.js";
 
 // 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 = opts.subscriptionsObject ?? "sys_webhook";
@@ -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
-import { createHmac, randomUUID } from "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),
-    ...delivery.headers ?? {}
-  };
-  if (delivery.secret) {
-    const sig = createHmac("sha256", delivery.secret).update(body).digest("hex");
-    headers["X-Objectstack-Signature"] = `sha256=${sig}`;
-  }
-  const timeoutMs = 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: 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 = e?.name === "AbortError" ? `timeout after ${timeoutMs}ms` : e?.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 {
-    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 = options.intervalMs ?? 250;
-    const lockTtlMs = options.lockTtlMs ?? intervalMs * 5;
-    this.opts = {
-      nodeId: options.nodeId,
-      cluster: options.cluster,
-      outbox: options.outbox,
-      partitionCount: options.partitionCount ?? 8,
-      batchSize: options.batchSize ?? 32,
-      intervalMs,
-      lockTtlMs,
-      claimTtlMs: 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 {
-      }
-    }
-  }
-  /**
-   * 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) => {
-      this.opts.logger?.warn?.("webhook-dispatcher: tick failed", {
-        nodeId: this.opts.nodeId,
-        error: err?.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 = this.opts.fetchImpl ?? globalThis.fetch;
-    if (!fetchImpl) {
-      this.opts.logger?.warn?.("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);
-    this.opts.onAttempt?.(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
-import { randomUUID as randomUUID2 } from "crypto";
-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 = randomUUID2();
-    const now = Date.now();
-    const row = {
-      id,
-      webhookId: input.webhookId,
-      eventId: input.eventId,
-      eventType: input.eventType,
-      url: input.url,
-      method: 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 = 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 = hashPartition(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 filter?.status ? all.filter((r) => r.status === filter.status) : all;
-  }
-  async redeliver(id) {
-    const row = this.rows.get(id);
-    if (!row) {
-      throw new RedeliverError(
-        `Delivery row '${id}' not found`,
-        "not_found"
-      );
-    }
-    if (row.status !== "success" && row.status !== "failed" && row.status !== "dead") {
-      throw new 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 = opts.objectName ?? SYS_WEBHOOK_DELIVERY;
-    this.successTtlMs = opts.successTtlMs ?? DEFAULTS.successTtlMs;
-    this.deadTtlMs = opts.deadTtlMs ?? DEFAULTS.deadTtlMs;
-    this.sweepIntervalMs = opts.sweepIntervalMs ?? DEFAULTS.sweepIntervalMs;
-    this.logger = opts.logger ?? {};
-  }
-  start() {
-    if (this.running) return;
-    this.running = true;
-    this.timer = setInterval(() => {
-      this.sweep().catch(
-        (err) => this.logger.warn?.("[webhook-retention] sweep failed", err)
-      );
-    }, this.sweepIntervalMs);
-    this.timer.unref?.();
-  }
-  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 = res?.affected ?? 0;
-      } catch (err) {
-        this.logger.warn?.("[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 = res?.affected ?? 0;
-      } catch (err) {
-        this.logger.warn?.("[webhook-retention] dead sweep failed", err);
-      }
-    }
-    if (successDeleted + deadDeleted > 0) {
-      this.logger.info?.("[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: [SysWebhook, 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: [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 {
       ctx.logger.warn?.(
-        "[webhook-outbox] manifest service unavailable \u2014 sys_webhook / sys_webhook_delivery will NOT appear in REST or Studio nav. Register MetadataService before WebhookOutboxPlugin."
+        "[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") {
@@ -680,123 +247,51 @@ var WebhookOutboxPlugin = class {
         }
       });
     }
-    const outbox = this.resolveOutbox(ctx);
-    this.outboxInstance = outbox;
-    const nodeId = this.options.nodeId ?? readEnvWithDeprecation("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") {
-      ctx.logger.warn?.(
-        "[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 = this.options.autoEnqueue ?? true;
-    const retentionOpt = 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);
       });
     }
-    ctx.logger.info?.("[webhook-outbox] initialised", {
-      nodeId,
-      partitions: this.options.partitionCount ?? 8,
-      interval: this.options.intervalMs ?? 250,
-      autoEnqueue: autoEnqueueOpt !== false,
-      retention: retentionOpt !== false
+    ctx.logger.info?.("[webhook-outbox] initialised (delivery via shared messaging HTTP outbox)", {
+      autoEnqueue: autoEnqueueOpt !== false
     });
   }
   async dispose() {
     await this.autoEnqueuer?.stop();
-    this.retention?.stop();
-    await this.dispatcher?.stop();
   }
-  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 = this.options.partitionCount ?? 8;
-      const sql = new SqlWebhookOutbox(engine, { partitionCount });
-      ctx.logger.info?.(
-        "[webhook-outbox] auto-selected SqlWebhookOutbox (objectql engine detected)",
-        { partitionCount }
-      );
-      return sql;
-    }
-    ctx.logger.warn?.(
-      "[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) {
+    const messaging = this.getMessaging(ctx);
+    if (!engine || !realtime || !messaging) {
       ctx.logger.warn?.(
-        "[webhook-auto-enqueuer] disabled \u2014 ObjectQL or Realtime service not available",
-        { hasEngine: !!engine, hasRealtime: !!realtime }
+        "[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()) {
+      ctx.logger.warn?.(
+        "[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);
-    ctx.logger.info?.("[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) {
-      ctx.logger.warn?.(
-        "[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);
-    ctx.logger.info?.("[webhook-retention] sweeper started");
+    ctx.logger.info?.("[webhook-auto-enqueuer] started (enqueues source=webhook onto sys_http_delivery)");
   }
   tryGetService(ctx, names) {
     for (const n of names) {
@@ -809,31 +304,24 @@ var WebhookOutboxPlugin = class {
     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") {
-      ctx.logger.debug?.(
-        "[webhook-outbox] HTTP server not available; redeliver REST endpoint not mounted"
-      );
+      ctx.logger.debug?.("[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
         );
       }
@@ -841,70 +329,36 @@ var WebhookOutboxPlugin = class {
       try {
         body = await c.req.json();
       } catch {
-        return c.json(
-          {
-            success: false,
-            error: "invalid_body",
-            message: "Request body must be JSON."
-          },
-          400
-        );
+        return c.json({ success: false, error: "invalid_body", message: "Request body must be JSON." }, 400);
       }
       const deliveryId = typeof body?.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);
-        ctx.logger.info?.("[webhook-outbox] redelivered", {
-          deliveryId,
-          requestedBy: userId
-        });
+        const row = await messaging.redeliverHttp(deliveryId);
+        ctx.logger.info?.("[webhook-outbox] redelivered", { deliveryId, requestedBy: userId });
         return c.json({ success: true, data: { id: row.id, status: row.status } });
       } catch (err) {
         const code = err?.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);
         }
-        ctx.logger.error?.(
-          "[webhook-outbox] redeliver failed",
-          err
-        );
+        ctx.logger.error?.("[webhook-outbox] redeliver failed", err);
         return c.json(
-          {
-            success: false,
-            error: "internal_error",
-            message: err?.message ?? String(err)
-          },
+          { success: false, error: "internal_error", message: err?.message ?? String(err) },
           500
         );
       }
     });
-    ctx.logger.info?.(
-      "[webhook-outbox] redeliver endpoint mounted at POST /api/v1/webhooks/redeliver"
-    );
+    ctx.logger.info?.("[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"]);
@@ -924,15 +378,7 @@ var WebhookOutboxPlugin = class {
 };
 export {
   AutoEnqueuer,
-  DEFAULT_TIMEOUT_MS,
-  DeliveryRetentionSweeper,
-  MemoryWebhookOutbox,
-  RedeliverError,
-  WebhookDispatcher,
-  WebhookOutboxPlugin,
-  classifyAttempt,
-  hashPartition,
-  nextRetryDelayMs,
-  sendOnce
+  SysWebhook,
+  WebhookOutboxPlugin
 };
 //# sourceMappingURL=index.js.map