@lunora/do 1.0.0-alpha.6 → 1.0.0-alpha.7

package/dist/index.d.mts

@@ -3666,6 +3666,44 @@ declare class SessionDO {
   private handleRevoke;
 }
 /**
+* Diff the previously-sent list snapshot (`previousJson`, the memo's
+* `lastJson`) against the new query result and produce per-row
+* {@link MutationDelta}s the client can merge in place via `applyDelta` —
+* Convex-parity live-pagination deltas (server half of gap #20).
+*
+* Returns `undefined` (caller falls back to a full `{type:"data"}` snapshot)
+* unless ALL of these hold:
+*
+* 1. `previousJson` parses to an array (there IS a previous list to diff against).
+* 2. `nextResult` is also an array.
+* 3. Every row in both arrays is a plain object carrying a string `_id`.
+* 4. Order preservation — rows present in BOTH arrays appear in the same relative order.
+* 5. Chattiness cap — the number of deltas does not exceed the new array length (a near-total change is cheaper as a snapshot).
+*
+* Diff is keyed by `_id`: rows only in prev → `delete`; rows only in next →
+* `insert`; rows in both whose JSON differs → `update`. Insert/update carry the
+* full new `row`; delete omits it (matching the wire contract `@lunora/client`
+* parses). Deltas are ordered deletes-then-inserts/updates so the client never
+* sees a transient over-length page.
+*
+* Per-row serialization is done exactly **once** per refresh (finding #6). Each
+* row is stringified a single time into a fingerprint reused for both the
+* `prev !== next` change-detection compare and — when the caller passes the
+* optional `frames` sink — the pre-serialized delta frame body. The returned
+* `MutationDelta[]` shape is unchanged; `frames`, when supplied, receives the
+* exact `JSON.stringify(delta)` string for each returned delta, in the same
+* order, so the caller can splice it straight into the `{type:"delta"}` frame
+* without serializing the delta (and the row inside it) a second time.
+* @returns the per-row deltas to send, or `undefined` when any precondition fails and a full snapshot should be sent instead
+*/
+declare const subscriptionListDeltas: (previousJson: string, nextResult: unknown, table: string, frames?: string[]) => MutationDelta[] | undefined;
+/**
+* Send one WebSocket frame, reporting whether it left the socket. A throw from
+* `ws.send` (socket closed mid-flush, outbound buffer gone) is the only
+* delivery-failure signal the runtime exposes; callers use the boolean to decide
+* whether to advance a subscription's delivered-diff baseline.
+*/
+/**
 * Optional programmatic log sink, resolved from `createShardDO({ observability })`.
 * Structurally a subset of `@lunora/runtime`'s `ObservabilitySink`, so a user can
 * pass the SAME sink object to `createWorker` (which drives `onRpc`) and
@@ -3918,38 +3956,6 @@ interface RunShardRankPageArgs {
   take?: number;
 }
 /**
-* Diff the previously-sent list snapshot (`previousJson`, the memo's
-* `lastJson`) against the new query result and produce per-row
-* {@link MutationDelta}s the client can merge in place via `applyDelta` —
-* Convex-parity live-pagination deltas (server half of gap #20).
-*
-* Returns `undefined` (caller falls back to a full `{type:"data"}` snapshot)
-* unless ALL of these hold:
-*
-* 1. `previousJson` parses to an array (there IS a previous list to diff against).
-* 2. `nextResult` is also an array.
-* 3. Every row in both arrays is a plain object carrying a string `_id`.
-* 4. Order preservation — rows present in BOTH arrays appear in the same relative order.
-* 5. Chattiness cap — the number of deltas does not exceed the new array length (a near-total change is cheaper as a snapshot).
-*
-* Diff is keyed by `_id`: rows only in prev → `delete`; rows only in next →
-* `insert`; rows in both whose JSON differs → `update`. Insert/update carry the
-* full new `row`; delete omits it (matching the wire contract `@lunora/client`
-* parses). Deltas are ordered deletes-then-inserts/updates so the client never
-* sees a transient over-length page.
-*
-* Per-row serialization is done exactly **once** per refresh (finding #6). Each
-* row is stringified a single time into a fingerprint reused for both the
-* `prev !== next` change-detection compare and — when the caller passes the
-* optional `frames` sink — the pre-serialized delta frame body. The returned
-* `MutationDelta[]` shape is unchanged; `frames`, when supplied, receives the
-* exact `JSON.stringify(delta)` string for each returned delta, in the same
-* order, so the caller can splice it straight into the `{type:"delta"}` frame
-* without serializing the delta (and the row inside it) a second time.
-* @returns the per-row deltas to send, or `undefined` when any precondition fails and a full snapshot should be sent instead
-*/
-declare const subscriptionListDeltas: (previousJson: string, nextResult: unknown, table: string, frames?: string[]) => MutationDelta[] | undefined;
-/**
 * Threshold at which a `__root__` DO triggers the size warning. 1 GiB —
 * exactly 10% of the 10 GiB per-DO SQLite ceiling, leaving plenty of runway
 * to plan a `.shardBy()` migration before the wall hits.
@@ -4131,6 +4137,18 @@ declare abstract class ShardDO {
   */
   private pendingChangedTables;
   /**
+  * Coalesced set of tables awaiting a subscription-refresh pass, merged
+  * across every {@link ShardDO.flushChangedTables} call that lands while a
+  * pass is already draining. The single drain loop
+  * ({@link ShardDO.drainSubscriptionRefreshes}) owns this set; a burst of N
+  * writes to the same table therefore collapses into one (or two) refresh
+  * passes instead of N, so each affected subscription's handler re-runs once
+  * per burst rather than once per write. `undefined` when nothing is pending.
+  */
+  private pendingRefreshTables;
+  /** True while {@link ShardDO.drainSubscriptionRefreshes} is running; the single-waiter gate that coalesces concurrent flushes. */
+  private refreshInFlight;
+  /**
   * Last pushed result per `(socket, subId)`, keyed by socket. Lets
   * `refreshSubscriptions` skip re-running queries whose tables were
   * untouched and suppress pushes when the re-run result is unchanged. Held
@@ -5303,6 +5321,17 @@ declare abstract class ShardDO {
   */
   private flushChangedTables;
   /**
+  * Drain {@link ShardDO.pendingRefreshTables} one coalesced batch at a time
+  * until it is empty, then release the {@link ShardDO.refreshInFlight} gate.
+  * Tables merged by a `flushChangedTables` that lands mid-pass are picked up
+  * by the next loop iteration, so every committed write is observed by a
+  * refresh that runs after it — bursts simply share a pass. The post-write
+  * high-watermark and live-socket set are re-read inside each
+  * `refreshSubscriptions` call, so a later batch always reflects the latest
+  * committed state.
+  */
+  private drainSubscriptionRefreshes;
+  /**
   * For every live subscription whose query reads one of `changed`, re-run
   * the query and push a fresh `{ type: "data" }` frame when the result
   * differs from the last one sent. Subscriptions with no `functionPath`

package/dist/index.d.ts

@@ -3666,6 +3666,44 @@ declare class SessionDO {
   private handleRevoke;
 }
 /**
+* Diff the previously-sent list snapshot (`previousJson`, the memo's
+* `lastJson`) against the new query result and produce per-row
+* {@link MutationDelta}s the client can merge in place via `applyDelta` —
+* Convex-parity live-pagination deltas (server half of gap #20).
+*
+* Returns `undefined` (caller falls back to a full `{type:"data"}` snapshot)
+* unless ALL of these hold:
+*
+* 1. `previousJson` parses to an array (there IS a previous list to diff against).
+* 2. `nextResult` is also an array.
+* 3. Every row in both arrays is a plain object carrying a string `_id`.
+* 4. Order preservation — rows present in BOTH arrays appear in the same relative order.
+* 5. Chattiness cap — the number of deltas does not exceed the new array length (a near-total change is cheaper as a snapshot).
+*
+* Diff is keyed by `_id`: rows only in prev → `delete`; rows only in next →
+* `insert`; rows in both whose JSON differs → `update`. Insert/update carry the
+* full new `row`; delete omits it (matching the wire contract `@lunora/client`
+* parses). Deltas are ordered deletes-then-inserts/updates so the client never
+* sees a transient over-length page.
+*
+* Per-row serialization is done exactly **once** per refresh (finding #6). Each
+* row is stringified a single time into a fingerprint reused for both the
+* `prev !== next` change-detection compare and — when the caller passes the
+* optional `frames` sink — the pre-serialized delta frame body. The returned
+* `MutationDelta[]` shape is unchanged; `frames`, when supplied, receives the
+* exact `JSON.stringify(delta)` string for each returned delta, in the same
+* order, so the caller can splice it straight into the `{type:"delta"}` frame
+* without serializing the delta (and the row inside it) a second time.
+* @returns the per-row deltas to send, or `undefined` when any precondition fails and a full snapshot should be sent instead
+*/
+declare const subscriptionListDeltas: (previousJson: string, nextResult: unknown, table: string, frames?: string[]) => MutationDelta[] | undefined;
+/**
+* Send one WebSocket frame, reporting whether it left the socket. A throw from
+* `ws.send` (socket closed mid-flush, outbound buffer gone) is the only
+* delivery-failure signal the runtime exposes; callers use the boolean to decide
+* whether to advance a subscription's delivered-diff baseline.
+*/
+/**
 * Optional programmatic log sink, resolved from `createShardDO({ observability })`.
 * Structurally a subset of `@lunora/runtime`'s `ObservabilitySink`, so a user can
 * pass the SAME sink object to `createWorker` (which drives `onRpc`) and
@@ -3918,38 +3956,6 @@ interface RunShardRankPageArgs {
   take?: number;
 }
 /**
-* Diff the previously-sent list snapshot (`previousJson`, the memo's
-* `lastJson`) against the new query result and produce per-row
-* {@link MutationDelta}s the client can merge in place via `applyDelta` —
-* Convex-parity live-pagination deltas (server half of gap #20).
-*
-* Returns `undefined` (caller falls back to a full `{type:"data"}` snapshot)
-* unless ALL of these hold:
-*
-* 1. `previousJson` parses to an array (there IS a previous list to diff against).
-* 2. `nextResult` is also an array.
-* 3. Every row in both arrays is a plain object carrying a string `_id`.
-* 4. Order preservation — rows present in BOTH arrays appear in the same relative order.
-* 5. Chattiness cap — the number of deltas does not exceed the new array length (a near-total change is cheaper as a snapshot).
-*
-* Diff is keyed by `_id`: rows only in prev → `delete`; rows only in next →
-* `insert`; rows in both whose JSON differs → `update`. Insert/update carry the
-* full new `row`; delete omits it (matching the wire contract `@lunora/client`
-* parses). Deltas are ordered deletes-then-inserts/updates so the client never
-* sees a transient over-length page.
-*
-* Per-row serialization is done exactly **once** per refresh (finding #6). Each
-* row is stringified a single time into a fingerprint reused for both the
-* `prev !== next` change-detection compare and — when the caller passes the
-* optional `frames` sink — the pre-serialized delta frame body. The returned
-* `MutationDelta[]` shape is unchanged; `frames`, when supplied, receives the
-* exact `JSON.stringify(delta)` string for each returned delta, in the same
-* order, so the caller can splice it straight into the `{type:"delta"}` frame
-* without serializing the delta (and the row inside it) a second time.
-* @returns the per-row deltas to send, or `undefined` when any precondition fails and a full snapshot should be sent instead
-*/
-declare const subscriptionListDeltas: (previousJson: string, nextResult: unknown, table: string, frames?: string[]) => MutationDelta[] | undefined;
-/**
 * Threshold at which a `__root__` DO triggers the size warning. 1 GiB —
 * exactly 10% of the 10 GiB per-DO SQLite ceiling, leaving plenty of runway
 * to plan a `.shardBy()` migration before the wall hits.
@@ -4131,6 +4137,18 @@ declare abstract class ShardDO {
   */
   private pendingChangedTables;
   /**
+  * Coalesced set of tables awaiting a subscription-refresh pass, merged
+  * across every {@link ShardDO.flushChangedTables} call that lands while a
+  * pass is already draining. The single drain loop
+  * ({@link ShardDO.drainSubscriptionRefreshes}) owns this set; a burst of N
+  * writes to the same table therefore collapses into one (or two) refresh
+  * passes instead of N, so each affected subscription's handler re-runs once
+  * per burst rather than once per write. `undefined` when nothing is pending.
+  */
+  private pendingRefreshTables;
+  /** True while {@link ShardDO.drainSubscriptionRefreshes} is running; the single-waiter gate that coalesces concurrent flushes. */
+  private refreshInFlight;
+  /**
   * Last pushed result per `(socket, subId)`, keyed by socket. Lets
   * `refreshSubscriptions` skip re-running queries whose tables were
   * untouched and suppress pushes when the re-run result is unchanged. Held
@@ -5303,6 +5321,17 @@ declare abstract class ShardDO {
   */
   private flushChangedTables;
   /**
+  * Drain {@link ShardDO.pendingRefreshTables} one coalesced batch at a time
+  * until it is empty, then release the {@link ShardDO.refreshInFlight} gate.
+  * Tables merged by a `flushChangedTables` that lands mid-pass are picked up
+  * by the next loop iteration, so every committed write is observed by a
+  * refresh that runs after it — bursts simply share a pass. The post-write
+  * high-watermark and live-socket set are re-read inside each
+  * `refreshSubscriptions` call, so a later batch always reflects the latest
+  * committed state.
+  */
+  private drainSubscriptionRefreshes;
+  /**
   * For every live subscription whose query reads one of `changed`, re-run
   * the query and push a fresh `{ type: "data" }` frame when the result
   * differs from the last one sent. Subscriptions with no `functionPath`

package/dist/index.mjs

@@ -23,7 +23,7 @@ export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_share
 export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch } from './packem_shared/buildFtsMatch-BLEMawrp.mjs';
 export { M as MIN_ADMIN_TOKEN_LENGTH, a as MIN_AUTH_SECRET_LENGTH, b as buildSecurityAudit } from './packem_shared/security-audit-CucgBice.mjs';
 export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-ilPZsVwu.mjs';
-export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO, subscriptionListDeltas } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-DfwcxW8F.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-2DxWrdla.mjs';
 export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-BsAbi5Mn.mjs';
 export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-dDcFE1YZ.mjs';
 export { createSystemReader } from './packem_shared/createSystemReader-8CzSZP9V.mjs';
@@ -33,3 +33,4 @@ export { compileWhereSql } from './packem_shared/compileWhereSql-CXrhFA3G.mjs';
 export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-Ctdmxmrv.mjs';
 export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-BbVPvciS.mjs';
 export { runShardMigrations } from './packem_shared/runShardMigrations-PabobOjF.mjs';
+export { subscriptionListDeltas } from './packem_shared/subscriptionListDeltas-ce84gpwL.mjs';

package/dist/packem_shared/{ROOT_DO_SIZE_WARN_BYTES-DfwcxW8F.mjs → ROOT_DO_SIZE_WARN_BYTES-2DxWrdla.mjs}

@@ -12,6 +12,7 @@ import { ReactiveCache, reactiveCacheKey } from './ReactiveCache-ByVzgH3d.mjs';
 import { redact, standardRules } from '@visulima/redact';
 import { i as isDevEnvironment, c as buildSettings, b as buildSecurityAudit } from './security-audit-CucgBice.mjs';
 import { runReadonlySql } from './MAX_SQL_ROWS-dDcFE1YZ.mjs';
+import { trySendFrame, subscriptionListDeltas, sendDeltaFrames } from './subscriptionListDeltas-ce84gpwL.mjs';
 import { ConflictError } from './ConflictError-C0STs6bU.mjs';
 import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-Ctdmxmrv.mjs';
 import { r as readIdempotent, w as writeIdempotent, t as trimIdempotent } from './ctx-db-idempotency-DkC9rP91.mjs';
@@ -413,97 +414,7 @@ const findDanglingReferences = (sql, storageColumns, liveKeys) => {
 
 const WS_KEEPALIVE_PING = "lunora-ping";
 const WS_KEEPALIVE_PONG = "lunora-pong";
-const ROW_ID_FIELD = "_id";
-const DELTA_FALLBACK_TABLE = "__lunora__";
-const readRowId = (row) => {
-  if (typeof row !== "object" || row === null || Array.isArray(row)) {
-    return void 0;
-  }
-  const id = row[ROW_ID_FIELD];
-  return typeof id === "string" ? id : void 0;
-};
-const indexRowsById = (rows) => {
-  const byId = /* @__PURE__ */ new Map();
-  const order = [];
-  for (const row of rows) {
-    const id = readRowId(row);
-    if (id === void 0 || byId.has(id)) {
-      return void 0;
-    }
-    byId.set(id, row);
-    order.push(id);
-  }
-  return { byId, order };
-};
-const survivorsKeepOrder = (previous, next) => {
-  const survivingPrevious = previous.order.filter((id) => next.byId.has(id));
-  const survivingNext = next.order.filter((id) => previous.byId.has(id));
-  if (survivingPrevious.length !== survivingNext.length) {
-    return false;
-  }
-  return survivingPrevious.every((id, index) => survivingNext[index] === id);
-};
-const collectDeleteDeltas = (previous, next, deltaTable, tableJson) => {
-  const out = [];
-  for (const id of previous.order) {
-    if (!next.byId.has(id)) {
-      out.push({
-        delta: { key: id, op: "delete", table: deltaTable },
-        frame: `{"key":${JSON.stringify(id)},"op":"delete","table":${tableJson}}`
-      });
-    }
-  }
-  return out;
-};
-const collectUpsertDeltas = (previous, next, deltaTable, tableJson) => {
-  const out = [];
-  for (const id of next.order) {
-    const nextRow = next.byId.get(id);
-    const previousRow = previous.byId.get(id);
-    const nextFingerprint = JSON.stringify(nextRow);
-    const previousFingerprint = previousRow === void 0 ? void 0 : JSON.stringify(previousRow);
-    if (previousFingerprint === nextFingerprint) {
-      continue;
-    }
-    const op = previousFingerprint === void 0 ? "insert" : "update";
-    out.push({
-      delta: { key: id, op, row: nextRow, table: deltaTable },
-      frame: `{"key":${JSON.stringify(id)},"op":"${op}","row":${nextFingerprint},"table":${tableJson}}`
-    });
-  }
-  return out;
-};
-const subscriptionListDeltas = (previousJson, nextResult, table, frames) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(previousJson);
-  } catch {
-    return void 0;
-  }
-  if (!Array.isArray(parsed) || !Array.isArray(nextResult)) {
-    return void 0;
-  }
-  const previous = indexRowsById(parsed);
-  const next = indexRowsById(nextResult);
-  if (previous === void 0 || next === void 0) {
-    return void 0;
-  }
-  if (!survivorsKeepOrder(previous, next)) {
-    return void 0;
-  }
-  const deltaTable = table === "" ? DELTA_FALLBACK_TABLE : table;
-  const tableJson = JSON.stringify(deltaTable);
-  const framed = [...collectDeleteDeltas(previous, next, deltaTable, tableJson), ...collectUpsertDeltas(previous, next, deltaTable, tableJson)];
-  if (framed.length > next.order.length) {
-    return void 0;
-  }
-  if (frames !== void 0) {
-    for (const { frame } of framed) {
-      frames.push(frame);
-    }
-  }
-  return framed.map(({ delta }) => delta);
-};
+const UNDELIVERED_BASELINE = "<undelivered>";
 const ROOT_DO_SIZE_WARN_BYTES = 1073741824;
 const CDC_RESUME_SCAN_LIMIT = 1e4;
 const IDEMPOTENCY_RETENTION_MS = 864e5;
