@zhushanwen/session-delivery 1.0.0 → 2.0.0

package/dist/index.mjs

@@ -44,12 +44,9 @@ var LruSet = class {
 // src/delivery.ts
 var DEFAULT_CONFIG = {
   intent: "interrupt-at-turn-boundary",
-  mergeWindowMs: 0,
-  backoff: { ms: 100, max: 50 },
-  watchdogMs: 3e4
+  mergeWindowMs: 0
 };
 var DEFAULT_DELIVERED_WINDOW = 50;
-var PORT_SEND_SETTLE_TIMEOUT_MS = 6e4;
 function isThenable(v) {
   return !!v && typeof v.then === "function";
 }
@@ -81,6 +78,10 @@ function buildBatchPayload(messages) {
     payload: images.length > 0 ? { kind: "text", content, images } : { kind: "text", content }
   };
 }
+function isolateUnmarkedEntry(batch) {
+  const firstUnmarked = batch.find((e) => e.unmarked);
+  return firstUnmarked !== void 0 ? [firstUnmarked] : batch;
+}
 function settleChecked(batch, err, checkedPending) {
   const rejected = /* @__PURE__ */ new Set();
   if (checkedPending.length === 0) return rejected;
@@ -118,21 +119,19 @@ function resolveWarnSink(config) {
 function createDelivery(port, config) {
   const cfg = {
     ...DEFAULT_CONFIG,
-    ...config,
-    backoff: config?.backoff ?? DEFAULT_CONFIG.backoff
+    ...config
   };
   const active = [];
   const activeIndex = /* @__PURE__ */ new Map();
-  const tombstones = /* @__PURE__ */ new Map();
+  const terminalIndex = /* @__PURE__ */ new Set();
+  const terminalRecords = /* @__PURE__ */ new Map();
+  let checkedRetainWarned = false;
+  let mergeIgnoredWarned = false;
   const deliveredLog = [];
   const checkedPending = [];
   let inflightBatch = [];
   let inFlight = false;
-  let sendAttempts = 0;
   let mergeTimer;
-  let backoffTimer;
-  let hangTimer;
-  let watchdogTimer;
   let disposed = false;
   let settledUnsub;
   let missingKeyWarned = false;
@@ -140,6 +139,40 @@ function createDelivery(port, config) {
   let idSeq = 0;
   const dedupSet = config?.dedupe ? new LruSet(config.dedupe.maxKeys) : null;
   const changeSubs = /* @__PURE__ */ new Set();
+  const store = config?.store;
+  if (store) {
+    for (const id of store.loadTerminalIds()) terminalIndex.add(id);
+  }
+  function persistRecord(e) {
+    if (!store) return;
+    store.persist({
+      id: e.id,
+      lane: e.lane,
+      payload: e.payload,
+      intent: e.msg.intent ?? cfg.intent,
+      recordedAt: e.createdAt,
+      receiptAnchor: e.receiptAnchor,
+      unmarked: e.unmarked,
+      meta: e.msg.meta
+    });
+  }
+  function ackStore(id) {
+    if (!store) return;
+    try {
+      store.ack(id);
+    } catch (err) {
+      warn(`store.ack failed (terminal record not persisted; id=${id})`, err);
+    }
+  }
+  function safeHasTerminal(id) {
+    if (!store) return false;
+    try {
+      return store.hasTerminal(id);
+    } catch (err) {
+      warn(`store.hasTerminal threw; treating as not-terminal (id=${id})`, err);
+      return false;
+    }
+  }
   function now() {
     return Date.now();
   }
@@ -155,7 +188,6 @@ function createDelivery(port, config) {
       payload: e.payload,
       createdAt: e.createdAt,
       updatedAt: e.updatedAt,
-      sendAttempts: e.sendAttempts,
       ...e.settledAt !== void 0 ? { settledAt: e.settledAt } : {}
     };
   }
@@ -205,8 +237,11 @@ function createDelivery(port, config) {
     const ts = now();
     e.updatedAt = ts;
     e.settledAt = ts;
-    tombstones.set(e.id, { id: e.id, state, lane: e.lane, settledAt: ts });
+    terminalIndex.add(e.id);
+    terminalRecords.set(e.id, { id: e.id, state, lane: e.lane, settledAt: ts });
+    ackStore(e.id);
     if (state === "delivered") {
+      resolveWaitersOf(e);
       deliveredLog.push(e);
       if (deliveredLog.length > DEFAULT_DELIVERED_WINDOW) deliveredLog.shift();
     }
@@ -225,6 +260,14 @@ function createDelivery(port, config) {
       }
     }
   }
+  function resolveWaitersOf(e) {
+    for (let i = checkedPending.length - 1; i >= 0; i--) {
+      if (checkedPending[i].entry === e) {
+        checkedPending[i].resolve();
+        checkedPending.splice(i, 1);
+      }
+    }
+  }
   function clearMergeTimer() {
     if (mergeTimer !== void 0) {
       clearTimeout(mergeTimer);
@@ -242,23 +285,11 @@ function createDelivery(port, config) {
     clearMergeTimer();
     armMergeTimer();
   }
-  function clearBackoffTimer() {
-    if (backoffTimer !== void 0) {
-      clearTimeout(backoffTimer);
-      backoffTimer = void 0;
-    }
-  }
-  function clearHangTimer() {
-    if (hangTimer !== void 0) {
-      clearTimeout(hangTimer);
-      hangTimer = void 0;
-    }
-  }
   function ensureSettledSub() {
     if (settledUnsub || !port.subscribeSettled) return;
     settledUnsub = port.subscribeSettled(() => {
       if (disposed) return;
-      if (!isBusySafe()) {
+      if (cfg.dispatchMode === "on-accept" || !isBusySafe()) {
         flush();
       }
     });
@@ -269,30 +300,12 @@ function createDelivery(port, config) {
       settledUnsub = void 0;
     }
   }
-  function startWatchdog() {
-    if (watchdogTimer !== void 0) return;
-    if (!port.subscribeSettled) return;
-    watchdogTimer = setInterval(() => {
-      if (disposed || inFlight) return;
-      if (!hasQueuedEntries()) return;
-      if (!isBusySafe()) {
-        flush();
-      }
-    }, cfg.watchdogMs);
-  }
-  function stopWatchdog() {
-    if (watchdogTimer !== void 0) {
-      clearInterval(watchdogTimer);
-      watchdogTimer = void 0;
-    }
-  }
   function attemptSend() {
     if (inflightBatch.some((e) => !inRegistry(e))) {
       inflightBatch = inflightBatch.filter((e) => inRegistry(e));
     }
     if (inflightBatch.length === 0) {
       inFlight = false;
-      sendAttempts = 0;
       pump();
       return;
     }
@@ -302,30 +315,9 @@ function createDelivery(port, config) {
     try {
       const result = port.send(composed, intent);
       if (isThenable(result)) {
-        let settled = false;
-        clearHangTimer();
-        hangTimer = setTimeout(() => {
-          if (settled || disposed) return;
-          settled = true;
-          hangTimer = void 0;
-          warn(
-            `port.send hung; force-failed after ${PORT_SEND_SETTLE_TIMEOUT_MS}ms (retries may duplicate-deliver; see DeliveryPort.send settle contract)`
-          );
-          onSendFail(new Error(`port.send promise did not settle within ${PORT_SEND_SETTLE_TIMEOUT_MS}ms`));
-        }, PORT_SEND_SETTLE_TIMEOUT_MS);
         result.then(
-          (receipt) => {
-            if (settled) return;
-            settled = true;
-            clearHangTimer();
-            onSendReceipt(receipt);
-          },
-          (err) => {
-            if (settled) return;
-            settled = true;
-            clearHangTimer();
-            onSendFail(err);
-          }
+          (receipt) => onSendReceipt(receipt),
+          (err) => onSendFail(err)
         );
       } else {
         onSendReceipt(result);
@@ -336,6 +328,10 @@ function createDelivery(port, config) {
   }
   function onSendReceipt(receipt) {
     if (receipt !== void 0 && receipt.accepted === false) {
+      if ("deferred" in receipt) {
+        onSendDeferred(receipt.deferred);
+        return;
+      }
       onSendFail(new Error(receipt.reason ?? "port.send rejected (accepted:false)"));
       return;
     }
@@ -346,7 +342,6 @@ function createDelivery(port, config) {
     const batch = inflightBatch;
     inFlight = false;
     inflightBatch = [];
-    sendAttempts = 0;
     settleChecked(batch, void 0, checkedPending);
     let changed = false;
     for (const e of batch) {
@@ -366,49 +361,44 @@ function createDelivery(port, config) {
   }
   function onSendFail(err) {
     if (disposed) return;
-    sendAttempts++;
-    for (const e of inflightBatch) e.sendAttempts = sendAttempts;
-    const rejected = settleChecked(inflightBatch, err, checkedPending);
-    if (rejected.size > 0) {
-      inflightBatch = inflightBatch.filter((e) => !rejected.has(e));
-      for (const e of rejected) removeActive(e);
-      notifyChange();
-    }
-    if (inflightBatch.length === 0) {
-      inFlight = false;
-      inflightBatch = [];
-      sendAttempts = 0;
-      warn("port.send failed", err);
-      pump();
-      return;
+    const batch = inflightBatch;
+    inFlight = false;
+    inflightBatch = [];
+    warn("port.send failed (first-failure stop, no kernel retry)", err);
+    const rejected = settleChecked(batch, err, checkedPending);
+    let changed = false;
+    let retained = false;
+    for (const e of batch) {
+      if (!inRegistry(e)) continue;
+      if (rejected.has(e)) continue;
+      if (e.onFailure === "retain") continue;
+      callOnSettled(e.msg, "rejected");
     }
-    if (sendAttempts > cfg.backoff.max) {
-      const failedBatch = inflightBatch;
-      inFlight = false;
-      inflightBatch = [];
-      sendAttempts = 0;
-      warn("port.send failed after max retries", err);
-      let changed = false;
-      for (const e of failedBatch) {
-        if (disposed) break;
-        if (!inRegistry(e)) continue;
-        e.state = "failed";
-        const ts = now();
-        e.updatedAt = ts;
-        e.settledAt = ts;
+    for (const e of batch) {
+      if (!inRegistry(e)) continue;
+      if (e.onFailure === "retain") {
+        e.state = "queued";
+        e.updatedAt = now();
         changed = true;
-        callOnSettled(e.msg, "rejected");
+        retained = true;
+        warn(`entry retained after failure (id=${e.id}); re-dispatch waits for next settled edge or external flush`);
+        continue;
       }
-      if (changed) notifyChange();
-      pump();
-      return;
+      store?.discard(e.id);
+      removeActive(e);
+      changed = true;
     }
-    if (sendAttempts === 1) warn("port.send failed, retrying with backoff", err);
-    backoffTimer = setTimeout(() => {
-      backoffTimer = void 0;
-      if (disposed || !inFlight) return;
-      attemptSend();
-    }, cfg.backoff.ms);
+    if (changed) notifyChange();
+    if (!retained) pump();
+  }
+  function onSendDeferred(reason) {
+    if (disposed) return;
+    const batch = inflightBatch;
+    inFlight = false;
+    inflightBatch = [];
+    warn(
+      `port.send deferred (designed-in wait, reason=${reason}); ${batch.length} entry(ies) stay queued for next dispatch edge`
+    );
   }
   function pump() {
     if (disposed || inFlight) return;
@@ -418,49 +408,39 @@ function createDelivery(port, config) {
         if (inRegistry(w.entry) && w.entry.state === "queued") batch.push(w.entry);
       }
       if (batch.length > 0) {
-        inflightBatch = batch;
+        inflightBatch = isolateUnmarkedEntry(batch);
         inFlight = true;
-        sendAttempts = 0;
         attemptSend();
         return;
       }
     }
     if (hasQueuedEntries()) {
-      scheduleFlush(0);
+      scheduleFlush();
       return;
     }
-    if (checkedPending.length === 0) stopWatchdog();
   }
   function doSend() {
     if (disposed || inFlight) return;
-    const batch = active.filter((e) => e.state === "queued");
+    const batch = isolateUnmarkedEntry(active.filter((e) => e.state === "queued"));
     if (batch.length === 0) return;
     inFlight = true;
     inflightBatch = batch;
-    sendAttempts = 0;
     attemptSend();
   }
-  function scheduleFlush(attempt) {
+  function scheduleFlush() {
     if (disposed || !hasQueuedEntries()) return;
     if (inFlight) return;
-    clearBackoffTimer();
-    if (isBusySafe() && attempt < cfg.backoff.max) {
-      if (port.subscribeSettled) {
-        startWatchdog();
-        return;
-      }
-      backoffTimer = setTimeout(() => {
-        backoffTimer = void 0;
-        scheduleFlush(attempt + 1);
-      }, cfg.backoff.ms);
-      return;
-    }
+    if (cfg.dispatchMode !== "on-accept" && isBusySafe()) return;
     doSend();
   }
   const warnSink = resolveWarnSink(config);
   function warn(msg, err) {
     warnSink(msg, err);
   }
+  if (config?.dispatchMode === "on-accept" && (config.mergeWindowMs ?? 0) > 0 && !mergeIgnoredWarned) {
+    mergeIgnoredWarned = true;
+    warn("dispatchMode=on-accept ignores mergeWindowMs (batching moves to submit side)");
+  }
   function passDedupe(msg) {
     if (!dedupSet) return true;
     if (!msg.dedupeKey) {
@@ -476,7 +456,22 @@ function createDelivery(port, config) {
   }
   function seenId(id) {
     if (id === void 0) return false;
-    return activeIndex.has(id) || tombstones.has(id);
+    if (activeIndex.has(id)) return true;
+    if (terminalIndex.has(id)) return true;
+    return safeHasTerminal(id);
+  }
+  function resolveOnFailure(msg, opts) {
+    return opts?.onFailure ?? (msg.payload.kind === "custom" ? "retain" : "forget");
+  }
+  function persistBeforeAccept(e) {
+    try {
+      persistRecord(e);
+      return true;
+    } catch (err) {
+      warn(`store.persist failed before accept; entry rejected (id=${e.id})`, err);
+      removeActive(e);
+      return false;
+    }
   }
   function createEntry(msg, opts) {
     const ts = now();
@@ -487,10 +482,11 @@ function createDelivery(port, config) {
       payload: msg.payload,
       createdAt: ts,
       updatedAt: ts,
-      sendAttempts: 0,
       msg,
       cancelRequested: false,
-      receiptAnchor: opts?.receiptAnchor ?? "marker"
+      receiptAnchor: opts?.receiptAnchor ?? "marker",
+      unmarked: opts?.unmarked ?? false,
+      onFailure: resolveOnFailure(msg, opts)
     };
     active.push(entry);
     activeIndex.set(entry.id, entry);
@@ -512,7 +508,10 @@ function createDelivery(port, config) {
     }
     if (!passDedupe(msg)) return { kind: "swallowed", reason: "duplicate-content" };
     const entry = createEntry(msg, opts);
-    const useMerge = opts?.merge ?? (cfg.mergeWindowMs > 0 && cfg.mergeHoldActive != null && cfg.mergeHoldActive());
+    if (!persistBeforeAccept(entry)) {
+      return { kind: "rejected", reason: "persist-failed" };
+    }
+    const useMerge = cfg.dispatchMode !== "on-accept" && (opts?.merge ?? (cfg.mergeWindowMs > 0 && cfg.mergeHoldActive != null && cfg.mergeHoldActive()));
     if (useMerge) {
       resetMergeTimer();
       ensureSettledSub();
@@ -520,7 +519,7 @@ function createDelivery(port, config) {
     }
     clearMergeTimer();
     ensureSettledSub();
-    scheduleFlush(0);
+    scheduleFlush();
     return { kind: "accepted", id: entry.id };
   }
   async function sendChecked(msg, opts) {
@@ -533,14 +532,23 @@ function createDelivery(port, config) {
       return;
     }
     if (!passDedupe(msg)) return;
+    if (opts?.onFailure === "retain") {
+      if (!checkedRetainWarned) {
+        checkedRetainWarned = true;
+        warn("sendChecked ignores onFailure=retain (checked entries are always forget)");
+      }
+      opts = { ...opts, onFailure: "forget" };
+    }
     const entry = createEntry(msg, opts);
+    if (!persistBeforeAccept(entry)) {
+      throw new Error(`store.persist failed before accept (id=${entry.id})`);
+    }
     ensureSettledSub();
     return new Promise((resolve, reject) => {
       checkedPending.push({ entry, resolve, reject });
       if (!inFlight) {
         inflightBatch = [entry];
         inFlight = true;
-        sendAttempts = 0;
         attemptSend();
       }
     });
@@ -548,7 +556,7 @@ function createDelivery(port, config) {
   function flush() {
     if (disposed) return;
     clearMergeTimer();
-    scheduleFlush(0);
+    scheduleFlush();
   }
   function depth() {
     let n = 0;
@@ -558,7 +566,7 @@ function createDelivery(port, config) {
   function entriesFull() {
     return {
       active: active.map(snapshot),
-      tombstones: [...tombstones.values()].map((t) => ({ ...t }))
+      tombstones: [...terminalRecords.values()].map((t) => ({ ...t }))
     };
   }
   function projection() {
@@ -582,6 +590,28 @@ function createDelivery(port, config) {
     if (!disposed) callOnSettled(e.msg, "delivered");
     return true;
   }
+  function confirmDeliveredByProof(id) {
+    if (disposed) {
+      warn(`confirmDeliveredByProof ignored: delivery handle disposed (id=${id})`);
+      return false;
+    }
+    const e = activeIndex.get(id);
+    if (!e || e.receiptAnchor !== "details-id") return false;
+    if (e.state !== "queued" && e.state !== "in-flight") return false;
+    if (!cfg.proofCheck) {
+      warn(`details-id entry has no proofCheck injected; delivery unconfirmed (id=${id})`);
+      return false;
+    }
+    let proven;
+    try {
+      proven = cfg.proofCheck(id);
+    } catch (err) {
+      warn(`proofCheck threw; treating as not-delivered (id=${id})`, err);
+      return false;
+    }
+    if (!proven) return false;
+    return confirmDelivered(id);
+  }
   function confirmAccepted(id) {
     if (disposed) return false;
     const e = activeIndex.get(id);
@@ -616,13 +646,12 @@ function createDelivery(port, config) {
       const idx = active.indexOf(e);
       if (idx !== -1) active.splice(idx, 1);
       e.state = "queued";
-      e.sendAttempts = 0;
       e.updatedAt = now();
       e.settledAt = void 0;
     }
     active.unshift(...found);
     notifyChange();
-    scheduleFlush(0);
+    scheduleFlush();
     return found.length;
   }
   function cancel(id) {
@@ -632,7 +661,7 @@ function createDelivery(port, config) {
     }
     const e = activeIndex.get(id);
     if (!e) {
-      const tb = tombstones.get(id);
+      const tb = terminalRecords.get(id);
       if (tb) return { kind: "already-final", tombstone: { ...tb } };
       return { kind: "not-found" };
     }
@@ -651,40 +680,56 @@ function createDelivery(port, config) {
     finalizeEntry(e, "cancelled");
     return { kind: "cancelled", entry: snapshot(e) };
   }
+  function failInFlight(reason) {
+    if (disposed) return 0;
+    const ts = now();
+    let count = 0;
+    for (const e of active) {
+      if (e.state !== "in-flight") continue;
+      const batchIdx = inflightBatch.indexOf(e);
+      if (batchIdx !== -1) inflightBatch.splice(batchIdx, 1);
+      e.state = "failed";
+      e.updatedAt = ts;
+      e.settledAt = ts;
+      count++;
+      callOnSettled(e.msg, "rejected");
+    }
+    if (count > 0) {
+      warn(`failInFlight: ${count} in-flight entry(ies) marked failed (${reason})`);
+      notifyChange();
+    }
+    return count;
+  }
   function drain() {
     if (disposed) return [];
     clearMergeTimer();
-    clearBackoffTimer();
-    clearHangTimer();
     const drained = active.slice();
     active.length = 0;
     activeIndex.clear();
     inflightBatch = [];
     inFlight = false;
-    sendAttempts = 0;
     const ts = now();
     const result = drained.map((e) => {
-      tombstones.set(e.id, { id: e.id, state: "cancelled", lane: e.lane, settledAt: ts });
+      terminalIndex.add(e.id);
+      terminalRecords.set(e.id, { id: e.id, state: "cancelled", lane: e.lane, settledAt: ts });
+      ackStore(e.id);
       return { id: e.id, payload: e.payload };
     });
     for (const w of checkedPending) {
       w.reject(new DeliveryReclaimError("drained"));
     }
     checkedPending.length = 0;
-    stopWatchdog();
     if (drained.length > 0) notifyChange();
     return result;
   }
   function dispose() {
     disposed = true;
     clearMergeTimer();
-    clearBackoffTimer();
-    clearHangTimer();
-    stopWatchdog();
     teardownSettledSub();
     active.length = 0;
     activeIndex.clear();
-    tombstones.clear();
+    terminalIndex.clear();
+    terminalRecords.clear();
     deliveredLog.length = 0;
     inflightBatch = [];
     inFlight = false;
@@ -695,9 +740,123 @@ function createDelivery(port, config) {
     checkedPending.length = 0;
     dedupSet?.clear();
   }
-  return { send, sendChecked, flush, depth, entriesFull, projection, onChange, confirmDelivered, confirmAccepted, requeue, cancel, drain, dispose };
+  return { send, sendChecked, flush, depth, entriesFull, projection, onChange, confirmDelivered, confirmDeliveredByProof, confirmAccepted, requeue, cancel, failInFlight, drain, dispose };
+}
+
+// src/disk-store.ts
+function serializeLine(line) {
+  return `${JSON.stringify(line)}
+`;
+}
+function createDiskDeliveryStore(deps) {
+  const { fs, dir, file } = deps;
+  const log = deps.log ?? ((message, err) => {
+    console.warn(message, err ?? "");
+  });
+  let loaded = false;
+  const records = /* @__PURE__ */ new Map();
+  const terminalIds = /* @__PURE__ */ new Set();
+  const discardedIds = /* @__PURE__ */ new Set();
+  let dirCreated = false;
+  function applyLine(line) {
+    if (line.t === "record") {
+      records.set(line.r.id, line.r);
+      discardedIds.delete(line.r.id);
+      return;
+    }
+    if (line.t === "ack") {
+      terminalIds.add(line.id);
+      return;
+    }
+    if (line.t === "discard") {
+      discardedIds.add(line.id);
+      records.delete(line.id);
+      return;
+    }
+    const record = records.get(line.id);
+    if (record) {
+      record.meta = { ...record.meta, segments: line.segments };
+    }
+  }
+  function ensureLoaded() {
+    if (loaded) return;
+    loaded = true;
+    if (!fs.existsSync(file)) return;
+    let raw;
+    try {
+      raw = fs.readFileSync(file, "utf8");
+    } catch (err) {
+      log(`[disk-delivery-store] read failed (treated as empty), file=${file}`, err);
+      return;
+    }
+    let lineNumber = 0;
+    for (const lineText of raw.split("\n")) {
+      lineNumber += 1;
+      const trimmed = lineText.trim();
+      if (trimmed === "") continue;
+      let line;
+      try {
+        line = JSON.parse(trimmed);
+      } catch {
+        log(`[disk-delivery-store] corrupted line skipped, file=${file}, line=${lineNumber}`);
+        continue;
+      }
+      if (!line || typeof line !== "object" || typeof line.t !== "string") {
+        log(`[disk-delivery-store] malformed line skipped, file=${file}, line=${lineNumber}`);
+        continue;
+      }
+      applyLine(line);
+    }
+  }
+  function appendLine(line) {
+    if (!dirCreated) {
+      fs.mkdirSync(dir, { recursive: true });
+      dirCreated = true;
+    }
+    fs.appendFileSync(file, serializeLine(line));
+  }
+  return {
+    persist(record) {
+      ensureLoaded();
+      appendLine({ t: "record", r: record });
+      applyLine({ t: "record", r: record });
+    },
+    ack(id) {
+      ensureLoaded();
+      appendLine({ t: "ack", id, at: Date.now() });
+      applyLine({ t: "ack", id, at: 0 });
+    },
+    discard(id) {
+      ensureLoaded();
+      appendLine({ t: "discard", id, at: Date.now() });
+      applyLine({ t: "discard", id, at: 0 });
+    },
+    loadUndelivered() {
+      ensureLoaded();
+      const out = [];
+      for (const record of records.values()) {
+        if (terminalIds.has(record.id) || discardedIds.has(record.id)) continue;
+        out.push(record);
+      }
+      return out;
+    },
+    loadTerminalIds() {
+      ensureLoaded();
+      return [...terminalIds];
+    },
+    hasTerminal(id) {
+      ensureLoaded();
+      return terminalIds.has(id);
+    },
+    attachSegments(id, segments) {
+      ensureLoaded();
+      appendLine({ t: "meta", id, segments: [...segments] });
+      applyLine({ t: "meta", id, segments: [...segments] });
+    }
+  };
 }
 export {
   DeliveryReclaimError,
-  createDelivery
+  createDelivery,
+  createDiskDeliveryStore
 };