@rotorsoft/act 0.28.0 → 0.29.1

package/dist/index.cjs

@@ -47,6 +47,8 @@ __export(index_exports, {
   PackageSchema: () => PackageSchema,
   QuerySchema: () => QuerySchema,
   SNAP_EVENT: () => SNAP_EVENT,
+  StreamClosedError: () => StreamClosedError,
+  TOMBSTONE_EVENT: () => TOMBSTONE_EVENT,
   TargetSchema: () => TargetSchema,
   ValidationError: () => ValidationError,
   ZodEmpty: () => ZodEmpty,
@@ -210,7 +212,8 @@ var InMemoryCache = class {
 var Errors = {
   ValidationError: "ERR_VALIDATION",
   InvariantError: "ERR_INVARIANT",
-  ConcurrencyError: "ERR_CONCURRENCY"
+  ConcurrencyError: "ERR_CONCURRENCY",
+  StreamClosedError: "ERR_STREAM_CLOSED"
 };
 var ValidationError = class extends Error {
   constructor(target, payload, details) {
@@ -232,6 +235,13 @@ var InvariantError = class extends Error {
     this.name = Errors.InvariantError;
   }
 };
+var StreamClosedError = class extends Error {
+  constructor(stream) {
+    super(`Stream "${stream}" is closed (tombstoned)`);
+    this.stream = stream;
+    this.name = Errors.StreamClosedError;
+  }
+};
 var ConcurrencyError = class extends Error {
   constructor(stream, lastVersion, events, expectedVersion) {
     super(
@@ -665,6 +675,41 @@ var InMemoryStore = class {
     }
     return count;
   }
+  /**
+   * Atomically truncates streams and seeds each with a snapshot or tombstone.
+   * @param targets - Streams to truncate with optional snapshot state and meta.
+   * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event.
+   */
+  async truncate(targets) {
+    await sleep();
+    const deletedCounts = /* @__PURE__ */ new Map();
+    const streamSet = new Set(targets.map((t) => t.stream));
+    for (const e of this._events) {
+      if (streamSet.has(e.stream)) {
+        deletedCounts.set(e.stream, (deletedCounts.get(e.stream) ?? 0) + 1);
+      }
+    }
+    this._events = this._events.filter((e) => !streamSet.has(e.stream));
+    const result = /* @__PURE__ */ new Map();
+    for (const { stream, snapshot, meta } of targets) {
+      this._streams.delete(stream);
+      const event = {
+        id: this._events.length,
+        stream,
+        version: 0,
+        created: /* @__PURE__ */ new Date(),
+        name: snapshot !== void 0 ? SNAP_EVENT : TOMBSTONE_EVENT,
+        data: snapshot ?? {},
+        meta: meta ?? { correlation: "", causation: {} }
+      };
+      this._events.push(event);
+      result.set(stream, {
+        deleted: deletedCounts.get(stream) ?? 0,
+        committed: event
+      });
+    }
+    return result;
+  }
 };
 
 // src/ports.ts
@@ -711,6 +756,7 @@ function dispose(disposer) {
   return disposeAndExit;
 }
 var SNAP_EVENT = "__snapshot__";
+var TOMBSTONE_EVENT = "__tombstone__";
 function build_tracer(logLevel2) {
   if (logLevel2 === "trace") {
     const logger4 = log();
@@ -851,6 +897,8 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
   if (!stream) throw new Error("Missing target stream");
   payload = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
   const snapshot = await load(me, stream);
+  if (snapshot.event?.name === TOMBSTONE_EVENT)
+    throw new StreamClosedError(stream);
   const expected = expectedVersion ?? snapshot.event?.version;
   logger2.trace(
     payload,
@@ -1629,6 +1677,170 @@ var Act = class {
       this._settle_timer = void 0;
     }
   }
+  /**
+   * Close the books — guard, archive, truncate, and optionally restart streams.
+   *
+   * Safely removes historical events from the operational store:
+   *
+   * 1. **Correlate** — discover pending reaction targets
+   * 2. **Safety check** — skip streams with pending reactions (skipped when no reactive events)
+   * 3. **Guard** — commit `__tombstone__` with `expectedVersion` to block concurrent writes
+   * 4. **Load state** — for streams in `snapshots`, load final state while guarded (no races)
+   * 5. **Archive** — user callback per stream (abort-all on failure, streams are guarded)
+   * 6. **Truncate + seed** — atomic: delete all events, insert `__snapshot__` or `__tombstone__`
+   * 7. **Cache** — invalidate (tombstoned) or warm (restarted)
+   * 8. **Emit "closed"** — lifecycle event with results
+   *
+   * @param targets - Per-stream close options (stream, restart?, archive?)
+   * @returns `{ truncated: TruncateResult, skipped: string[] }`
+   *
+   * @example Archive and close
+   * ```typescript
+   * await app.close([
+   *   { stream: "order-123", archive: async () => { await archiveToS3("order-123"); } },
+   *   { stream: "order-456" },
+   * ]);
+   * ```
+   *
+   * @example Close with restart (state loaded automatically after guard)
+   * ```typescript
+   * await app.close([
+   *   { stream: "counter-1", restart: true },
+   *   { stream: "counter-2" },  // tombstoned
+   * ]);
+   * ```
+   */
+  async close(targets) {
+    if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
+    const targetMap = new Map(targets.map((t) => [t.stream, t]));
+    const streams = [...targetMap.keys()];
+    await this.correlate({ limit: 1e3 });
+    const streamInfo = /* @__PURE__ */ new Map();
+    await Promise.all(
+      streams.map(async (s) => {
+        let maxId = -1;
+        let version = -1;
+        await store().query(
+          (e) => {
+            if (e.name !== TOMBSTONE_EVENT) {
+              maxId = e.id;
+              version = e.version;
+            }
+          },
+          { stream: s, stream_exact: true, backward: true, limit: 1 }
+        );
+        if (maxId >= 0) streamInfo.set(s, { maxId, version });
+      })
+    );
+    const skipped = [];
+    let safe;
+    if (this._reactive_events.size === 0) {
+      safe = [...streamInfo.keys()];
+    } else {
+      const pendingSet = /* @__PURE__ */ new Set();
+      const leases = await store().claim(1e3, 1e3, (0, import_crypto2.randomUUID)(), 1);
+      if (leases.length) await store().ack(leases);
+      for (const lease of leases) {
+        const sourceRe = lease.source ? RegExp(lease.source) : void 0;
+        for (const [stream, info] of streamInfo) {
+          if ((!sourceRe || sourceRe.test(stream)) && lease.at < info.maxId) {
+            pendingSet.add(stream);
+          }
+        }
+      }
+      safe = [];
+      for (const [stream] of streamInfo) {
+        if (pendingSet.has(stream)) {
+          skipped.push(stream);
+        } else {
+          safe.push(stream);
+        }
+      }
+    }
+    if (!safe.length) {
+      const result2 = { truncated: /* @__PURE__ */ new Map(), skipped };
+      this.emit("closed", result2);
+      return result2;
+    }
+    const correlation = (0, import_crypto2.randomUUID)();
+    const guarded = [];
+    const guardEvents = /* @__PURE__ */ new Map();
+    await Promise.all(
+      safe.map(async (stream) => {
+        try {
+          const info = streamInfo.get(stream);
+          const [committed] = await store().commit(
+            stream,
+            [{ name: TOMBSTONE_EVENT, data: {} }],
+            { correlation, causation: {} },
+            info.version
+          );
+          guarded.push(stream);
+          guardEvents.set(stream, { id: committed.id, stream });
+        } catch {
+          skipped.push(stream);
+        }
+      })
+    );
+    if (!guarded.length) {
+      const result2 = { truncated: /* @__PURE__ */ new Map(), skipped };
+      this.emit("closed", result2);
+      return result2;
+    }
+    const mergedState = [...this._states.values()][0];
+    const seedStates = /* @__PURE__ */ new Map();
+    if (mergedState) {
+      await Promise.all(
+        guarded.filter((s) => targetMap.get(s)?.restart).map(async (stream) => {
+          const snap2 = await load(mergedState, stream);
+          seedStates.set(stream, snap2.state);
+        })
+      );
+    }
+    for (const stream of guarded) {
+      const archiveFn = targetMap.get(stream)?.archive;
+      if (archiveFn) await archiveFn();
+    }
+    const truncTargets = guarded.map((stream) => {
+      const snapshot = seedStates.get(stream);
+      const guard = guardEvents.get(stream);
+      return {
+        stream,
+        snapshot,
+        meta: {
+          correlation,
+          causation: {
+            event: {
+              id: guard.id,
+              name: TOMBSTONE_EVENT,
+              stream: guard.stream
+            }
+          }
+        }
+      };
+    });
+    const truncated = await store().truncate(truncTargets);
+    await Promise.all(
+      guarded.map(async (stream) => {
+        const entry = truncated.get(stream);
+        const state2 = seedStates.get(stream);
+        if (state2 && entry) {
+          await cache().set(stream, {
+            state: state2,
+            version: entry.committed.version,
+            event_id: entry.committed.id,
+            patches: 0,
+            snaps: 1
+          });
+        } else {
+          await cache().invalidate(stream);
+        }
+      })
+    );
+    const result = { truncated, skipped };
+    this.emit("closed", result);
+    return result;
+  }
   /**
    * Debounced, non-blocking correlate→drain cycle.
    *
@@ -1815,7 +2027,6 @@ var _this_ = ({ stream }) => ({
   source: stream,
   target: stream
 });
-var _void_ = () => void 0;
 
 // src/act-builder.ts
 function act(states = /* @__PURE__ */ new Map(), registry = {
@@ -1893,13 +2104,6 @@ function act(states = /* @__PURE__ */ new Map(), registry = {
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
-          },
-          void() {
-            registry.events[event].reactions.set(handler.name, {
-              ...reaction,
-              resolver: _void_
-            });
-            return builder;
           }
         };
       }
@@ -1962,13 +2166,6 @@ function _projection(target, events) {
                 resolver: typeof resolver === "string" ? { target: resolver } : resolver
               });
               return nextBuilder;
-            },
-            void() {
-              register.reactions.set(handler.name, {
-                ...reaction,
-                resolver: _void_
-              });
-              return nextBuilder;
             }
           };
         }
@@ -2044,13 +2241,6 @@ function slice(states = /* @__PURE__ */ new Map(), actions = {}, events = {}, pr
               resolver: typeof resolver === "string" ? { target: resolver } : resolver
             });
             return builder;
-          },
-          void() {
-            events[event].reactions.set(handler.name, {
-              ...reaction,
-              resolver: _void_
-            });
-            return builder;
           }
         };
       }
@@ -2175,6 +2365,8 @@ function action_builder(state2) {
   PackageSchema,
   QuerySchema,
   SNAP_EVENT,
+  StreamClosedError,
+  TOMBSTONE_EVENT,
   TargetSchema,
   ValidationError,
   ZodEmpty,