@timurproko/a1 0.2.7-dev.1276 → 0.2.7-dev.1285

package/dist/integrations/pi/engine/pending-delivery.js

@@ -1,3 +1,4 @@
+import { DeliveryRetention } from "./delivery-retention.js";
 const MAX_PENDING_EVENTS = 1024;
 const MAX_PENDING_EVENT_BYTES = 8 * 1024 * 1024;
 /** Actual shell semantics: only live complete block state has no independent side effect. */
@@ -29,21 +30,32 @@ export class PendingEngineDelivery {
     #head;
     #tail;
     #size = 0;
-    #bytes = 0;
+    #retention = new DeliveryRetention();
     #protected = 0;
     #generation = -1;
     #superseded = 0;
     #peakNodes = 0;
     #peakBytes = 0;
+    rejection = null;
     retain;
-    constructor(retain) { this.retain = retain; }
+    current;
+    externalBytes;
+    constructor(retain, current, externalBytes) {
+        this.retain = retain;
+        this.current = current;
+        this.externalBytes = externalBytes;
+    }
     get size() { return this.#size; }
+    get #bytes() { return this.#retention.bytes + this.#size * 128 + (this.externalBytes?.() ?? 0); }
     diagnostics() {
         return { pending: this.#size, bytes: this.#bytes, protected: this.#protected,
             superseded: this.#superseded, peakNodes: this.#peakNodes, peakBytes: this.#peakBytes };
     }
     /** False means not admitted. The caller must enter its reserved recovery protocol, never evict. */
     push(event, generation, reconcile) {
+        this.rejection = null;
+        if (this.current)
+            this.#retention.baseline(this.current());
         const key = replaceableEventKey(event);
         if (generation !== this.#generation || key === null) {
             if (!this.seal())
@@ -51,14 +63,23 @@ export class PendingEngineDelivery {
             this.#generation = generation;
         }
         const prior = key === null ? undefined : this.#replaceable.get(key);
-        let bytes = retainedEventBytes(event);
-        const marker = key !== null && bytes > 64 * 1024 && reconcile !== undefined;
-        if (marker)
-            bytes = 128;
+        // Compatibility: production owns exact immutable revisions through the ledger. Legacy standalone
+        // queues retain the compact-marker contract when no authoritative owner is supplied.
+        const marker = this.current === undefined && key !== null && retainedEventBytes(event) > 64 * 1024 && reconcile !== undefined;
+        const charge = marker ? undefined : this.#retention.retain(event);
+        const release = marker ? undefined : this.retain?.(event);
+        prior?.charge?.();
+        const bytes = this.#retention.bytes + this.#size * 128 + (this.externalBytes?.(prior?.event) ?? 0);
         if (this.#size - (prior === undefined ? 0 : 1) >= MAX_PENDING_EVENTS
-            || this.#bytes - (prior?.bytes ?? 0) + bytes > MAX_PENDING_EVENT_BYTES)
+            || bytes + (prior === undefined ? 128 : 0) > MAX_PENDING_EVENT_BYTES) {
+            this.rejection = this.#size - (prior === undefined ? 0 : 1) >= MAX_PENDING_EVENTS ? "event-count" : "retained-bytes";
+            charge?.();
+            release?.();
+            if (prior?.event)
+                prior.charge = this.#retention.retain(prior.event);
             return false;
-        const node = { key, generation, bytes, ...(marker ? { resolve: reconcile } : { event, release: this.retain?.(event) }) };
+        }
+        const node = { key, generation, charge, ...(marker ? { resolve: reconcile } : { event, release }) };
         if (prior !== undefined) {
             this.#unlink(prior);
             this.#superseded = Math.min(Number.MAX_SAFE_INTEGER, this.#superseded + 1);
@@ -70,7 +91,6 @@ export class PendingEngineDelivery {
             this.#head = node;
         this.#tail = node;
         this.#size++;
-        this.#bytes += bytes;
         if (key === null)
             this.#protected++;
         else
@@ -101,9 +121,17 @@ export class PendingEngineDelivery {
             return undefined;
         const event = node.event ?? node.resolve();
         const release = node.release ?? this.retain?.(event);
+        const charge = node.charge;
         this.#unlink(node, false);
-        // Invariant: a consumed snapshot retains its assets through synchronous listener delivery, including reentrant production.
-        return { event, generation: node.generation, ...(release === undefined ? {} : { release }) };
+        // Invariant: keep the exact revision and assets charged through reentrant listener production.
+        let released = false;
+        return { event, generation: node.generation, release: () => {
+                if (released)
+                    return;
+                released = true;
+                charge?.();
+                release?.();
+            } };
     }
     // Invariant: a barrier freezes lazy authoritative markers before a later segment can change them.
     seal() {
@@ -111,22 +139,28 @@ export class PendingEngineDelivery {
             if (node.resolve === undefined)
                 continue;
             const event = node.resolve();
-            const bytes = retainedEventBytes(event);
-            if (this.#bytes - node.bytes + bytes > MAX_PENDING_EVENT_BYTES)
+            const charge = this.#retention.retain(event);
+            const release = this.retain?.(event);
+            if (this.#bytes > MAX_PENDING_EVENT_BYTES) {
+                this.rejection = "retained-bytes";
+                charge();
+                release?.();
                 return false;
-            this.#bytes += bytes - node.bytes;
-            node.bytes = bytes;
+            }
+            node.charge = charge;
             node.event = event;
             node.resolve = undefined;
-            node.release = this.retain?.(event);
+            node.release = release;
             this.#peakBytes = Math.max(this.#peakBytes, this.#bytes);
         }
         this.#replaceable.clear();
         return true;
     }
     #unlink(node, release = true) {
-        if (release)
+        if (release) {
+            node.charge?.();
             node.release?.();
+        }
         if (node.previous !== undefined)
             node.previous.next = node.next;
         else
@@ -136,7 +170,6 @@ export class PendingEngineDelivery {
         else
             this.#tail = node.previous;
         this.#size--;
-        this.#bytes -= node.bytes;
         if (node.key === null)
             this.#protected--;
         else if (this.#replaceable.get(node.key) === node)