@crvouga/mockingbird-service-resend 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -1,14 +1,22 @@
 # Changelog — @crvouga/mockingbird-service-resend
 
-## 3.3.0 (2026-10-12)
+## 3.4.0 (2026-10-15)
 
 ### Features
 
-- unify the emulator control plane ([2068547](https://github.com/crvouga/mockingbird/commit/2068547bedde4e2e2331c1657c1a78120e84428b))
+- finish durable run lifecycle ([725ea1a](https://github.com/crvouga/mockingbird/commit/725ea1a966dac65434e98f06a9c33aca0d6f32d7))
+- add management and portable archives ([0d2a6dd](https://github.com/crvouga/mockingbird/commit/0d2a6dd0f9fecb3a1ea7c1638f6639787395c2f4))
 
-### Dependencies
+### Fixes and improvements
 
-- `@crvouga/mockingbird-service-sqlite`
+- correlate cross-namespace operations ([3457a4b](https://github.com/crvouga/mockingbird/commit/3457a4b7dbfd9ad9c8a10671a5744b7c8425d000))
+- harden HTTP stream handling ([674307a](https://github.com/crvouga/mockingbird/commit/674307a869f57907567d462c4f506c3b0a237e13))
+
+## 3.3.0 (2026-10-12)
+
+### Features
+
+- unify the emulator control plane ([2068547](https://github.com/crvouga/mockingbird/commit/2068547bedde4e2e2331c1657c1a78120e84428b))
 
 ## 3.2.0 (2026-10-08)
 

package/dist/{chunk-YJDLINUI.js → chunk-KPX5JPKL.js}

@@ -1438,7 +1438,7 @@ var assertSnapshotDocument = (value, label = "snapshot") => {
     });
   }
   if (value.clock !== void 0) {
-    if (!isRecord2(value.clock) || typeof value.clock.now !== "number" || typeof value.clock.frozen !== "boolean")
+    if (!isRecord2(value.clock) || typeof value.clock.now !== "number" || !Number.isFinite(value.clock.now) || typeof value.clock.frozen !== "boolean")
       throw new ControlError(`${label}.clock: expected {now, frozen}`);
   }
   return value;
@@ -3378,6 +3378,91 @@ var createMetrics = (partition = true) => {
   };
 };
 
+// ../core/dist/outbound.js
+function ownedTransport(policy) {
+  if (!["offline", "allowlist"].includes(policy.mode) || policy.origins?.some((origin) => {
+    try {
+      return new URL(origin).origin !== origin;
+    } catch {
+      return true;
+    }
+  }))
+    throw new Error("invalid outbound transport policy");
+  const reject = (namespace, reason) => {
+    try {
+      policy.onReject?.({ namespace, policy: policy.mode, reason });
+    } catch {
+    }
+    throw new Error(`outbound policy ${policy.mode}: ${reason}`);
+  };
+  return async (request, namespace, send) => {
+    if (policy.mode === "offline")
+      return reject(namespace, "delivery disabled");
+    const allowed = (url2) => ["http:", "https:"].includes(url2.protocol) && !url2.username && !url2.password && (policy.origins ?? []).includes(url2.origin);
+    let url = new URL(request.url);
+    if (!allowed(url))
+      return reject(namespace, "destination not allowed");
+    const max = policy.maxBodyBytes ?? 1024 * 1024;
+    const chunks = [];
+    let size = 0;
+    const reader = request.body?.getReader();
+    if (reader)
+      try {
+        for (; ; ) {
+          const item = await reader.read();
+          if (item.done)
+            break;
+          size += item.value.length;
+          if (size > max)
+            return reject(namespace, "body limit exceeded");
+          chunks.push(item.value);
+        }
+      } finally {
+        void reader.cancel().catch(() => {
+        });
+        reader.releaseLock();
+      }
+    const body = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset);
+      offset += chunk.length;
+    }
+    let method = request.method, headers = new Headers(request.headers);
+    for (let redirects = 0; ; redirects++) {
+      if (!allowed(url))
+        return reject(namespace, "redirect destination not allowed");
+      const response = await send(new Request(url, {
+        method,
+        headers,
+        ...method !== "GET" && method !== "HEAD" ? { body } : {},
+        redirect: "manual",
+        signal: request.signal
+      }));
+      if (![301, 302, 303, 307, 308].includes(response.status))
+        return response;
+      const location = response.headers.get("location");
+      if (!location)
+        return response;
+      await response.body?.cancel();
+      if (redirects >= (policy.maxRedirects ?? 5))
+        return reject(namespace, "redirect limit exceeded");
+      const next = new URL(location, url);
+      if (next.origin !== url.origin) {
+        headers = new Headers(headers);
+        for (const key of ["authorization", "cookie", "proxy-authorization"])
+          headers.delete(key);
+      }
+      if (response.status === 303 || (response.status === 301 || response.status === 302) && method === "POST") {
+        method = "GET";
+        headers.delete("content-length");
+        headers.delete("content-type");
+      }
+      url = next;
+    }
+  };
+}
+
 // ../core/dist/outbox.js
 var OutboxStore = class {
   items;
@@ -4023,7 +4108,7 @@ var stateAdminRoutes = (routes) => {
 };
 
 // ../core/dist/version.js
-var PACKAGE_VERSION = true ? "3.3.0" : UNRELEASED_VERSION;
+var PACKAGE_VERSION = true ? "3.4.0" : UNRELEASED_VERSION;
 
 // ../core/dist/signing.js
 var encoder = new TextEncoder();
@@ -4115,13 +4200,35 @@ var createWebhookHub = (options) => {
   const payloads = /* @__PURE__ */ new Map();
   const faults = /* @__PURE__ */ new Map();
   const held = /* @__PURE__ */ new Map();
+  const deliveryObservers = /* @__PURE__ */ new Set();
+  const notify = (delivery) => {
+    for (const listener of deliveryObservers)
+      try {
+        listener({ namespace: delivery.namespace, state: delivery.state, deliveryId: delivery.id });
+      } catch {
+      }
+  };
+  let transport;
   const inFlight2 = /* @__PURE__ */ new Set();
+  const workNamespace = /* @__PURE__ */ new Map();
+  const activeDeliveries = /* @__PURE__ */ new Map();
   const controllers = /* @__PURE__ */ new Map();
   let immediate = Promise.resolve();
   const snapshots = /* @__PURE__ */ new WeakMap();
-  const track = (work) => {
+  const track = (work, delivery) => {
     inFlight2.add(work);
-    void work.finally(() => inFlight2.delete(work));
+    workNamespace.set(work, delivery.namespace);
+    const active = activeDeliveries.get(delivery.id) ?? { namespace: delivery.namespace, count: 0 };
+    active.count++;
+    activeDeliveries.set(delivery.id, active);
+    const finish = () => {
+      inFlight2.delete(work);
+      workNamespace.delete(work);
+      active.count--;
+      if (active.count === 0)
+        activeDeliveries.delete(delivery.id);
+    };
+    void work.then(finish, finish);
   };
   const attempt = async (delivery) => {
     const entry = payloads.get(delivery.id);
@@ -4153,7 +4260,8 @@ var createWebhookHub = (options) => {
         type: message.type,
         tags: message.tags
       });
-      const response = await send(new Request(endpoint.url, {
+      const ownedSend = (request) => transport ? transport(request, message.namespace, send) : send(request);
+      const response = await ownedSend(new Request(endpoint.url, {
         method: "POST",
         headers: {
           "content-type": message.contentType,
@@ -4180,6 +4288,7 @@ var createWebhookHub = (options) => {
     const index = delivery.attempts.length;
     if (index >= delays.length) {
       delivery.state = "failed";
+      notify(delivery);
       pending.delete(delivery.id);
       return;
     }
@@ -4189,9 +4298,10 @@ var createWebhookHub = (options) => {
       await attempt(delivery).then((ok) => {
         if (!payloads.has(delivery.id))
           return;
-        if (ok)
+        if (ok) {
           delivery.state = "delivered";
-        else
+          notify(delivery);
+        } else
           schedule(delivery);
       });
     };
@@ -4200,12 +4310,12 @@ var createWebhookHub = (options) => {
       const task = immediate.then(settle);
       immediate = task.catch(() => {
       });
-      track(task);
+      track(task, delivery);
       return;
     }
     const timer = scheduleTimer(() => {
       pending.delete(delivery.id);
-      track(settle());
+      track(settle(), delivery);
     }, delay);
     unref(timer);
     pending.set(delivery.id, timer);
@@ -4229,6 +4339,8 @@ var createWebhookHub = (options) => {
       payloads.set(delivery.id, { message, endpoint });
       if (state === "pending")
         schedule(delivery);
+      else
+        notify(delivery);
     }
   };
   const takeFault = (namespace) => {
@@ -4250,8 +4362,19 @@ var createWebhookHub = (options) => {
       fanOut(message);
   };
   const hub = {
+    observeDeliveries(listener) {
+      deliveryObservers.add(listener);
+      return () => deliveryObservers.delete(listener);
+    },
+    setTransportPolicy(policy) {
+      transport = policy;
+    },
     pending(namespace) {
-      return inFlight2.size + (held.get(namespace)?.length ?? 0) + [...deliveries.values()].filter((d) => d.namespace === namespace && d.state === "pending").length;
+      const ids = new Set([...deliveries.values()].filter((d) => d.namespace === namespace && d.state === "pending").map((d) => d.id));
+      for (const [id2, active] of activeDeliveries)
+        if (active.namespace === namespace)
+          ids.add(id2);
+      return ids.size + (held.get(namespace)?.length ?? 0);
     },
     snapshot(namespace) {
       if (hub.pending(namespace) > 0)
@@ -4267,6 +4390,36 @@ var createWebhookHub = (options) => {
       }));
       return handle;
     },
+    exportSnapshot(handle) {
+      const point = typeof handle === "object" && handle !== null ? snapshots.get(handle) : void 0;
+      if (!point)
+        throw new Error("invalid webhook snapshot");
+      const { namespace: _namespace, ...document2 } = point;
+      return structuredClone(document2);
+    },
+    importSnapshot(namespace, document2) {
+      if (!isRecord4(document2) || !Array.isArray(document2.endpoints) || !Array.isArray(document2.messages) || !Array.isArray(document2.deliveries) || !Array.isArray(document2.payloads) || !Array.isArray(document2.faults))
+        throw new Error("invalid portable webhook snapshot");
+      for (const endpoint of document2.endpoints)
+        if (typeof parseEndpoint(endpoint) === "string")
+          throw new Error("invalid portable webhook endpoint");
+      for (const message of document2.messages)
+        if (!isRecord4(message) || typeof message.id !== "string" || typeof message.body !== "string")
+          throw new Error("invalid portable webhook message");
+      for (const pair of [...document2.deliveries, ...document2.payloads])
+        if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string" || !isRecord4(pair[1]))
+          throw new Error("invalid portable webhook entry");
+      const handle = {};
+      const point = structuredClone(document2);
+      for (const message of point.messages)
+        message.namespace = namespace;
+      for (const [, delivery] of point.deliveries)
+        delivery.namespace = namespace;
+      for (const [, payload] of point.payloads)
+        payload.message.namespace = namespace;
+      snapshots.set(handle, { ...point, namespace });
+      return handle;
+    },
     restore(namespace, handle) {
       const point = typeof handle === "object" && handle !== null ? snapshots.get(handle) : void 0;
       if (!point || point.namespace !== namespace || hub.pending(namespace) > 0)
@@ -4327,9 +4480,14 @@ var createWebhookHub = (options) => {
       const delivery = deliveries.get(id2);
       if (!delivery)
         return void 0;
-      const ok = await attempt(delivery);
-      if (ok)
-        delivery.state = "delivered";
+      const work = (async () => {
+        const ok = await attempt(delivery);
+        if (ok)
+          delivery.state = "delivered";
+        notify({ ...delivery, state: ok ? "delivered" : "failed" });
+      })();
+      track(work, delivery);
+      await work;
       return delivery;
     },
     async flush() {
@@ -4346,11 +4504,12 @@ var createWebhookHub = (options) => {
           if (!delivery)
             continue;
           track(attempt(delivery).then((ok) => {
-            if (ok)
+            if (ok) {
               delivery.state = "delivered";
-            else
+              notify(delivery);
+            } else
               schedule(delivery);
-          }));
+          }), delivery);
         }
         await hub.idle();
         const scheduled = [...pending.values()].some((timer) => timer !== void 0);
@@ -4358,9 +4517,13 @@ var createWebhookHub = (options) => {
           return;
       }
     },
-    async idle() {
-      while (inFlight2.size > 0)
-        await Promise.allSettled([...inFlight2]);
+    async idle(namespace) {
+      for (; ; ) {
+        const selected = [...inFlight2].filter((work) => namespace === void 0 || workNamespace.get(work) === namespace);
+        if (!selected.length)
+          return;
+        await Promise.allSettled(selected);
+      }
     },
     fault(namespace, fault) {
       const queue = faults.get(namespace) ?? [];
@@ -4973,7 +5136,8 @@ var createRuntime = (options) => {
       ...point.rngState !== void 0 ? { rng: { state: point.rngState, ...streams } } : {},
       ...rules ? { faults: rules } : {},
       ...waits ? { latency: waits } : {},
-      ...settings?.virtualTime !== void 0 ? { virtualTime: settings.virtualTime } : {}
+      ...settings?.virtualTime !== void 0 ? { virtualTime: settings.virtualTime } : {},
+      ...point.webhooks !== void 0 ? { webhooks: options.webhooks?.exportSnapshot(point.webhooks) } : {}
     };
   };
   const position = (value, label) => {
@@ -5058,7 +5222,8 @@ var createRuntime = (options) => {
       records: stored,
       ...document2.clock ? { clock: { now: document2.clock.now, frozen: document2.clock.frozen } } : {},
       ...document2.rng?.state !== void 0 ? { rngState: position(document2.rng.state, "snapshot.rng.state") } : {},
-      controls: held
+      controls: held,
+      ...document2.webhooks !== void 0 ? { webhooks: options.webhooks?.importSnapshot(namespace, document2.webhooks) } : {}
     };
   };
   const kept = /* @__PURE__ */ new Map();
@@ -5192,6 +5357,20 @@ var createRuntime = (options) => {
       restoreAll(namespace, point);
       timelines.delete(namespace);
     },
+    fleetExport(handle) {
+      const point = typeof handle === "object" && handle !== null ? fleetPoints.get(handle) : void 0;
+      if (!point)
+        throw new Error("invalid fleet checkpoint");
+      return toDocument(point);
+    },
+    fleetImport(namespace, document2) {
+      const handle = {};
+      fleetPoints.set(handle, {
+        namespace,
+        ...fromDocument(namespace, assertSnapshotDocument(document2))
+      });
+      return handle;
+    },
     applyPreset: (name2, namespace = DEFAULT_NAMESPACE, overrides = {}) => controls.addFault(namespace, { ...overrides, preset: name2 }),
     instance,
     namespaces: () => [...publicNamespaces].sort(),
@@ -8515,9 +8694,11 @@ export {
   createClock,
   restoreClock,
   parseDuration,
+  normalizeControls,
   normalizeBootControls,
   parseFaultHeader,
   resolveAdminPrefix,
+  ownedTransport,
   document,
   operationIds,
   supportedOperationIds,
@@ -8536,4 +8717,4 @@ export {
  * Copyright (c) 2021 - present, Yusuke Wada and Hono contributors
  * MIT license: see THIRD_PARTY_NOTICES.md in the repository and npm packages.
  */
-//# sourceMappingURL=chunk-YJDLINUI.js.map
+//# sourceMappingURL=chunk-KPX5JPKL.js.map