@rotorsoft/act 1.8.0 → 1.9.0

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-I4L224TZ.js";
+} from "./chunk-F4S2JOPN.js";
 import {
   ActorSchema,
   CausationEventSchema,

package/dist/test/index.cjs

@@ -4460,11 +4460,24 @@ var InMemoryStore = class {
   _maxEventIdByStream = /* @__PURE__ */ new Map();
   // global max non-snapshot event id — fast pre-check for source-less streams in claim()
   _maxNonSnapEventId = -1;
+  // stream → (event_id → cloned sensitive payload). Two-level so `forget_pii`
+  // is O(1) — drop the inner Map for the stream and the wipe is done — mirroring
+  // the `DELETE WHERE stream = ?` scope that durable adapters get from their
+  // stream index. Entries exist only for events committed with a non-null
+  // `pii` field; absence means "no PII" (returned as `null` on load).
+  _pii = /* @__PURE__ */ new Map();
   _resetIndexes() {
     this._events.length = 0;
     this._streamVersions.clear();
     this._maxEventIdByStream.clear();
     this._maxNonSnapEventId = -1;
+    this._pii.clear();
+  }
+  // Attach the isolated PII payload (or null) to an event before handing it to
+  // a caller. Allocation-free for events without PII — by far the common case.
+  _withPii(e) {
+    const pii = this._pii.get(e.stream)?.get(e.id);
+    return pii ? { ...e, pii } : e;
   }
   /**
    * Dispose of the store and clear all events.
@@ -4520,7 +4533,9 @@ var InMemoryStore = class {
           continue;
         if (query.after && e.id <= query.after) break;
         if (query.created_after && e.created <= query.created_after) break;
-        await Promise.resolve(callback(e));
+        await Promise.resolve(
+          callback(this._withPii(e))
+        );
         count++;
         if (query?.limit && count >= query.limit) break;
       }
@@ -4532,7 +4547,9 @@ var InMemoryStore = class {
         if (query?.created_after && e.created <= query.created_after) continue;
         if (query?.before && e.id >= query.before) break;
         if (query?.created_before && e.created >= query.created_before) break;
-        await Promise.resolve(callback(e));
+        await Promise.resolve(
+          callback(this._withPii(e))
+        );
         count++;
         if (query?.limit && count >= query.limit) break;
       }
@@ -4561,7 +4578,7 @@ var InMemoryStore = class {
     }
     let version = currentVersion + 1;
     let lastNonSnapId = -1;
-    const committed = msgs.map(({ name, data }) => {
+    const committed = msgs.map(({ name, data, pii }) => {
       const c = {
         id: this._events.length,
         stream,
@@ -4572,9 +4589,17 @@ var InMemoryStore = class {
         meta
       };
       this._events.push(c);
+      if (pii != null) {
+        let perStream = this._pii.get(stream);
+        if (!perStream) {
+          perStream = /* @__PURE__ */ new Map();
+          this._pii.set(stream, perStream);
+        }
+        perStream.set(c.id, structuredClone(pii));
+      }
       if (name !== SNAP_EVENT) lastNonSnapId = c.id;
       version++;
-      return c;
+      return this._withPii(c);
     });
     this._streamVersions.set(stream, version - 1);
     if (lastNonSnapId >= 0) {
@@ -4755,6 +4780,21 @@ var InMemoryStore = class {
    * @param input - Stream names or a filter selecting the streams to unblock.
    * @returns Count of streams that were actually flipped (were blocked).
    */
+  /**
+   * Wipe the sensitive-data payload for every event on the stream — see
+   * {@link Store.forget_pii}. O(1) drop of the stream's inner Map; the size of
+   * that Map is the count of events that had PII. Idempotent: a second call
+   * finds no inner Map and returns `0`.
+   *
+   * @param stream - Target stream.
+   * @returns Count of events whose isolated PII payload was deleted.
+   */
+  async forget_pii(stream) {
+    await sleep();
+    const count = this._pii.get(stream)?.size ?? 0;
+    this._pii.delete(stream);
+    return count;
+  }
   async unblock(input) {
     await sleep();
     let count = 0;