@rotorsoft/act 1.35.0 → 1.35.2

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-MHPUVTMX.js";
+} from "./chunk-SVVVS6GA.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -71,7 +71,7 @@ import {
   pii_fields,
   pii_schemas,
   sensitive
-} from "./chunk-DH2HW5XJ.js";
+} from "./chunk-H2QN755D.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -1648,12 +1648,30 @@ var subscribe = (streams, correlated_at, correlator) => store().subscribe(stream
 
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
-import { prettifyError } from "zod";
+import { prettifyError, ZodError } from "zod";
 var bare_patch = (_me, state2, partial) => patch(state2, partial);
-var check_invariants = (target, state2, schema) => {
-  const result = schema.safeParse(state2);
-  if (!result.success)
-    throw new ValidationError(target, state2, prettifyError(result.error));
+var value_at = (value, path) => path.reduce(
+  (at, key) => at?.[key],
+  value
+);
+var check_invariants = (target, state2, schema, pii_aware) => {
+  let result;
+  try {
+    result = schema.safeParse(state2);
+  } catch (error) {
+    throw new ValidationError(target, state2, error);
+  }
+  if (result.success) return;
+  const issues = pii_aware ? result.error.issues.filter((issue) => {
+    const value = value_at(state2, issue.path);
+    return value !== REDACTED && value !== SHREDDED;
+  }) : result.error.issues;
+  if (issues.length)
+    throw new ValidationError(
+      target,
+      state2,
+      prettifyError(new ZodError(issues))
+    );
 };
 var DEFAULT_BATCH = 500;
 var cache_put = (stream, entry) => cache().set(stream, entry).catch(
@@ -1909,7 +1927,7 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
       );
       if (snapshot.event?.name === TOMBSTONE_EVENT)
         throw new StreamClosedError(stream);
-      const expected = expectedVersion ?? (snapshot.version >= 0 ? snapshot.version : void 0);
+      const expected = expectedVersion ?? snapshot.version;
       for (const { valid, description } of me.given?.[action2] ?? [])
         if (!valid(snapshot.state, actor))
           throw new InvariantError(
@@ -1973,17 +1991,15 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
         patches++;
         return { state: state2, patch: patch2, patches };
       });
-      check_invariants(`${me.name}.${action2}`, state2, me.state);
+      check_invariants(
+        `${me.name}.${action2}`,
+        state2,
+        me.state,
+        me.pii_aware
+      );
       let committed;
       try {
-        committed = await store().commit(
-          stream,
-          emitted,
-          meta,
-          // Reactions skip the inferred version guard (leases already
-          // serialize them); an explicit expectedVersion is still honored.
-          reactingTo ? expectedVersion : expected
-        );
+        committed = await store().commit(stream, emitted, meta, expected);
       } catch (error) {
         if (error instanceof ConcurrencyError) void cache_drop(stream);
         throw error;
@@ -2000,21 +2016,16 @@ async function action(me, action2, target, payload, options, patch_fn = bare_pat
         replayed: snapshot.replayed
       }));
       const last = snapshots.at(-1);
-      const contiguous = committed[0].version === snapshot.version + 1;
-      const snapped = contiguous && me.snap?.(last);
-      const snap_event = snapped ? await snap(last) : void 0;
-      if (!me.pii_aware) {
-        if (contiguous)
-          void cache_put(stream, {
-            stream,
-            state: last.state,
-            version: snap_event?.version ?? last.event.version,
-            event_id: snap_event?.id ?? last.event.id,
-            patches: snap_event ? 0 : last.patches,
-            snaps: snap_event ? last.snaps + 1 : last.snaps
-          });
-        else void cache_drop(stream);
-      }
+      const snap_event = me.snap?.(last) ? await snap(last) : void 0;
+      if (!me.pii_aware)
+        void cache_put(stream, {
+          stream,
+          state: last.state,
+          version: snap_event?.version ?? last.event.version,
+          event_id: snap_event?.id ?? last.event.id,
+          patches: snap_event ? 0 : last.patches,
+          snaps: snap_event ? last.snaps + 1 : last.snaps
+        });
       return snapshots;
     } catch (error) {
       if (!(error instanceof ConcurrencyError)) throw error;