@rotorsoft/act 1.10.1 → 1.10.2

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-3Z2HU726.js";
+} from "./chunk-5PWLGL5E.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -40,11 +40,10 @@ import {
   ZodEmpty,
   pii_fields,
   pii_gate,
-  pii_merge,
   pii_split,
   pii_strip,
   sensitive
-} from "./chunk-BY5JPOZR.js";
+} from "./chunk-NGVWJXEF.js";
 import "./chunk-5WRI5ZAA.js";
 
 // src/signals.ts
@@ -639,7 +638,7 @@ async function load_restart_seeds(guarded, target_map, stream_info, event_to_sta
         );
         return;
       }
-      const snap2 = await load2(owner_state, stream);
+      const snap2 = await load2(owner_state, { stream });
       seed_states.set(stream, snap2.state);
     })
   );
@@ -1003,7 +1002,6 @@ async function scan(source, opts = {}, callback) {
           migrated = {
             ...event,
             name: migration.to,
-            // biome-ignore lint/suspicious/noExplicitAny: migration target shape is caller-defined
             data: new_data
           };
           migrated_count++;
@@ -1052,39 +1050,37 @@ async function scan(source, opts = {}, callback) {
     }
   };
 }
-async function load(me, stream, callback, asOf, actor) {
+async function load(me, target, callback) {
+  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);
   const cache_hit = !!cached;
   let state2 = cached?.state ?? (me.init ? me.init() : {});
   let patches = cached?.patches ?? 0;
   let snaps = cached?.snaps ?? 0;
-  let version = cached?.version ?? -1;
   let replayed = 0;
   let event;
   await store().query(
-    (e) => {
-      version = e.version;
-      const typed = e;
-      event = me.view(typed, actor);
-      if (e.name === SNAP_EVENT) {
-        state2 = e.data;
+    (raw) => {
+      event = me.view(raw, actor);
+      if (event.name === SNAP_EVENT) {
+        state2 = event.data;
         snaps++;
         patches = 0;
         replayed++;
-      } else if (me.patch[e.name]) {
-        state2 = patch(state2, me.patch[e.name](typed, state2));
+      } else if (me.patch[event.name]) {
+        state2 = patch(state2, me.patch[event.name](event, state2));
         patches++;
         replayed++;
-      } else if (e.name !== TOMBSTONE_EVENT) {
+      } else if (event.name !== TOMBSTONE_EVENT) {
         log().warn(
-          `Skipping unknown event "${String(e.name)}" on stream "${stream}" (id=${e.id}) \u2014 no reducer in state "${me.name}"`
+          `Skipping unknown event "${String(event.name)}" on stream "${stream}" (id=${event.id}) \u2014 no reducer in state "${me.name}"`
         );
       }
       callback?.({
         event,
         state: state2,
-        version,
+        version: event.version,
         patches,
         snaps,
         cache_hit,
@@ -1097,39 +1093,43 @@ async function load(me, stream, callback, asOf, actor) {
       ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
     }
   );
-  if (replayed > 0 && !time_travel && event) {
+  if (replayed > 0 && !time_travel && event && !me.pii_aware) {
     await cache().set(stream, {
       state: state2,
-      version,
+      version: event.version,
       event_id: event.id,
       patches,
       snaps
     });
   }
-  return { event, state: state2, version, patches, snaps, cache_hit, replayed };
+  return {
+    event,
+    state: state2,
+    version: event?.version ?? cached?.version ?? -1,
+    patches,
+    snaps,
+    cache_hit,
+    replayed
+  };
 }
-async function action(me, action2, target, payload, reactingTo, skipValidation = false, correlator = default_correlator) {
+async function action(me, action2, target, payload, options) {
   const { stream, expectedVersion, actor } = target;
   if (!stream) throw new Error("Missing target stream");
-  const validated = skipValidation ? payload : validate(action2, payload, me.actions[action2]);
+  const reactingTo = options?.reactingTo;
+  const correlator = options?.correlator ?? default_correlator;
+  const validated = validate(action2, payload, me.actions[action2]);
   const opts = me.options?.[action2];
   const max_retries = opts?.maxRetries ?? 0;
   for (let attempt = 0; ; attempt++) {
     try {
-      const snapshot = await load(
-        me,
-        stream,
-        void 0,
-        void 0,
-        target.actor
-      );
+      const snapshot = await load(me, { stream, actor: target.actor });
       if (snapshot.event?.name === TOMBSTONE_EVENT)
         throw new StreamClosedError(stream);
       const expected = expectedVersion ?? snapshot.event?.version;
       if (me.given) {
         const invariants = me.given[action2] || [];
-        invariants.forEach(({ valid, description }) => {
-          if (!valid(snapshot.state, actor))
+        invariants.forEach(({ valid: valid2, description }) => {
+          if (!valid2(snapshot.state, actor))
             throw new InvariantError(
               action2,
               validated,
@@ -1145,24 +1145,11 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
         return [snapshot];
       }
       const tuples = Array.isArray(result[0]) ? result : [result];
-      const deprecated = me._deprecated;
-      if (deprecated && deprecated.size > 0) {
-        const me_ = me;
-        const warned = me_._warned ?? (me_._warned = /* @__PURE__ */ new Set());
-        for (const [name] of tuples) {
-          const evt = name;
-          if (deprecated.has(evt) && !warned.has(evt)) {
-            warned.add(evt);
-            log().warn(
-              `Action "${String(action2)}" emitted deprecated event "${evt}". A newer version exists in the registry \u2014 update the action's .emit() to target the current version. (warned once per process)`
-            );
-          }
-        }
-      }
-      const emitted = tuples.map(([name, data]) => {
-        const validated2 = skipValidation ? data : validate(name, data, me.events[name]);
-        return me.message({ name, data: validated2 });
-      });
+      const valid = tuples.map(([name, data]) => ({
+        name,
+        data: validate(name, data, me.events[name])
+      }));
+      const emitted = valid.map((e) => me.message(e));
       const meta = {
         correlation: reactingTo?.meta.correlation || correlator({
           action: action2,
@@ -1203,12 +1190,13 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
         throw error;
       }
       let { state: state2, patches } = snapshot;
-      const snapshots = committed.map((event) => {
+      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);
         patches++;
         return {
-          event: me.view(event, target.actor),
+          event,
           state: state2,
           version: event.version,
           patches,
@@ -1220,13 +1208,15 @@ async function action(me, action2, target, payload, reactingTo, skipValidation =
       });
       const last = snapshots.at(-1);
       const snapped = me.snap?.(last);
-      cache().set(stream, {
-        state: last.state,
-        version: last.event.version,
-        event_id: last.event.id,
-        patches: snapped ? 0 : last.patches,
-        snaps: snapped ? last.snaps + 1 : last.snaps
-      }).catch((err) => log().error(err));
+      if (!me.pii_aware) {
+        cache().set(stream, {
+          state: last.state,
+          version: last.event.version,
+          event_id: last.event.id,
+          patches: snapped ? 0 : last.patches,
+          snaps: snapped ? last.snaps + 1 : last.snaps
+        }).catch((err) => log().error(err));
+      }
       if (snapped) void snap(last);
       return snapshots;
     } catch (error) {
@@ -1293,15 +1283,7 @@ var traced = (inner, exit, entry) => (async (...args) => {
   return result;
 });
 function build_es(logger, correlator = default_correlator) {
-  const bound_action = (me, action_name, target, payload, reactingTo, skipValidation = false) => action(
-    me,
-    action_name,
-    target,
-    payload,
-    reactingTo,
-    skipValidation,
-    correlator
-  );
+  const bound_action = (me, action_name, target, payload, options) => action(me, action_name, target, payload, { correlator, ...options });
   if (logger.level !== "trace") {
     return {
       snap,
@@ -1320,7 +1302,7 @@ function build_es(logger, correlator = default_correlator) {
         )
       );
     }),
-    load: traced(load, (result, _me, stream, _cb, asOf) => {
+    load: traced(load, (result, _me, target) => {
       const stats = stats_marker(
         result.version,
         result.replayed,
@@ -1331,7 +1313,7 @@ function build_es(logger, correlator = default_correlator) {
         es_caption(
           "load",
           C_GREEN,
-          `${stream}${as_of_marker(asOf)} ${cache_marker(result.cache_hit)} ${stats}`
+          `${target.stream}${as_of_marker(target.asOf)} ${cache_marker(result.cache_hit)} ${stats}`
         )
       );
     }),
@@ -1819,13 +1801,10 @@ function build_handle(deps) {
     };
     for (const payload of payloads) {
       const { event, handler } = payload;
-      scoped_app.do = (action2, target, action_payload, reactingTo, skipValidation) => bound_do(
-        action2,
-        target,
-        action_payload,
-        reactingTo ?? event,
-        skipValidation
-      );
+      scoped_app.do = (action2, target, action_payload, options) => bound_do(action2, target, action_payload, {
+        ...options,
+        reactingTo: options?.reactingTo ?? event
+      });
       try {
         await handler(event, stream, scoped_app);
         at = event.id;
@@ -2231,8 +2210,9 @@ var Act = class {
    * @param action - The name of the action to execute
    * @param target - Target specification with stream ID and actor context
    * @param payload - Action payload matching the action's schema
-   * @param reactingTo - Optional event that triggered this action (for correlation)
-   * @param skipValidation - Skip schema validation (use carefully, for performance)
+   * @param options - Per-call dispatch options ({@link DoOptions}) —
+   *   `reactingTo` to thread correlation, `correlator` to override the
+   *   framework or orchestrator-level correlator for this call only.
    * @returns Array of snapshots for all affected states (usually one)
    *
    * @throws {ValidationError} If payload doesn't match action schema
@@ -2287,7 +2267,7 @@ var Act = class {
    *         { amount: event.data.items.length }
    *       );
    *       // To use a different correlation, pass reactingTo explicitly:
-   *       // await app.do("reduceStock", target, payload, customEvent);
+   *       // await app.do("reduceStock", target, payload, { reactingTo: customEvent });
    *     })
    *     .to("inventory-1")
    *   .build();
@@ -2297,15 +2277,14 @@ var Act = class {
    * @see {@link Snapshot} for return value structure
    * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
    */
-  async do(action2, target, payload, reactingTo, skipValidation = false) {
+  async do(action2, target, payload, options) {
     return this._scoped(async () => {
       const snapshots = await this._es.action(
         this.registry.actions[action2],
         action2,
         target,
         payload,
-        reactingTo,
-        skipValidation
+        options
       );
       if (this._reactive_events.size > 0)
         this._arm_for_event_names(
@@ -2315,7 +2294,7 @@ var Act = class {
       return snapshots;
     });
   }
-  async load(stateOrName, stream, callback, asOf, actor) {
+  async load(stateOrName, streamOrTarget, callback, asOf) {
     return this._scoped(async () => {
       let merged;
       if (typeof stateOrName === "string") {
@@ -2325,7 +2304,12 @@ var Act = class {
       } else {
         merged = this._states.get(stateOrName.name) || stateOrName;
       }
-      return await this._es.load(merged, stream, callback, asOf, actor);
+      const target = typeof streamOrTarget === "string" ? {
+        stream: streamOrTarget,
+        actor: void 0,
+        asOf
+      } : streamOrTarget;
+      return await this._es.load(merged, target, callback);
     });
   }
   /**
@@ -3049,11 +3033,14 @@ function act() {
   const states = /* @__PURE__ */ new Map();
   const _sf = /* @__PURE__ */ new Map();
   const _dp = /* @__PURE__ */ new Map();
+  const _de = /* @__PURE__ */ new Map();
+  const EMPTY_DEPRECATED = /* @__PURE__ */ new Set();
   const registry = {
     actions: {},
     events: {},
     sensitive_fields: (event_name) => _sf.get(event_name) ?? [],
-    disclosure_predicate: (state_name) => _dp.get(state_name) ?? null
+    disclosure_predicate: (state_name) => _dp.get(state_name) ?? null,
+    deprecated_events: (state_name) => _de.get(state_name) ?? EMPTY_DEPRECATED
   };
   const pending_projections = [];
   const batch_handlers = /* @__PURE__ */ new Map();
@@ -3065,7 +3052,7 @@ function act() {
       const event_names = Object.keys(state2.events);
       const deprecated = deprecated_event_names(event_names);
       if (deprecated.size === 0) continue;
-      state2._deprecated = deprecated;
+      _de.set(state2.name, deprecated);
       for (const name of deprecated) {
         const current = current_version_of(name, event_names);
         deprecation_summary.push({
@@ -3193,18 +3180,17 @@ function act() {
             );
           }
           const disclose = state2.disclose ?? null;
-          state2.view = (event, actor) => {
-            const fields = fields_by_event.get(event.name);
-            return fields ? pii_gate(event, fields, disclose, actor) : event;
-          };
+          state2.pii_aware = true;
+          state2.view = (event, actor) => pii_gate(
+            event,
+            fields_by_event.get(event.name) ?? [],
+            disclose,
+            actor
+          );
           state2.message = (validated) => {
             const fields = fields_by_event.get(validated.name);
             return fields ? pii_split(validated, fields) : validated;
           };
-          for (const [event_name, fields] of fields_by_event) {
-            const original = state2.patch[event_name];
-            state2.patch[event_name] = (event, s) => original(pii_merge(event, fields), s);
-          }
         }
         for (const [target, original] of batch_handlers) {
           const wrapped = async (events, stream) => {
@@ -3384,9 +3370,10 @@ function state(entry) {
             init,
             patch: default_patch,
             on: {},
-            // Step delegates initialized as identity. `act().build()`
-            // overrides on states with `sensitive(...)` events to bake in
-            // the gate / split.
+            // Step delegates initialized as identity, `pii_aware` false.
+            // `act().build()` flips both on states with `sensitive(...)`
+            // events to bake in the gate / split and gate the cache write.
+            pii_aware: false,
             view: (event) => event,
             message: (validated) => validated
           };