@rotorsoft/act 1.1.0 → 1.2.0

package/dist/test/index.cjs

@@ -4939,23 +4939,19 @@ var InMemoryStore = class {
     return result;
   }
   /**
-   * Atomically rebuild the store from a stream of {@link RestoreRow}.
+   * Atomically wipe-and-rebuild the store under an in-process snapshot.
    *
-   * Captures every index state up front, clears it, then iterates the
-   * source. Any throw mid-iteration restores the snapshot, leaving
-   * the store byte-for-byte unchanged from the operator's
-   * perspective.
+   * Captures every index state up front, clears it, then hands the
+   * orchestrator a per-event insert `callback` via the driver. Any
+   * throw inside the driver restores the snapshot, leaving the store
+   * byte-for-byte unchanged from the operator's perspective.
    *
-   * `id`s are reassigned `0..N-1` as rows arrive (matching the
+   * `id`s are reassigned `0..N-1` as events arrive (matching the
    * adapter's commit-id convention — InMemory uses `_events.length`).
-   * `created` is preserved verbatim from the source. Causation
-   * references in `meta.causation.event.id` are remapped via the
-   * `old → new` table that's built as rows land — references to ids
-   * not in the source pass through unchanged.
+   * `created` is preserved verbatim from the source.
    */
-  async restore(source, _opts = {}) {
+  async restore(driver) {
     await sleep();
-    const started = Date.now();
     const prevEvents = this._events;
     const prevStreams = this._streams;
     const prevStreamVersions = this._streamVersions;
@@ -4966,50 +4962,18 @@ var InMemoryStore = class {
     this._streamVersions = /* @__PURE__ */ new Map();
     this._maxEventIdByStream = /* @__PURE__ */ new Map();
     this._maxNonSnapEventId = -1;
-    const idMap = /* @__PURE__ */ new Map();
     try {
-      let kept = 0;
-      for await (const row of source) {
+      await driver(async (event) => {
         const id = this._events.length;
-        const created = row.created instanceof Date ? row.created : new Date(row.created);
-        let meta = row.meta;
-        const causedBy = meta.causation.event?.id;
-        if (causedBy !== void 0) {
-          const remapped = idMap.get(causedBy);
-          if (remapped !== void 0 && remapped !== causedBy) {
-            meta = {
-              ...meta,
-              causation: {
-                ...meta.causation,
-                event: { ...meta.causation.event, id: remapped }
-              }
-            };
-          }
-        }
-        const committed = {
-          id,
-          stream: row.stream,
-          version: row.version,
-          created,
-          name: row.name,
-          data: row.data,
-          meta
-        };
+        const committed = { ...event, id };
         this._events.push(committed);
-        idMap.set(row.id, id);
-        this._streamVersions.set(row.stream, row.version);
-        if (row.name !== SNAP_EVENT) {
-          this._maxEventIdByStream.set(row.stream, id);
+        this._streamVersions.set(event.stream, event.version);
+        if (event.name !== SNAP_EVENT) {
+          this._maxEventIdByStream.set(event.stream, id);
           this._maxNonSnapEventId = id;
         }
-        kept++;
-      }
-      return {
-        kept,
-        duration_ms: Date.now() - started,
-        dropped: { closed_streams: 0, snapshots: 0, empty_streams: 0 },
-        dry_run: false
-      };
+        return id;
+      });
     } catch (err) {
       this._events = prevEvents;
       this._streams = prevStreams;