@@ -1133,6 +1044,18 @@ class ShardDO {
    * the common read-only path allocates nothing.
    */
   pendingChangedTables = void 0;
+  /**
+   * Coalesced set of tables awaiting a subscription-refresh pass, merged
+   * across every {@link ShardDO.flushChangedTables} call that lands while a
+   * pass is already draining. The single drain loop
+   * ({@link ShardDO.drainSubscriptionRefreshes}) owns this set; a burst of N
+   * writes to the same table therefore collapses into one (or two) refresh
+   * passes instead of N, so each affected subscription's handler re-runs once
+   * per burst rather than once per write. `undefined` when nothing is pending.
+   */
+  pendingRefreshTables = void 0;
+  /** True while {@link ShardDO.drainSubscriptionRefreshes} is running; the single-waiter gate that coalesces concurrent flushes. */
+  refreshInFlight = false;
   /**
    * Last pushed result per `(socket, subId)`, keyed by socket. Lets
    * `refreshSubscriptions` skip re-running queries whose tables were
@@ -2249,10 +2172,7 @@ class ShardDO {
         if (!this.matchesSubscription(query, delta)) {
           continue;
         }
-        try {
-          ws.send(`{"type":"delta","id":${JSON.stringify(subId)},"delta":${deltaJson}}`);
-        } catch {
-        }
+        trySendFrame(ws, `{"type":"delta","id":${JSON.stringify(subId)},"delta":${deltaJson}}`);
       }
     }
   }
@@ -3567,11 +3487,47 @@ class ShardDO {
     if (!changed || changed.size === 0) {
       return;
     }
+    if (this.pendingRefreshTables) {
+      for (const table of changed) {
+        this.pendingRefreshTables.add(table);
+      }
+    } else {
+      this.pendingRefreshTables = changed;
+    }
+    if (this.refreshInFlight) {
+      return;
+    }
     if (typeof this.state.waitUntil === "function") {
-      this.state.waitUntil(this.refreshSubscriptions(changed));
+      this.state.waitUntil(this.drainSubscriptionRefreshes());
+      return;
+    }
+    await this.drainSubscriptionRefreshes();
+  }
+  /**
+   * Drain {@link ShardDO.pendingRefreshTables} one coalesced batch at a time
+   * until it is empty, then release the {@link ShardDO.refreshInFlight} gate.
+   * Tables merged by a `flushChangedTables` that lands mid-pass are picked up
+   * by the next loop iteration, so every committed write is observed by a
+   * refresh that runs after it — bursts simply share a pass. The post-write
+   * high-watermark and live-socket set are re-read inside each
+   * `refreshSubscriptions` call, so a later batch always reflects the latest
+   * committed state.
+   */
+  async drainSubscriptionRefreshes() {
+    if (this.refreshInFlight) {
       return;
     }
-    await this.refreshSubscriptions(changed);
+    this.refreshInFlight = true;
+    try {
+      let batch = this.pendingRefreshTables;
+      while (batch && batch.size > 0) {
+        this.pendingRefreshTables = void 0;
+        await this.refreshSubscriptions(batch);
+        batch = this.pendingRefreshTables;
+      }
+    } finally {
+      this.refreshInFlight = false;
+    }
   }
   /**
    * For every live subscription whose query reads one of `changed`, re-run
@@ -3763,21 +3719,8 @@ class ShardDO {
     }
     const deltaFrames = [];
     const deltas = existing === void 0 ? void 0 : subscriptionListDeltas(existing.lastJson, outcome.result, outcome.tables.values().next().value ?? "", deltaFrames);
-    memos.set(subId, { lastJson: json, tables: outcome.tables });
-    if (deltas !== void 0) {
-      const idJson = JSON.stringify(subId);
-      for (const deltaBody of deltaFrames) {
-        try {
-          ws.send(`{"type":"delta","id":${idJson},"delta":${deltaBody}${cursorSuffix}}`);
-        } catch {
-        }
-      }
-      return;
-    }
-    try {
-      ws.send(`{"type":"data","id":${JSON.stringify(subId)},"data":${json}${cursorSuffix}}`);
-    } catch {
-    }
+    const delivered = deltas === void 0 ? trySendFrame(ws, `{"type":"data","id":${JSON.stringify(subId)},"data":${json}${cursorSuffix}}`) : sendDeltaFrames(ws, subId, deltaFrames, cursorSuffix);
+    memos.set(subId, { lastJson: delivered ? json : existing?.lastJson ?? UNDELIVERED_BASELINE, tables: outcome.tables });
   }
   /**
    * Gate the upgrade request against two complementary controls:
@@ -3999,10 +3942,7 @@ class ShardDO {
       if (ws === sender || this.readAttachment(ws).whispers?.includes(topic) !== true) {
         continue;
       }
-      try {
-        ws.send(frame);
-      } catch {
-      }
+      trySendFrame(ws, frame);
     }
   }
   // eslint-disable-next-line class-methods-use-this -- cohesive DO instance method grouped with the hibernation/attachment helpers; reads only the socket

package/dist/packem_shared/subscriptionListDeltas-ce84gpwL.mjs

@@ -0,0 +1,111 @@
+const ROW_ID_FIELD = "_id";
+const DELTA_FALLBACK_TABLE = "__lunora__";
+const readRowId = (row) => {
+  if (typeof row !== "object" || row === null || Array.isArray(row)) {
+    return void 0;
+  }
+  const id = row[ROW_ID_FIELD];
+  return typeof id === "string" ? id : void 0;
+};
+const indexRowsById = (rows) => {
+  const byId = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const row of rows) {
+    const id = readRowId(row);
+    if (id === void 0 || byId.has(id)) {
+      return void 0;
+    }
+    byId.set(id, row);
+    order.push(id);
+  }
+  return { byId, order };
+};
+const survivorsKeepOrder = (previous, next) => {
+  const survivingPrevious = previous.order.filter((id) => next.byId.has(id));
+  const survivingNext = next.order.filter((id) => previous.byId.has(id));
+  if (survivingPrevious.length !== survivingNext.length) {
+    return false;
+  }
+  return survivingPrevious.every((id, index) => survivingNext[index] === id);
+};
+const collectDeleteDeltas = (previous, next, deltaTable, tableJson) => {
+  const out = [];
+  for (const id of previous.order) {
+    if (!next.byId.has(id)) {
+      out.push({
+        delta: { key: id, op: "delete", table: deltaTable },
+        frame: `{"key":${JSON.stringify(id)},"op":"delete","table":${tableJson}}`
+      });
+    }
+  }
+  return out;
+};
+const collectUpsertDeltas = (previous, next, deltaTable, tableJson) => {
+  const out = [];
+  for (const id of next.order) {
+    const nextRow = next.byId.get(id);
+    const previousRow = previous.byId.get(id);
+    const nextFingerprint = JSON.stringify(nextRow);
+    const previousFingerprint = previousRow === void 0 ? void 0 : JSON.stringify(previousRow);
+    if (previousFingerprint === nextFingerprint) {
+      continue;
+    }
+    const op = previousFingerprint === void 0 ? "insert" : "update";
+    out.push({
+      delta: { key: id, op, row: nextRow, table: deltaTable },
+      frame: `{"key":${JSON.stringify(id)},"op":"${op}","row":${nextFingerprint},"table":${tableJson}}`
+    });
+  }
+  return out;
+};
+const subscriptionListDeltas = (previousJson, nextResult, table, frames) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(previousJson);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(parsed) || !Array.isArray(nextResult)) {
+    return void 0;
+  }
+  const previous = indexRowsById(parsed);
+  const next = indexRowsById(nextResult);
+  if (previous === void 0 || next === void 0) {
+    return void 0;
+  }
+  if (!survivorsKeepOrder(previous, next)) {
+    return void 0;
+  }
+  const deltaTable = table === "" ? DELTA_FALLBACK_TABLE : table;
+  const tableJson = JSON.stringify(deltaTable);
+  const framed = [...collectDeleteDeltas(previous, next, deltaTable, tableJson), ...collectUpsertDeltas(previous, next, deltaTable, tableJson)];
+  if (framed.length > next.order.length) {
+    return void 0;
+  }
+  if (frames !== void 0) {
+    for (const { frame } of framed) {
+      frames.push(frame);
+    }
+  }
+  return framed.map(({ delta }) => delta);
+};
+const trySendFrame = (ws, frame) => {
+  try {
+    ws.send(frame);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const sendDeltaFrames = (ws, subId, deltaFrames, cursorSuffix) => {
+  const idJson = JSON.stringify(subId);
+  let delivered = true;
+  for (const deltaBody of deltaFrames) {
+    if (!trySendFrame(ws, `{"type":"delta","id":${idJson},"delta":${deltaBody}${cursorSuffix}}`)) {
+      delivered = false;
+    }
+  }
+  return delivered;
+};
+
+export { sendDeltaFrames, subscriptionListDeltas, trySendFrame };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.7",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",