@rotorsoft/act 1.22.9 → 1.23.1

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-YVLB5MMB.js";
+} from "./chunk-4HYYZOEH.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -1736,6 +1736,15 @@ function compute_backoff_delay(retry, opts) {
 }
 
 // src/internal/event-sourcing.ts
+var bare_patch = (_me, state2, partial) => patch(state2, partial);
+var validating_patch = (me, state2, partial, event) => {
+  const next = patch(state2, partial);
+  return validate(
+    `${me.name}.${String(event.name)}#${event.id}`,
+    next,
+    me.state
+  );
+};
 var DEFAULT_BATCH = 500;
 async function snap(snapshot) {
   const { id, stream, name, meta, version } = snapshot.event;
@@ -1890,7 +1899,7 @@ async function scan(source, opts = {}, callback) {
     }
   };
 }
-async function load(me, target, callback) {
+async function load(me, target, callback, patch_fn = bare_patch) {
   const { stream, actor, asOf } = target;
   const time_travel = !!asOf && Object.values(asOf).some((v) => v !== void 0);
   const cached = time_travel ? void 0 : await cache().get(stream);
@@ -1909,7 +1918,7 @@ async function load(me, target, callback) {
         patches = 0;
         replayed++;
       } else if (me.patch[event.name]) {
-        state2 = patch(state2, me.patch[event.name](event, state2));
+        state2 = patch_fn(me, state2, me.patch[event.name](event, state2), event);
         patches++;
         replayed++;
       } else if (event.name !== TOMBSTONE_EVENT) {
@@ -1960,7 +1969,7 @@ async function load(me, target, callback) {
     replayed
   };
 }
-async function action(me, action2, target, payload, options) {
+async function action(me, action2, target, payload, options, patch_fn = bare_patch) {
   const { stream, expectedVersion, actor } = target;
   if (!stream) throw new Error("Missing target stream");
   const reactingTo = options?.reactingTo;
@@ -1970,7 +1979,12 @@ async function action(me, action2, target, payload, options) {
   const max_retries = opts?.maxRetries ?? 0;
   for (let attempt = 0; ; attempt++) {
     try {
-      const snapshot = await load(me, { stream, actor: target.actor });
+      const snapshot = await load(
+        me,
+        { stream, actor: target.actor },
+        void 0,
+        patch_fn
+      );
       if (snapshot.event?.name === TOMBSTONE_EVENT)
         throw new StreamClosedError(stream);
       const expected = expectedVersion ?? (snapshot.version >= 0 ? snapshot.version : void 0);
@@ -2041,7 +2055,7 @@ async function action(me, action2, target, payload, options) {
       const snapshots = committed.map((row, i) => {
         const event = { ...row, data: valid[i].data };
         const p = me.patch[event.name](event, state2);
-        state2 = patch(state2, p);
+        state2 = patch_fn(me, state2, p, event);
         patches++;
         return {
           event,
@@ -2137,12 +2151,20 @@ var traced = (inner, exit, entry) => (async (...args) => {
   exit?.(result, ...args);
   return result;
 });
-function build_es(logger, correlator = default_correlator) {
-  const bound_action = (me, action_name, target, payload, options) => action(me, action_name, target, payload, { correlator, ...options });
+function build_es(logger, correlator = default_correlator, patch_fn = bare_patch) {
+  const bound_action = (me, action_name, target, payload, options) => action(
+    me,
+    action_name,
+    target,
+    payload,
+    { correlator, ...options },
+    patch_fn
+  );
+  const bound_load = (me, target, callback) => load(me, target, callback, patch_fn);
   if (logger.level !== "trace") {
     return {
       snap,
-      load,
+      load: bound_load,
       action: bound_action,
       tombstone
     };
@@ -2157,7 +2179,7 @@ function build_es(logger, correlator = default_correlator) {
         )
       );
     }),
-    load: traced(load, (result, _me, target) => {
+    load: traced(bound_load, (result, _me, target) => {
       const stats = stats_marker(
         result.version,
         result.replayed,
@@ -2468,6 +2490,83 @@ var DrainController = class {
   }
 };
 
+// src/internal/projection-fold.ts
+import { z as z5 } from "zod";
+var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
+var DEFAULT_MAX_CACHED_STATES = 1e4;
+var FoldOptionsSchema = z5.object({
+  flushEvery: z5.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: z5.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+function make_fold_handler(me, flush, config2, patch_fn = bare_patch) {
+  const cache2 = /* @__PURE__ */ new Map();
+  const row = ({ dirty: _, ...row2 }) => row2;
+  const flush_dirty = async () => {
+    const rows = [];
+    const flushed = [];
+    for (const f of cache2.values())
+      if (f.dirty) {
+        rows.push(row(f));
+        flushed.push(f);
+      }
+    if (rows.length === 0) return;
+    await flush(rows);
+    for (const f of flushed) f.dirty = false;
+  };
+  return async (events) => {
+    let folded_since_flush = 0;
+    for (const event of events) {
+      const stream = event.stream;
+      let fold = cache2.get(stream);
+      if (fold) {
+        cache2.delete(stream);
+        cache2.set(stream, fold);
+      } else {
+        if (cache2.size >= config2.maxCachedStates) {
+          const oldest = cache2.keys().next().value;
+          const evictee = cache2.get(oldest);
+          if (evictee.dirty) await flush([row(evictee)]);
+          cache2.delete(oldest);
+        }
+        const snapshot = await load(me, { stream }, void 0, patch_fn);
+        fold = {
+          stream,
+          state: snapshot.state,
+          version: snapshot.version,
+          event_id: snapshot.id,
+          patches: snapshot.patches,
+          snaps: snapshot.snaps,
+          dirty: true
+        };
+        cache2.set(stream, fold);
+      }
+      if (event.id > fold.event_id) {
+        const reducer = me.patch[event.name];
+        fold.state = patch_fn(
+          me,
+          fold.state,
+          reducer(event, fold.state),
+          event
+        );
+        fold.version = event.version;
+        fold.event_id = event.id;
+        fold.patches++;
+        fold.dirty = true;
+      } else {
+        fold.dirty = true;
+      }
+      if (++folded_since_flush >= config2.flushEvery) {
+        await flush_dirty();
+        folded_since_flush = 0;
+      }
+    }
+    await flush_dirty();
+  };
+}
+
 // src/internal/reactions.ts
 function finalize(lease, handled, at, error, options, logger, failed_at) {
   if (!error) return { lease, handled, acked_at: at };
@@ -2673,82 +2772,6 @@ var SettleLoop = class {
   }
 };
 
-// src/internal/state-fold.ts
-import { patch as patch2 } from "@rotorsoft/act-patch";
-import { z as z5 } from "zod";
-var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
-var DEFAULT_MAX_CACHED_STATES = 1e4;
-var FoldOptionsSchema = z5.object({
-  flushEvery: z5.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
-  maxCachedStates: z5.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
-});
-function resolveFoldConfig(options) {
-  return FoldOptionsSchema.parse(options);
-}
-function make_fold_handler(me, flush, config2) {
-  const cache2 = /* @__PURE__ */ new Map();
-  const row = ({ dirty: _, ...row2 }) => row2;
-  const flush_dirty = async () => {
-    const rows = [];
-    const flushed = [];
-    for (const f of cache2.values())
-      if (f.dirty) {
-        rows.push(row(f));
-        flushed.push(f);
-      }
-    if (rows.length === 0) return;
-    await flush(rows);
-    for (const f of flushed) f.dirty = false;
-  };
-  return async (events) => {
-    let folded_since_flush = 0;
-    for (const event of events) {
-      const stream = event.stream;
-      let fold = cache2.get(stream);
-      if (fold) {
-        cache2.delete(stream);
-        cache2.set(stream, fold);
-      } else {
-        if (cache2.size >= config2.maxCachedStates) {
-          const oldest = cache2.keys().next().value;
-          const evictee = cache2.get(oldest);
-          if (evictee.dirty) await flush([row(evictee)]);
-          cache2.delete(oldest);
-        }
-        const snapshot = await load(me, { stream });
-        fold = {
-          stream,
-          state: snapshot.state,
-          version: snapshot.version,
-          event_id: snapshot.id,
-          patches: snapshot.patches,
-          snaps: snapshot.snaps,
-          dirty: true
-        };
-        cache2.set(stream, fold);
-      }
-      if (event.id > fold.event_id) {
-        const reducer = me.patch[event.name];
-        fold.state = patch2(
-          fold.state,
-          reducer(event, fold.state)
-        );
-        fold.version = event.version;
-        fold.event_id = event.id;
-        fold.patches++;
-        fold.dirty = true;
-      } else {
-        fold.dirty = true;
-      }
-      if (++folded_since_flush >= config2.flushEvery) {
-        await flush_dirty();
-        folded_since_flush = 0;
-      }
-    }
-    await flush_dirty();
-  };
-}
-
 // src/act.ts
 var DEFAULT_MAX_SUBSCRIBED_STREAMS = 1e3;
 var DEFAULT_SETTLE_DEBOUNCE_MS = 10;
@@ -2905,8 +2928,14 @@ var Act = class {
    * @param lanes     Declared drain lanes (ACT-1103). The builder collects
    *   these from `.withLane(...)` calls. Slice 1 records them on the
    *   instance; later slices fan out one `DrainController` per lane.
+   * @param patch_fn  The per-event patch step selected once by the builder
+   *   from `ActOptions.validateFoldedState` (ACT-1238) — `bare_patch` by
+   *   default, `validating_patch` when the flag is on. The builder uses
+   *   the same value for its projection-fold handlers, so there is a
+   *   single selection site. Defaults to `bare_patch` for direct
+   *   construction.
    */
-  constructor(registry, states = /* @__PURE__ */ new Map(), batch_handlers = /* @__PURE__ */ new Map(), options = {}, lanes = []) {
+  constructor(registry, states = /* @__PURE__ */ new Map(), batch_handlers = /* @__PURE__ */ new Map(), options = {}, lanes = [], patch_fn = bare_patch) {
     this.registry = registry;
     this._states = states;
     this._batch_handlers = batch_handlers;
@@ -2914,7 +2943,7 @@ var Act = class {
     validate_only_lanes(options, lanes);
     this._scoped = options.scoped ? (fn) => scoped.run(options.scoped, fn) : (fn) => fn();
     this._correlator = options.correlator ?? default_correlator;
-    this._es = build_es(this._logger, this._correlator);
+    this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
     this._handle = build_handle({
       logger: this._logger,
@@ -4155,6 +4184,7 @@ function act() {
     },
     on: (event) => reaction_on(event, registry.events, builder),
     build: (options) => {
+      const patch_fn = options?.validateFoldedState === true ? validating_patch : bare_patch;
       if (!_built) {
         for (const proj of pending_projections) {
           merge_projection(proj, registry.events);
@@ -4177,7 +4207,7 @@ function act() {
             );
           batch_handlers.set(
             proj.target,
-            make_fold_handler(merged, fold.flush, fold.config)
+            make_fold_handler(merged, fold.flush, fold.config, patch_fn)
           );
         }
         finalize_deprecations();
@@ -4250,7 +4280,8 @@ function act() {
         states,
         batch_handlers,
         options,
-        lanes
+        lanes,
+        patch_fn
       );
     },
     events: registry.events