@objectstack/service-messaging 7.5.0 → 7.6.0

package/dist/index.cjs

@@ -20,13 +20,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_HTTP_TIMEOUT_MS: () => DEFAULT_HTTP_TIMEOUT_MS,
   DEFAULT_LOCALE: () => DEFAULT_LOCALE,
   DEFAULT_RETENTION_TARGETS: () => DEFAULT_RETENTION_TARGETS,
   DELIVERY_OBJECT: () => DELIVERY_OBJECT,
   EMAIL_USER_OBJECT: () => USER_OBJECT2,
+  HttpDelivery: () => HttpDelivery,
+  HttpDispatcher: () => HttpDispatcher,
+  HttpRedeliverError: () => HttpRedeliverError,
   INBOX_OBJECT: () => INBOX_OBJECT,
   InboxMessage: () => InboxMessage,
   MEMBER_OBJECT: () => MEMBER_OBJECT,
+  MemoryHttpOutbox: () => MemoryHttpOutbox,
   MemoryNotificationOutbox: () => MemoryNotificationOutbox,
   MessagingService: () => MessagingService,
   MessagingServicePlugin: () => MessagingServicePlugin,
@@ -43,23 +48,29 @@ __export(index_exports, {
   PreferenceResolver: () => PreferenceResolver,
   RECEIPT_OBJECT: () => RECEIPT_OBJECT,
   RecipientResolver: () => RecipientResolver,
+  SYS_HTTP_DELIVERY: () => SYS_HTTP_DELIVERY,
+  SqlHttpOutbox: () => SqlHttpOutbox,
   SqlNotificationOutbox: () => SqlNotificationOutbox,
   TEAM_MEMBER_OBJECT: () => TEAM_MEMBER_OBJECT,
   TEMPLATE_OBJECT: () => TEMPLATE_OBJECT,
   USER_OBJECT: () => USER_OBJECT,
   classifyDeliveryAttempt: () => classifyDeliveryAttempt,
+  classifyHttpAttempt: () => classifyAttempt,
   createEmailChannel: () => createEmailChannel,
   createInboxChannel: () => createInboxChannel,
   hashPartition: () => hashPartition,
   interpolate: () => interpolate,
+  newHttpDeliveryId: () => newDeliveryId,
+  nextHttpRetryDelayMs: () => nextHttpRetryDelayMs,
   nextRetryDelayMs: () => nextRetryDelayMs,
   quietHoursDeferral: () => quietHoursDeferral,
-  renderNotification: () => renderNotification
+  renderNotification: () => renderNotification,
+  sendHttpOnce: () => sendOnce
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/messaging-service-plugin.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto4 = require("crypto");
 
 // src/recipient-resolver.ts
 function looksLikeEmail(s) {
@@ -350,8 +361,81 @@ function msg2(err) {
   return err?.message ?? String(err);
 }
 
+// src/inbox-channel.ts
+var INBOX_OBJECT = "sys_inbox_message";
+var RECEIPT_OBJECT = "sys_notification_receipt";
+function createInboxChannel(opts) {
+  const objectName = opts.objectName ?? INBOX_OBJECT;
+  const receiptObject = opts.receiptObject ?? RECEIPT_OBJECT;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  async function writeDeliveredReceipt(ctx, data, r) {
+    if (!r.notificationId) return;
+    try {
+      await data.insert(receiptObject, {
+        notification_id: r.notificationId,
+        delivery_id: null,
+        user_id: r.userId,
+        channel: "inbox",
+        state: "delivered",
+        at: r.at,
+        organization_id: r.organizationId ?? null,
+        created_at: r.at
+      });
+    } catch (err) {
+      ctx.logger.warn(
+        `[inbox] delivered receipt write failed for '${r.userId}' (${err.message}); inbox row stands`
+      );
+    }
+  }
+  return {
+    id: "inbox",
+    async send(ctx, delivery) {
+      const data = opts.getData();
+      const n = delivery.notification;
+      if (!data) {
+        ctx.logger.warn(
+          `[inbox] no data engine registered; inbox row for '${delivery.recipient}' not persisted`
+        );
+        return { ok: true };
+      }
+      const userId = delivery.recipient;
+      const at = now();
+      const row = {
+        user_id: userId,
+        notification_id: n.notificationId ?? null,
+        topic: n.topic,
+        title: n.title,
+        body_md: n.body,
+        severity: n.severity ?? "info",
+        action_url: n.actionUrl,
+        organization_id: n.organizationId ?? null,
+        created_at: at
+      };
+      let inboxId;
+      try {
+        const created = await data.insert(objectName, row);
+        const id = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
+        inboxId = id != null ? String(id) : void 0;
+      } catch (err) {
+        return { ok: false, error: `inbox insert failed: ${err.message}` };
+      }
+      await writeDeliveredReceipt(ctx, data, {
+        notificationId: n.notificationId,
+        userId,
+        organizationId: n.organizationId,
+        at
+      });
+      return { ok: true, externalId: inboxId };
+    },
+    classifyError(_err) {
+      return "retryable";
+    }
+  };
+}
+
 // src/messaging-service.ts
 var NOTIFICATION_EVENT_OBJECT = "sys_notification";
+var READ_RECEIPT_STATES = /* @__PURE__ */ new Set(["read", "clicked", "dismissed"]);
 var MessagingService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -373,6 +457,49 @@ var MessagingService = class {
   setOutbox(outbox) {
     this.outbox = outbox;
   }
+  /**
+   * Attach the generic outbound-HTTP delivery outbox (ADR-0018 M3). Wired by
+   * the plugin at `kernel:ready` once the data engine is resolvable. Once set,
+   * {@link enqueueHttp} persists durable rows the {@link HttpDispatcher}
+   * drains with retry / dead-letter; the Flow `http` node enqueues through it.
+   */
+  setHttpOutbox(outbox) {
+    this.httpOutbox = outbox;
+  }
+  /**
+   * Whether durable HTTP delivery is available. Callers (e.g. the `http` node)
+   * fall back to a direct, non-durable send when this is `false`.
+   */
+  isHttpDeliveryReady() {
+    return this.httpOutbox !== void 0;
+  }
+  /**
+   * Enqueue a durable outbound-HTTP delivery (ADR-0018 M3). Returns the row id.
+   * Throws if no HTTP outbox is wired — guard with {@link isHttpDeliveryReady}.
+   */
+  async enqueueHttp(input) {
+    if (!this.httpOutbox) {
+      throw new Error("messaging: HTTP delivery outbox not configured (no data engine / reliableDelivery off)");
+    }
+    return this.httpOutbox.enqueue(input);
+  }
+  /**
+   * Reset a terminal HTTP delivery row back to `pending` so the dispatcher
+   * re-sends it (ADR-0018 M3). Backs the webhook redeliver admin endpoint.
+   * Throws if no HTTP outbox is wired, or `HttpRedeliverError` for a missing /
+   * non-terminal row.
+   */
+  async redeliverHttp(id) {
+    if (!this.httpOutbox) {
+      throw new Error("messaging: HTTP delivery outbox not configured");
+    }
+    return this.httpOutbox.redeliver(id);
+  }
+  /** List HTTP delivery rows (admin/tests). Empty when no outbox is wired. */
+  async listHttp(filter) {
+    if (!this.httpOutbox) return [];
+    return this.httpOutbox.list(filter);
+  }
   /** Register a channel implementation. A duplicate id warns and replaces. */
   registerChannel(channel) {
     if (this.channels.has(channel.id)) {
@@ -393,6 +520,119 @@ var MessagingService = class {
   getRegisteredChannels() {
     return [...this.channels.keys()];
   }
+  /* ------------------------------------------------------------------ */
+  /*  Inbox read API (ADR-0030) — backs /api/v1/notifications            */
+  /*                                                                     */
+  /*  The REST notification surface reads the L5 `sys_inbox_message`      */
+  /*  materialization joined with the `sys_notification_receipt`         */
+  /*  read-state spine — NOT the re-modeled `sys_notification` L2 event   */
+  /*  (which carries no recipient/read columns). Mark-read upserts the    */
+  /*  receipt, keyed `(notification_id, user_id, channel:'inbox')`.       */
+  /* ------------------------------------------------------------------ */
+  /**
+   * List the signed-in user's in-app inbox, joined with read-state.
+   *
+   * A message is unread until its event has a `read`/`clicked`/`dismissed`
+   * receipt; the `read` filter (when given) is applied in-memory after the
+   * join. `unreadCount` is computed over the fetched window (bounded by
+   * `limit`, like the Console bell's poll). Returns the REST contract shape
+   * (`ListNotificationsResponseSchema`): `{ notifications, unreadCount }`.
+   */
+  async listInbox(userId, opts = {}) {
+    const data = this.ctx.getData?.();
+    if (!data || !userId) return { notifications: [], unreadCount: 0 };
+    const limit = Math.min(Math.max(opts.limit ?? 50, 1), 200);
+    const where = { user_id: userId };
+    if (opts.type) where.topic = opts.type;
+    const [rows, receipts] = await Promise.all([
+      data.find(INBOX_OBJECT, { where, orderBy: [{ field: "created_at", order: "desc" }], limit }),
+      // Read-state spine. Best-effort: if receipts are unavailable the
+      // inbox still lists (everything reads as unread) rather than erroring.
+      data.find(RECEIPT_OBJECT, { where: { user_id: userId, channel: "inbox" } }).catch(() => [])
+    ]);
+    const stateByNotif = /* @__PURE__ */ new Map();
+    for (const r of receipts) {
+      const nid = r?.notification_id != null ? String(r.notification_id) : "";
+      if (!nid) continue;
+      const state = String(r.state ?? "delivered");
+      const prev = stateByNotif.get(nid);
+      if (!prev || !READ_RECEIPT_STATES.has(prev) && READ_RECEIPT_STATES.has(state)) {
+        stateByNotif.set(nid, state);
+      }
+    }
+    let unreadCount = 0;
+    const all = rows.map((m) => {
+      const nid = m?.notification_id != null ? String(m.notification_id) : null;
+      const state = nid ? stateByNotif.get(nid) : void 0;
+      const read = state ? READ_RECEIPT_STATES.has(state) : false;
+      if (!read) unreadCount += 1;
+      return {
+        id: nid ?? String(m.id),
+        type: m.topic ?? "notification",
+        title: m.title ?? "",
+        body: m.body_md ?? "",
+        read,
+        actionUrl: m.action_url ?? void 0,
+        createdAt: m.created_at ?? this.now()
+      };
+    });
+    const notifications = opts.read === void 0 ? all : all.filter((n) => n.read === opts.read);
+    return { notifications, unreadCount };
+  }
+  /**
+   * Mark specific notifications read by upserting their inbox receipts to
+   * `read`. Updates the existing `delivered` receipt in place (keyed
+   * `(notification_id, user_id, channel:'inbox')`); inserts one only when
+   * absent. `ids` are notification (event) ids. Returns the REST contract
+   * shape (`MarkNotificationsReadResponseSchema`): `{ success, readCount }`.
+   */
+  async markRead(userId, ids) {
+    const data = this.ctx.getData?.();
+    if (!data || !userId || !ids?.length) return { success: true, readCount: 0 };
+    const at = this.now();
+    let readCount = 0;
+    for (const id of ids) {
+      const nid = String(id ?? "");
+      if (!nid) continue;
+      try {
+        readCount += await this.upsertReadReceipt(data, userId, nid, at);
+      } catch (err) {
+        this.ctx.logger.warn(`[messaging] markRead failed for '${nid}': ${err.message}`);
+      }
+    }
+    return { success: true, readCount };
+  }
+  /**
+   * Mark every currently-unread inbox message for the user as read. Returns
+   * `{ success, readCount }` (`MarkAllNotificationsReadResponseSchema`).
+   */
+  async markAllRead(userId) {
+    const data = this.ctx.getData?.();
+    if (!data || !userId) return { success: true, readCount: 0 };
+    const { notifications } = await this.listInbox(userId, { read: false, limit: 200 });
+    return this.markRead(userId, notifications.map((n) => n.id));
+  }
+  /** Upsert a `read` receipt for one notification; returns 1 when it persisted. */
+  async upsertReadReceipt(data, userId, notificationId, at) {
+    const existing = await data.findOne(RECEIPT_OBJECT, {
+      where: { notification_id: notificationId, user_id: userId, channel: "inbox" },
+      fields: ["id"]
+    });
+    if (existing?.id) {
+      await data.update(RECEIPT_OBJECT, { state: "read", at }, { where: { id: existing.id } });
+    } else {
+      await data.insert(RECEIPT_OBJECT, {
+        notification_id: notificationId,
+        delivery_id: null,
+        user_id: userId,
+        channel: "inbox",
+        state: "read",
+        at,
+        created_at: at
+      });
+    }
+    return 1;
+  }
   /**
    * The single notification ingress. Writes the L2 event, resolves the
    * audience, and fans the result out to its channels. An unregistered
@@ -600,78 +840,6 @@ function actionUrlFor(input, payload) {
   return obj && id ? `/${obj}/${id}` : void 0;
 }
 
-// src/inbox-channel.ts
-var INBOX_OBJECT = "sys_inbox_message";
-var RECEIPT_OBJECT = "sys_notification_receipt";
-function createInboxChannel(opts) {
-  const objectName = opts.objectName ?? INBOX_OBJECT;
-  const receiptObject = opts.receiptObject ?? RECEIPT_OBJECT;
-  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  async function writeDeliveredReceipt(ctx, data, r) {
-    if (!r.notificationId) return;
-    try {
-      await data.insert(receiptObject, {
-        notification_id: r.notificationId,
-        delivery_id: null,
-        user_id: r.userId,
-        channel: "inbox",
-        state: "delivered",
-        at: r.at,
-        organization_id: r.organizationId ?? null,
-        created_at: r.at
-      });
-    } catch (err) {
-      ctx.logger.warn(
-        `[inbox] delivered receipt write failed for '${r.userId}' (${err.message}); inbox row stands`
-      );
-    }
-  }
-  return {
-    id: "inbox",
-    async send(ctx, delivery) {
-      const data = opts.getData();
-      const n = delivery.notification;
-      if (!data) {
-        ctx.logger.warn(
-          `[inbox] no data engine registered; inbox row for '${delivery.recipient}' not persisted`
-        );
-        return { ok: true };
-      }
-      const userId = delivery.recipient;
-      const at = now();
-      const row = {
-        user_id: userId,
-        notification_id: n.notificationId ?? null,
-        topic: n.topic,
-        title: n.title,
-        body_md: n.body,
-        severity: n.severity ?? "info",
-        action_url: n.actionUrl,
-        organization_id: n.organizationId ?? null,
-        created_at: at
-      };
-      let inboxId;
-      try {
-        const created = await data.insert(objectName, row);
-        const id = Array.isArray(created) ? created[0]?.id : created?.id ?? created;
-        inboxId = id != null ? String(id) : void 0;
-      } catch (err) {
-        return { ok: false, error: `inbox insert failed: ${err.message}` };
-      }
-      await writeDeliveredReceipt(ctx, data, {
-        notificationId: n.notificationId,
-        userId,
-        organizationId: n.organizationId,
-        at
-      });
-      return { ok: true, externalId: inboxId };
-    },
-    classifyError(_err) {
-      return "retryable";
-    }
-  };
-}
-
 // src/sql-outbox.ts
 var import_node_crypto = require("crypto");
 
@@ -737,9 +905,297 @@ var SqlNotificationOutbox = class {
       partition_key: hashPartition(input.notificationId, this.partitionCount),
       status: "pending",
       attempts: 0,
-      // Deferred dispatch (quiet-hours, P3): claim() skips pending rows
-      // whose next_attempt_at is in the future.
-      next_attempt_at: input.notBefore ?? null,
+      // Deferred dispatch (quiet-hours, P3): claim() skips pending rows
+      // whose next_attempt_at is in the future.
+      next_attempt_at: input.notBefore ?? null,
+      created_at: now,
+      updated_at: now
+    };
+    try {
+      await this.engine.insert(this.objectName, row);
+      return id;
+    } catch (err) {
+      const winner = await this.engine.findOne(this.objectName, { where: dedup, fields: ["id"] });
+      if (winner?.id) return String(winner.id);
+      throw err;
+    }
+  }
+  async claim(opts) {
+    const now = opts.now ?? Date.now();
+    await this.engine.update(
+      this.objectName,
+      { status: "pending", claimed_by: null, claimed_at: null, updated_at: now },
+      { where: { status: "in_flight", claimed_at: { $lt: now - opts.claimTtlMs } }, multi: true }
+    );
+    const partitionFilter = opts.partition ? { partition_key: opts.partition.index } : {};
+    const candidates = await this.engine.find(this.objectName, {
+      where: {
+        status: "pending",
+        ...partitionFilter,
+        $or: [{ next_attempt_at: null }, { next_attempt_at: { $lte: now } }]
+      },
+      fields: ["id"],
+      limit: opts.limit
+    });
+    if (!candidates.length) return [];
+    const ids = candidates.map((c) => c.id);
+    await this.engine.update(
+      this.objectName,
+      { status: "in_flight", claimed_by: opts.nodeId, claimed_at: now, updated_at: now },
+      { where: { id: { $in: ids }, status: "pending" }, multi: true }
+    );
+    const claimed = await this.engine.find(this.objectName, {
+      where: { id: { $in: ids }, claimed_by: opts.nodeId, claimed_at: now, status: "in_flight" }
+    });
+    return claimed.map((r) => this.toRecord(r));
+  }
+  async ack(id, result) {
+    const current = await this.engine.findOne(this.objectName, {
+      where: { id },
+      fields: ["attempts"]
+    });
+    if (!current) return;
+    const now = Date.now();
+    let status;
+    let nextAttemptAt = null;
+    let error = null;
+    if (result.success) {
+      status = "success";
+    } else if (result.suppressed) {
+      status = "suppressed";
+      error = result.error ?? null;
+    } else if (result.dead) {
+      status = "dead";
+      error = result.error ?? null;
+    } else {
+      status = "pending";
+      nextAttemptAt = result.nextAttemptAt ?? null;
+      error = result.error ?? null;
+    }
+    await this.engine.update(
+      this.objectName,
+      {
+        status,
+        attempts: (current.attempts ?? 0) + 1,
+        last_attempted_at: now,
+        claimed_by: null,
+        claimed_at: null,
+        next_attempt_at: nextAttemptAt,
+        error,
+        updated_at: now
+      },
+      { where: { id }, multi: false }
+    );
+  }
+  async list(filter) {
+    const where = {};
+    if (filter?.status) where.status = filter.status;
+    if (filter?.notificationId) where.notification_id = filter.notificationId;
+    const rows = await this.engine.find(this.objectName, { where });
+    return rows.map((r) => this.toRecord(r));
+  }
+  toRecord(r) {
+    let payload = r.payload ?? {};
+    if (typeof payload === "string") {
+      try {
+        payload = JSON.parse(payload);
+      } catch {
+        payload = {};
+      }
+    }
+    return {
+      id: r.id,
+      notificationId: r.notification_id,
+      recipientId: r.recipient_id,
+      channel: r.channel,
+      topic: r.topic ?? void 0,
+      payload,
+      organizationId: r.organization_id ?? void 0,
+      partitionKey: r.partition_key,
+      status: r.status,
+      attempts: r.attempts,
+      claimedBy: r.claimed_by ?? void 0,
+      claimedAt: r.claimed_at ?? void 0,
+      nextAttemptAt: r.next_attempt_at ?? void 0,
+      lastAttemptedAt: r.last_attempted_at ?? void 0,
+      error: r.error ?? void 0,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    };
+  }
+};
+
+// src/sql-http-outbox.ts
+var import_node_crypto2 = require("crypto");
+
+// src/http-outbox.ts
+var HttpRedeliverError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "HttpRedeliverError";
+  }
+};
+
+// src/objects/http-delivery.object.ts
+var import_data = require("@objectstack/spec/data");
+var HttpDelivery = import_data.ObjectSchema.create({
+  name: "sys_http_delivery",
+  label: "HTTP Delivery",
+  pluralLabel: "HTTP Deliveries",
+  icon: "globe",
+  isSystem: true,
+  managedBy: "system",
+  userActions: { create: false, edit: false, delete: false, import: false },
+  description: "Durable outbox row for one outbound-HTTP attempt (ADR-0018). Managed by @objectstack/service-messaging; do not write directly.",
+  displayNameField: "id",
+  titleFormat: "{label} \u2192 {url}",
+  compactLayout: ["source", "url", "status", "attempts", "next_retry_at"],
+  listViews: {
+    recent: {
+      type: "grid",
+      name: "recent",
+      label: "Recent",
+      data: { provider: "object", object: "sys_http_delivery" },
+      columns: ["source", "label", "url", "status", "attempts", "response_code", "updated_at"],
+      sort: [{ field: "updated_at", order: "desc" }],
+      pagination: { pageSize: 50 }
+    },
+    failures: {
+      type: "grid",
+      name: "failures",
+      label: "Failures",
+      data: { provider: "object", object: "sys_http_delivery" },
+      columns: ["source", "url", "status", "attempts", "response_code", "error", "updated_at"],
+      filter: [{ field: "status", operator: "in", value: ["failed", "dead"] }],
+      sort: [{ field: "updated_at", order: "desc" }],
+      pagination: { pageSize: 50 }
+    },
+    pending: {
+      type: "grid",
+      name: "pending",
+      label: "Pending",
+      data: { provider: "object", object: "sys_http_delivery" },
+      columns: ["source", "url", "attempts", "next_retry_at", "updated_at"],
+      filter: [{ field: "status", operator: "equals", value: "pending" }],
+      sort: [{ field: "next_retry_at", order: "asc" }],
+      pagination: { pageSize: 50 }
+    }
+  },
+  fields: {
+    id: import_data.Field.text({
+      label: "Delivery ID",
+      required: true,
+      maxLength: 64,
+      description: "UUID \u2014 also doubles as the receiver-side idempotency key"
+    }),
+    source: import_data.Field.text({
+      label: "Source",
+      required: true,
+      maxLength: 32,
+      description: "Provenance domain, e.g. 'webhook' | 'flow'. UNIQUE(source, dedup_key)."
+    }),
+    ref_id: import_data.Field.text({
+      label: "Ref ID",
+      required: true,
+      maxLength: 128,
+      description: "Partition/ordering anchor within source (webhook id, flow id, \u2026)"
+    }),
+    dedup_key: import_data.Field.text({
+      label: "Dedup Key",
+      required: true,
+      maxLength: 191,
+      description: "UNIQUE(source, dedup_key) for at-most-once enqueue"
+    }),
+    label: import_data.Field.text({
+      label: "Label",
+      required: false,
+      maxLength: 191,
+      description: "Diagnostic label / event type \u2014 surfaced on X-Objectstack-Event"
+    }),
+    url: import_data.Field.text({
+      label: "Target URL",
+      required: true,
+      maxLength: 2048,
+      description: "Snapshotted at enqueue so config edits do not rewrite live rows"
+    }),
+    method: import_data.Field.text({ label: "Method", required: false, maxLength: 10 }),
+    headers_json: import_data.Field.textarea({ label: "Headers JSON", required: false }),
+    signing_secret: import_data.Field.text({ label: "HMAC Secret", required: false, maxLength: 256 }),
+    timeout_ms: import_data.Field.number({ label: "Timeout (ms)", required: false }),
+    payload_json: import_data.Field.textarea({ label: "Payload JSON", required: true }),
+    partition_key: import_data.Field.number({
+      label: "Partition",
+      required: true,
+      description: "hash(ref_id) mod partitionCount \u2014 precomputed for cheap WHERE"
+    }),
+    status: import_data.Field.text({
+      label: "Status",
+      required: true,
+      defaultValue: "pending",
+      maxLength: 16,
+      description: "pending | in_flight | success | failed | dead"
+    }),
+    attempts: import_data.Field.number({
+      label: "Attempts",
+      required: true,
+      defaultValue: 0,
+      description: "Number of attempts made so far"
+    }),
+    claimed_by: import_data.Field.text({ label: "Claimed By", required: false, maxLength: 128 }),
+    claimed_at: import_data.Field.number({ label: "Claimed At (ms)", required: false }),
+    next_retry_at: import_data.Field.number({ label: "Next Retry At (ms)", required: false }),
+    last_attempted_at: import_data.Field.number({ label: "Last Attempted At (ms)", required: false }),
+    response_code: import_data.Field.number({ label: "HTTP Status", required: false }),
+    response_body: import_data.Field.textarea({ label: "Response Body (capped)", required: false }),
+    error: import_data.Field.textarea({ label: "Error", required: false }),
+    created_at: import_data.Field.number({ label: "Created At (ms)", required: true }),
+    updated_at: import_data.Field.number({ label: "Updated At (ms)", required: true })
+  },
+  indexes: [
+    { fields: ["source", "dedup_key"], unique: true },
+    // Hot path: claim query
+    { fields: ["status", "partition_key", "next_retry_at"] },
+    // Reaper: scan stale in_flight rows by claimed_at
+    { fields: ["status", "claimed_at"] },
+    { fields: ["source", "ref_id"] }
+  ]
+});
+var SYS_HTTP_DELIVERY = "sys_http_delivery";
+
+// src/sql-http-outbox.ts
+var SqlHttpOutbox = class {
+  constructor(engine, opts) {
+    this.engine = engine;
+    if (opts.partitionCount <= 0) {
+      throw new Error("SqlHttpOutbox: partitionCount must be > 0");
+    }
+    this.objectName = opts.objectName ?? SYS_HTTP_DELIVERY;
+    this.partitionCount = opts.partitionCount;
+  }
+  async enqueue(input) {
+    const existing = await this.engine.findOne(this.objectName, {
+      where: { source: input.source, dedup_key: input.dedupKey },
+      fields: ["id"]
+    });
+    if (existing?.id) return existing.id;
+    const id = (0, import_node_crypto2.randomUUID)();
+    const now = Date.now();
+    const row = {
+      id,
+      source: input.source,
+      ref_id: input.refId,
+      dedup_key: input.dedupKey,
+      label: input.label,
+      url: input.url,
+      method: input.method ?? "POST",
+      headers_json: input.headers ? JSON.stringify(input.headers) : void 0,
+      signing_secret: input.signingSecret,
+      timeout_ms: input.timeoutMs,
+      payload_json: JSON.stringify(input.payload ?? null),
+      partition_key: hashPartition(input.refId, this.partitionCount),
+      status: "pending",
+      attempts: 0,
       created_at: now,
       updated_at: now
     };
@@ -747,8 +1203,11 @@ var SqlNotificationOutbox = class {
       await this.engine.insert(this.objectName, row);
       return id;
     } catch (err) {
-      const winner = await this.engine.findOne(this.objectName, { where: dedup, fields: ["id"] });
-      if (winner?.id) return String(winner.id);
+      const winner = await this.engine.findOne(this.objectName, {
+        where: { source: input.source, dedup_key: input.dedupKey },
+        fields: ["id"]
+      });
+      if (winner?.id) return winner.id;
       throw err;
     }
   }
@@ -757,19 +1216,25 @@ var SqlNotificationOutbox = class {
     await this.engine.update(
       this.objectName,
       { status: "pending", claimed_by: null, claimed_at: null, updated_at: now },
-      { where: { status: "in_flight", claimed_at: { $lt: now - opts.claimTtlMs } }, multi: true }
+      {
+        where: {
+          status: "in_flight",
+          claimed_at: { $lt: now - opts.claimTtlMs }
+        },
+        multi: true
+      }
     );
     const partitionFilter = opts.partition ? { partition_key: opts.partition.index } : {};
     const candidates = await this.engine.find(this.objectName, {
       where: {
         status: "pending",
         ...partitionFilter,
-        $or: [{ next_attempt_at: null }, { next_attempt_at: { $lte: now } }]
+        $or: [{ next_retry_at: null }, { next_retry_at: { $lte: now } }]
       },
       fields: ["id"],
       limit: opts.limit
     });
-    if (!candidates.length) return [];
+    if (candidates.length === 0) return [];
     const ids = candidates.map((c) => c.id);
     await this.engine.update(
       this.objectName,
@@ -779,7 +1244,7 @@ var SqlNotificationOutbox = class {
     const claimed = await this.engine.find(this.objectName, {
       where: { id: { $in: ids }, claimed_by: opts.nodeId, claimed_at: now, status: "in_flight" }
     });
-    return claimed.map((r) => this.toRecord(r));
+    return claimed.map((r) => this.toDelivery(r));
   }
   async ack(id, result) {
     const current = await this.engine.findOne(this.objectName, {
@@ -789,19 +1254,19 @@ var SqlNotificationOutbox = class {
     if (!current) return;
     const now = Date.now();
     let status;
-    let nextAttemptAt = null;
-    let error = null;
+    let nextRetryAt;
+    let error;
     if (result.success) {
       status = "success";
-    } else if (result.suppressed) {
-      status = "suppressed";
-      error = result.error ?? null;
+      nextRetryAt = null;
+      error = null;
     } else if (result.dead) {
       status = "dead";
+      nextRetryAt = null;
       error = result.error ?? null;
     } else {
       status = "pending";
-      nextAttemptAt = result.nextAttemptAt ?? null;
+      nextRetryAt = result.nextRetryAt ?? null;
       error = result.error ?? null;
     }
     await this.engine.update(
@@ -812,7 +1277,9 @@ var SqlNotificationOutbox = class {
         last_attempted_at: now,
         claimed_by: null,
         claimed_at: null,
-        next_attempt_at: nextAttemptAt,
+        response_code: result.httpStatus ?? null,
+        response_body: result.responseBody ?? null,
+        next_retry_at: nextRetryAt,
         error,
         updated_at: now
       },
@@ -822,34 +1289,65 @@ var SqlNotificationOutbox = class {
   async list(filter) {
     const where = {};
     if (filter?.status) where.status = filter.status;
-    if (filter?.notificationId) where.notification_id = filter.notificationId;
+    if (filter?.source) where.source = filter.source;
     const rows = await this.engine.find(this.objectName, { where });
-    return rows.map((r) => this.toRecord(r));
+    return rows.map((r) => this.toDelivery(r));
   }
-  toRecord(r) {
-    let payload = r.payload ?? {};
-    if (typeof payload === "string") {
-      try {
-        payload = JSON.parse(payload);
-      } catch {
-        payload = {};
-      }
+  async redeliver(id) {
+    const current = await this.engine.findOne(this.objectName, { where: { id } });
+    if (!current) {
+      throw new HttpRedeliverError(`Delivery row '${id}' not found`, "not_found");
+    }
+    if (current.status !== "success" && current.status !== "failed" && current.status !== "dead") {
+      throw new HttpRedeliverError(
+        `Delivery row '${id}' is '${current.status}', expected one of: success, failed, dead`,
+        "not_eligible"
+      );
     }
+    const now = Date.now();
+    await this.engine.update(
+      this.objectName,
+      {
+        status: "pending",
+        attempts: 0,
+        claimed_by: null,
+        claimed_at: null,
+        next_retry_at: null,
+        last_attempted_at: null,
+        response_code: null,
+        response_body: null,
+        error: null,
+        updated_at: now
+      },
+      { where: { id, status: { $in: ["success", "failed", "dead"] } }, multi: false }
+    );
+    const after = await this.engine.findOne(this.objectName, { where: { id } });
+    if (!after || after.status !== "pending") {
+      throw new HttpRedeliverError(`Delivery row '${id}' state changed during redeliver`, "not_eligible");
+    }
+    return this.toDelivery(after);
+  }
+  toDelivery(r) {
     return {
       id: r.id,
-      notificationId: r.notification_id,
-      recipientId: r.recipient_id,
-      channel: r.channel,
-      topic: r.topic ?? void 0,
-      payload,
-      organizationId: r.organization_id ?? void 0,
-      partitionKey: r.partition_key,
+      source: r.source,
+      refId: r.ref_id,
+      dedupKey: r.dedup_key,
+      label: r.label ?? void 0,
+      url: r.url,
+      method: r.method ?? void 0,
+      headers: r.headers_json ? JSON.parse(r.headers_json) : void 0,
+      signingSecret: r.signing_secret ?? void 0,
+      timeoutMs: r.timeout_ms ?? void 0,
+      payload: JSON.parse(r.payload_json),
       status: r.status,
       attempts: r.attempts,
       claimedBy: r.claimed_by ?? void 0,
       claimedAt: r.claimed_at ?? void 0,
-      nextAttemptAt: r.next_attempt_at ?? void 0,
+      nextRetryAt: r.next_retry_at ?? void 0,
       lastAttemptedAt: r.last_attempted_at ?? void 0,
+      responseCode: r.response_code ?? void 0,
+      responseBody: r.response_body ?? void 0,
       error: r.error ?? void 0,
       createdAt: r.created_at,
       updatedAt: r.updated_at
@@ -1004,6 +1502,237 @@ function stableNodeOffset(nodeId, partitionCount) {
   return Math.abs(h) % partitionCount;
 }
 
+// src/http-sender.ts
+var import_node_crypto3 = require("crypto");
+var DEFAULT_HTTP_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 ?? null);
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "ObjectStack-Http/1.0",
+    "X-Objectstack-Delivery": delivery.id,
+    "X-Objectstack-Attempt": String(delivery.attempts + 1),
+    ...delivery.label ? { "X-Objectstack-Event": delivery.label } : {},
+    ...delivery.headers ?? {}
+  };
+  if (delivery.signingSecret) {
+    const sig = (0, import_node_crypto3.createHmac)("sha256", delivery.signingSecret).update(body).digest("hex");
+    headers["X-Objectstack-Signature"] = `sha256=${sig}`;
+  }
+  const timeoutMs = delivery.timeoutMs ?? DEFAULT_HTTP_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 nextHttpRetryDelayMs(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 = nextHttpRetryDelayMs(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
+  };
+}
+function newDeliveryId() {
+  return (0, import_node_crypto3.randomUUID)();
+}
+
+// src/http-dispatcher.ts
+var SINGLE_NODE_CLUSTER2 = {
+  lock: {
+    async acquire() {
+      return { release() {
+      }, isHeld: () => true, renew() {
+      } };
+    }
+  }
+};
+var HttpDispatcher = class {
+  constructor(options) {
+    this.running = false;
+    const intervalMs = options.intervalMs ?? 500;
+    const lockTtlMs = options.lockTtlMs ?? intervalMs * 5;
+    this.opts = {
+      nodeId: options.nodeId,
+      outbox: options.outbox,
+      cluster: options.cluster ?? SINGLE_NODE_CLUSTER2,
+      partitionCount: options.partitionCount ?? 8,
+      batchSize: options.batchSize ?? 32,
+      intervalMs,
+      lockTtlMs,
+      claimTtlMs: options.claimTtlMs ?? lockTtlMs * 2,
+      fetchImpl: options.fetchImpl,
+      rng: options.rng,
+      now: options.now,
+      logger: options.logger,
+      onAttempt: options.onAttempt
+    };
+  }
+  /** 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);
+    this.timer.unref?.();
+  }
+  /** 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). Exposed for deterministic tests. */
+  async tick() {
+    await this.runTick();
+  }
+  scheduleTick() {
+    if (this.inflightTick) return;
+    this.inflightTick = this.runTick().catch((err) => {
+      this.opts.logger?.warn?.("http-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 = stableNodeOffset2(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 = `http.dispatcher.partition.${index}`;
+    const handle = await this.opts.cluster.lock.acquire(key, {
+      ttlMs: this.opts.lockTtlMs,
+      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,
+        now: this.opts.now?.()
+      });
+      if (claimed.length === 0) return;
+      await handle.renew?.(this.opts.lockTtlMs);
+      for (const row of claimed) {
+        if (handle.isHeld && !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?.("http-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, this.opts.now?.() ?? Date.now(), this.opts.rng);
+    await this.opts.outbox.ack(row.id, result);
+    this.opts.onAttempt?.(row, result.success);
+  }
+};
+function stableNodeOffset2(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/retention.ts
 var DEFAULT_RETENTION_TARGETS = [
   { object: RECEIPT_OBJECT, tsField: "created_at", format: "iso" },
@@ -1211,8 +1940,8 @@ function createEmailChannel(opts) {
 }
 
 // src/objects/inbox-message.object.ts
-var import_data = require("@objectstack/spec/data");
-var InboxMessage = import_data.ObjectSchema.create({
+var import_data2 = require("@objectstack/spec/data");
+var InboxMessage = import_data2.ObjectSchema.create({
   name: "sys_inbox_message",
   label: "Inbox Message",
   pluralLabel: "Inbox Messages",
@@ -1234,37 +1963,37 @@ var InboxMessage = import_data.ObjectSchema.create({
     }
   },
   fields: {
-    id: import_data.Field.text({
+    id: import_data2.Field.text({
       label: "Inbox Message ID",
       required: true,
       readonly: true
     }),
-    user_id: import_data.Field.text({
+    user_id: import_data2.Field.text({
       label: "Recipient User",
       required: true,
       searchable: true
     }),
-    notification_id: import_data.Field.text({
+    notification_id: import_data2.Field.text({
       label: "Notification Event",
       searchable: true,
       description: "FK \u2192 sys_notification (the L2 event this row materializes)"
     }),
-    delivery_id: import_data.Field.text({
+    delivery_id: import_data2.Field.text({
       label: "Delivery",
       description: "FK \u2192 sys_notification_delivery (outbox row); null until P1"
     }),
-    topic: import_data.Field.text({
+    topic: import_data2.Field.text({
       label: "Topic",
       searchable: true
     }),
-    title: import_data.Field.text({
+    title: import_data2.Field.text({
       label: "Title",
       required: true
     }),
-    body_md: import_data.Field.markdown({
+    body_md: import_data2.Field.markdown({
       label: "Body"
     }),
-    severity: import_data.Field.select({
+    severity: import_data2.Field.select({
       label: "Severity",
       options: [
         { label: "Info", value: "info" },
@@ -1272,10 +2001,10 @@ var InboxMessage = import_data.ObjectSchema.create({
         { label: "Critical", value: "critical" }
       ]
     }),
-    action_url: import_data.Field.text({
+    action_url: import_data2.Field.text({
       label: "Action URL"
     }),
-    created_at: import_data.Field.datetime({
+    created_at: import_data2.Field.datetime({
       label: "Created At",
       readonly: true
     })
@@ -1283,8 +2012,8 @@ var InboxMessage = import_data.ObjectSchema.create({
 });
 
 // src/objects/notification-receipt.object.ts
-var import_data2 = require("@objectstack/spec/data");
-var NotificationReceipt = import_data2.ObjectSchema.create({
+var import_data3 = require("@objectstack/spec/data");
+var NotificationReceipt = import_data3.ObjectSchema.create({
   name: "sys_notification_receipt",
   label: "Notification Receipt",
   pluralLabel: "Notification Receipts",
@@ -1295,43 +2024,43 @@ var NotificationReceipt = import_data2.ObjectSchema.create({
   titleFormat: "{state}",
   compactLayout: ["notification_id", "user_id", "channel", "state", "at"],
   fields: {
-    id: import_data2.Field.text({
+    id: import_data3.Field.text({
       label: "Receipt ID",
       required: true,
       readonly: true
     }),
-    notification_id: import_data2.Field.text({
+    notification_id: import_data3.Field.text({
       label: "Notification Event",
       required: true,
       searchable: true,
       description: "FK \u2192 sys_notification (L2 event)"
     }),
-    delivery_id: import_data2.Field.text({
+    delivery_id: import_data3.Field.text({
       label: "Delivery",
       required: false,
       description: "FK \u2192 sys_notification_delivery (outbox row); null until P1"
     }),
-    user_id: import_data2.Field.text({
+    user_id: import_data3.Field.text({
       label: "Recipient User",
       required: true,
       searchable: true
     }),
-    channel: import_data2.Field.text({
+    channel: import_data3.Field.text({
       label: "Channel",
       required: true,
       description: "Channel id this receipt is for (inbox / email / push / \u2026)"
     }),
-    state: import_data2.Field.select(["delivered", "read", "clicked", "dismissed"], {
+    state: import_data3.Field.select(["delivered", "read", "clicked", "dismissed"], {
       label: "State",
       required: true,
       defaultValue: "delivered"
     }),
-    at: import_data2.Field.datetime({
+    at: import_data3.Field.datetime({
       label: "At",
       required: false,
       description: "When the receipt reached its current state"
     }),
-    created_at: import_data2.Field.datetime({
+    created_at: import_data3.Field.datetime({
       label: "Created At",
       readonly: true
     })
@@ -1343,8 +2072,8 @@ var NotificationReceipt = import_data2.ObjectSchema.create({
 });
 
 // src/objects/notification-delivery.object.ts
-var import_data3 = require("@objectstack/spec/data");
-var NotificationDelivery = import_data3.ObjectSchema.create({
+var import_data4 = require("@objectstack/spec/data");
+var NotificationDelivery = import_data4.ObjectSchema.create({
   name: "sys_notification_delivery",
   label: "Notification Delivery",
   pluralLabel: "Notification Deliveries",
@@ -1355,34 +2084,34 @@ var NotificationDelivery = import_data3.ObjectSchema.create({
   titleFormat: "{channel} \u2192 {recipient_id}",
   compactLayout: ["notification_id", "recipient_id", "channel", "status", "attempts"],
   fields: {
-    id: import_data3.Field.text({ label: "Delivery ID", required: true, readonly: true }),
-    notification_id: import_data3.Field.text({
+    id: import_data4.Field.text({ label: "Delivery ID", required: true, readonly: true }),
+    notification_id: import_data4.Field.text({
       label: "Notification Event",
       required: true,
       searchable: true,
       description: "FK \u2192 sys_notification (L2 event)"
     }),
-    recipient_id: import_data3.Field.text({ label: "Recipient User", required: true, searchable: true }),
-    channel: import_data3.Field.text({ label: "Channel", required: true }),
-    topic: import_data3.Field.text({ label: "Topic", searchable: true }),
-    payload: import_data3.Field.json({
+    recipient_id: import_data4.Field.text({ label: "Recipient User", required: true, searchable: true }),
+    channel: import_data4.Field.text({ label: "Channel", required: true }),
+    topic: import_data4.Field.text({ label: "Topic", searchable: true }),
+    payload: import_data4.Field.json({
       label: "Payload",
       description: "Snapshot of the rendered notification content for dispatch."
     }),
-    status: import_data3.Field.select(["pending", "in_flight", "success", "failed", "dead", "suppressed"], {
+    status: import_data4.Field.select(["pending", "in_flight", "success", "failed", "dead", "suppressed"], {
       label: "Status",
       required: true,
       defaultValue: "pending"
     }),
-    attempts: import_data3.Field.number({ label: "Attempts", defaultValue: 0 }),
-    partition_key: import_data3.Field.number({ label: "Partition Key", defaultValue: 0 }),
-    claimed_by: import_data3.Field.text({ label: "Claimed By", description: "Node id while in_flight" }),
-    claimed_at: import_data3.Field.number({ label: "Claimed At (ms)" }),
-    next_attempt_at: import_data3.Field.number({ label: "Next Attempt At (ms)" }),
-    last_attempted_at: import_data3.Field.number({ label: "Last Attempted At (ms)" }),
-    error: import_data3.Field.textarea({ label: "Error" }),
-    created_at: import_data3.Field.number({ label: "Created At (ms)", readonly: true }),
-    updated_at: import_data3.Field.number({ label: "Updated At (ms)" })
+    attempts: import_data4.Field.number({ label: "Attempts", defaultValue: 0 }),
+    partition_key: import_data4.Field.number({ label: "Partition Key", defaultValue: 0 }),
+    claimed_by: import_data4.Field.text({ label: "Claimed By", description: "Node id while in_flight" }),
+    claimed_at: import_data4.Field.number({ label: "Claimed At (ms)" }),
+    next_attempt_at: import_data4.Field.number({ label: "Next Attempt At (ms)" }),
+    last_attempted_at: import_data4.Field.number({ label: "Last Attempted At (ms)" }),
+    error: import_data4.Field.textarea({ label: "Error" }),
+    created_at: import_data4.Field.number({ label: "Created At (ms)", readonly: true }),
+    updated_at: import_data4.Field.number({ label: "Updated At (ms)" })
   },
   indexes: [
     // Dedup: one delivery per (event, recipient, channel).
@@ -1396,8 +2125,8 @@ var NotificationDelivery = import_data3.ObjectSchema.create({
 });
 
 // src/objects/notification-preference.object.ts
-var import_data4 = require("@objectstack/spec/data");
-var NotificationPreference = import_data4.ObjectSchema.create({
+var import_data5 = require("@objectstack/spec/data");
+var NotificationPreference = import_data5.ObjectSchema.create({
   name: "sys_notification_preference",
   label: "Notification Preference",
   pluralLabel: "Notification Preferences",
@@ -1408,44 +2137,44 @@ var NotificationPreference = import_data4.ObjectSchema.create({
   titleFormat: "{user_id} \xB7 {topic} \xB7 {channel}",
   compactLayout: ["user_id", "topic", "channel", "enabled", "digest"],
   fields: {
-    id: import_data4.Field.text({ label: "Preference ID", required: true, readonly: true }),
-    user_id: import_data4.Field.text({
+    id: import_data5.Field.text({ label: "Preference ID", required: true, readonly: true }),
+    user_id: import_data5.Field.text({
       label: "User",
       required: true,
       searchable: true,
       description: "Recipient user id, or '*' for the admin-global default."
     }),
-    topic: import_data4.Field.text({
+    topic: import_data5.Field.text({
       label: "Topic",
       required: true,
       searchable: true,
       defaultValue: "*",
       description: "Notification topic, or '*' for all topics."
     }),
-    channel: import_data4.Field.text({
+    channel: import_data5.Field.text({
       label: "Channel",
       required: true,
       defaultValue: "*",
       description: "Channel id (inbox/email/push/\u2026), or '*' for all channels."
     }),
-    enabled: import_data4.Field.boolean({
+    enabled: import_data5.Field.boolean({
       label: "Enabled",
       defaultValue: true,
       description: "When false, this (user, topic, channel) is muted."
     }),
-    digest: import_data4.Field.select(["none", "daily", "weekly"], {
+    digest: import_data5.Field.select(["none", "daily", "weekly"], {
       label: "Digest",
       required: false,
       defaultValue: "none",
       description: "Batch cadence (P3 digest middleware)."
     }),
-    quiet_hours: import_data4.Field.json({
+    quiet_hours: import_data5.Field.json({
       label: "Quiet Hours",
       required: false,
       description: "Optional { tz, start, end } window (P3 quiet-hours middleware)."
     }),
-    created_at: import_data4.Field.datetime({ label: "Created At", readonly: true }),
-    updated_at: import_data4.Field.datetime({ label: "Updated At", required: false })
+    created_at: import_data5.Field.datetime({ label: "Created At", readonly: true }),
+    updated_at: import_data5.Field.datetime({ label: "Updated At", required: false })
   },
   indexes: [
     { fields: ["user_id", "topic", "channel"], unique: true },
@@ -1454,8 +2183,8 @@ var NotificationPreference = import_data4.ObjectSchema.create({
 });
 
 // src/objects/notification-subscription.object.ts
-var import_data5 = require("@objectstack/spec/data");
-var NotificationSubscription = import_data5.ObjectSchema.create({
+var import_data6 = require("@objectstack/spec/data");
+var NotificationSubscription = import_data6.ObjectSchema.create({
   name: "sys_notification_subscription",
   label: "Notification Subscription",
   pluralLabel: "Notification Subscriptions",
@@ -1466,25 +2195,25 @@ var NotificationSubscription = import_data5.ObjectSchema.create({
   titleFormat: "{principal} \xB7 {topic}",
   compactLayout: ["topic", "principal", "enabled", "created_at"],
   fields: {
-    id: import_data5.Field.text({ label: "Subscription ID", required: true, readonly: true }),
-    topic: import_data5.Field.text({
+    id: import_data6.Field.text({ label: "Subscription ID", required: true, readonly: true }),
+    topic: import_data6.Field.text({
       label: "Topic",
       required: true,
       searchable: true,
       description: "Notification topic this principal subscribes to."
     }),
-    principal: import_data5.Field.text({
+    principal: import_data6.Field.text({
       label: "Principal",
       required: true,
       searchable: true,
       description: "Subscriber selector: 'role:x' | 'team:x' | 'user:id' | bare user id."
     }),
-    enabled: import_data5.Field.boolean({
+    enabled: import_data6.Field.boolean({
       label: "Enabled",
       defaultValue: true,
       description: "When false, the subscription is inactive."
     }),
-    created_at: import_data5.Field.datetime({ label: "Created At", readonly: true })
+    created_at: import_data6.Field.datetime({ label: "Created At", readonly: true })
   },
   indexes: [
     { fields: ["topic", "principal"], unique: true },
@@ -1493,8 +2222,8 @@ var NotificationSubscription = import_data5.ObjectSchema.create({
 });
 
 // src/objects/notification-template.object.ts
-var import_data6 = require("@objectstack/spec/data");
-var NotificationTemplate = import_data6.ObjectSchema.create({
+var import_data7 = require("@objectstack/spec/data");
+var NotificationTemplate = import_data7.ObjectSchema.create({
   name: "sys_notification_template",
   label: "Notification Template",
   pluralLabel: "Notification Templates",
@@ -1505,47 +2234,47 @@ var NotificationTemplate = import_data6.ObjectSchema.create({
   titleFormat: "{topic} \xB7 {channel} \xB7 {locale}",
   compactLayout: ["topic", "channel", "locale", "is_active"],
   fields: {
-    id: import_data6.Field.text({ label: "Template ID", required: true, readonly: true }),
-    topic: import_data6.Field.text({ label: "Topic", required: true, searchable: true }),
-    channel: import_data6.Field.text({
+    id: import_data7.Field.text({ label: "Template ID", required: true, readonly: true }),
+    topic: import_data7.Field.text({ label: "Topic", required: true, searchable: true }),
+    channel: import_data7.Field.text({
       label: "Channel",
       required: true,
       defaultValue: "email",
       description: "Channel id this template renders for (email/inbox/push/\u2026)."
     }),
-    locale: import_data6.Field.text({
+    locale: import_data7.Field.text({
       label: "Locale",
       required: true,
       defaultValue: "en",
       description: "BCP-47 locale, e.g. 'en' / 'en-US' / 'zh-CN'."
     }),
-    version: import_data6.Field.number({
+    version: import_data7.Field.number({
       label: "Version",
       required: false,
       defaultValue: 1
     }),
-    subject: import_data6.Field.text({
+    subject: import_data7.Field.text({
       label: "Subject / Title",
       required: false,
       description: "Rendered into the email subject / inbox title. Supports {{ payload.x }}."
     }),
-    body: import_data6.Field.markdown({
+    body: import_data7.Field.markdown({
       label: "Body",
       required: false,
       description: "Template body. Supports {{ payload.x }}. Interpreted per `format`."
     }),
-    format: import_data6.Field.select(["markdown", "html", "text", "mjml"], {
+    format: import_data7.Field.select(["markdown", "html", "text", "mjml"], {
       label: "Body Format",
       required: false,
       defaultValue: "markdown"
     }),
-    is_active: import_data6.Field.boolean({
+    is_active: import_data7.Field.boolean({
       label: "Active",
       defaultValue: true,
       description: "Only active templates are selected at render time."
     }),
-    created_at: import_data6.Field.datetime({ label: "Created At", readonly: true }),
-    updated_at: import_data6.Field.datetime({ label: "Updated At", required: false })
+    created_at: import_data7.Field.datetime({ label: "Created At", readonly: true }),
+    updated_at: import_data7.Field.datetime({ label: "Updated At", required: false })
   },
   indexes: [
     { fields: ["topic", "channel", "locale"] },
@@ -1588,6 +2317,7 @@ var MessagingServicePlugin = class {
       service.registerChannel(createInboxChannel({ getData }));
     }
     ctx.registerService("messaging", service);
+    ctx.registerService("notification", service);
     ctx.getService("manifest").register({
       id: "com.objectstack.service.messaging",
       name: "Messaging Service",
@@ -1600,7 +2330,8 @@ var MessagingServicePlugin = class {
         NotificationDelivery,
         NotificationPreference,
         NotificationSubscription,
-        NotificationTemplate
+        NotificationTemplate,
+        HttpDelivery
       ],
       navigationContributions: [
         {
@@ -1647,7 +2378,7 @@ var MessagingServicePlugin = class {
           cluster = void 0;
         }
         this.dispatcher = new NotificationDispatcher({
-          nodeId: `notify-${process.pid}-${(0, import_node_crypto2.randomUUID)().slice(0, 8)}`,
+          nodeId: `notify-${process.pid}-${(0, import_node_crypto4.randomUUID)().slice(0, 8)}`,
           outbox,
           channels: service,
           channelContext: { logger: ctx.logger },
@@ -1660,6 +2391,20 @@ var MessagingServicePlugin = class {
         ctx.logger.info(
           `[messaging] reliable delivery on (outbox + dispatcher, ${this.options.partitionCount} partitions${cluster ? ", clustered" : ", single-node"})`
         );
+        const httpOutbox = new SqlHttpOutbox(engine, { partitionCount: this.options.partitionCount });
+        service.setHttpOutbox(httpOutbox);
+        this.httpDispatcher = new HttpDispatcher({
+          nodeId: `http-${process.pid}-${(0, import_node_crypto4.randomUUID)().slice(0, 8)}`,
+          outbox: httpOutbox,
+          cluster,
+          partitionCount: this.options.partitionCount,
+          intervalMs: this.options.dispatchIntervalMs,
+          logger: ctx.logger
+        });
+        this.httpDispatcher.start();
+        ctx.logger.info(
+          `[messaging] HTTP delivery on (sys_http_delivery outbox + dispatcher, ${this.options.partitionCount} partitions)`
+        );
       });
     }
     if (this.options.retentionDays > 0 && typeof ctx.hook === "function") {
@@ -1687,6 +2432,8 @@ var MessagingServicePlugin = class {
   async stop() {
     await this.dispatcher?.stop();
     this.dispatcher = void 0;
+    await this.httpDispatcher?.stop();
+    this.httpDispatcher = void 0;
     if (this.retentionTimer) {
       clearInterval(this.retentionTimer);
       this.retentionTimer = void 0;
@@ -1695,7 +2442,7 @@ var MessagingServicePlugin = class {
 };
 
 // src/memory-outbox.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var MemoryNotificationOutbox = class {
   constructor(partitionCount = 8, clock = () => Date.now()) {
     this.partitionCount = partitionCount;
@@ -1708,7 +2455,7 @@ var MemoryNotificationOutbox = class {
         return r.id;
       }
     }
-    const id = (0, import_node_crypto3.randomUUID)();
+    const id = (0, import_node_crypto5.randomUUID)();
     const now = this.clock();
     this.rows.set(id, {
       id,
@@ -1785,15 +2532,140 @@ var MemoryNotificationOutbox = class {
     return rows.map((r) => ({ ...r }));
   }
 };
+
+// src/memory-http-outbox.ts
+var import_node_crypto6 = require("crypto");
+var MemoryHttpOutbox = class {
+  constructor() {
+    this.rows = /* @__PURE__ */ new Map();
+    /** Dedup index keyed by `${source}::${dedupKey}` -> row id. */
+    this.dedup = /* @__PURE__ */ new Map();
+  }
+  async enqueue(input) {
+    const dedupKey = `${input.source}::${input.dedupKey}`;
+    const existing = this.dedup.get(dedupKey);
+    if (existing) return existing;
+    const id = (0, import_node_crypto6.randomUUID)();
+    const now = Date.now();
+    const row = {
+      id,
+      source: input.source,
+      refId: input.refId,
+      dedupKey: input.dedupKey,
+      label: input.label,
+      url: input.url,
+      method: input.method ?? "POST",
+      headers: input.headers,
+      signingSecret: input.signingSecret,
+      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.refId, 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) {
+    let all = Array.from(this.rows.values()).map((r) => ({ ...r }));
+    if (filter?.status) all = all.filter((r) => r.status === filter.status);
+    if (filter?.source) all = all.filter((r) => r.source === filter.source);
+    return all;
+  }
+  async redeliver(id) {
+    const row = this.rows.get(id);
+    if (!row) {
+      throw new HttpRedeliverError(`Delivery row '${id}' not found`, "not_found");
+    }
+    if (row.status !== "success" && row.status !== "failed" && row.status !== "dead") {
+      throw new HttpRedeliverError(
+        `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 };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_HTTP_TIMEOUT_MS,
   DEFAULT_LOCALE,
   DEFAULT_RETENTION_TARGETS,
   DELIVERY_OBJECT,
   EMAIL_USER_OBJECT,
+  HttpDelivery,
+  HttpDispatcher,
+  HttpRedeliverError,
   INBOX_OBJECT,
   InboxMessage,
   MEMBER_OBJECT,
+  MemoryHttpOutbox,
   MemoryNotificationOutbox,
   MessagingService,
   MessagingServicePlugin,
@@ -1810,17 +2682,23 @@ var MemoryNotificationOutbox = class {
   PreferenceResolver,
   RECEIPT_OBJECT,
   RecipientResolver,
+  SYS_HTTP_DELIVERY,
+  SqlHttpOutbox,
   SqlNotificationOutbox,
   TEAM_MEMBER_OBJECT,
   TEMPLATE_OBJECT,
   USER_OBJECT,
   classifyDeliveryAttempt,
+  classifyHttpAttempt,
   createEmailChannel,
   createInboxChannel,
   hashPartition,
   interpolate,
+  newHttpDeliveryId,
+  nextHttpRetryDelayMs,
   nextRetryDelayMs,
   quietHoursDeferral,
-  renderNotification
+  renderNotification,
+  sendHttpOnce
 });
 //# sourceMappingURL=index.cjs.map