@rotorsoft/act 1.31.5 → 1.31.6

package/dist/index.js

@@ -24,7 +24,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-GQYI2NMQ.js";
+} from "./chunk-IO2OOCOR.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -45,12 +45,13 @@ import {
   TargetSchema,
   ValidationError,
   ZodEmpty,
+  is_pii,
   make_gate,
   pii_fields,
   pii_split,
   pii_strip,
   sensitive
-} from "./chunk-TOJ5DZ5B.js";
+} from "./chunk-D5MBFIKL.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -3875,10 +3876,9 @@ var Act = class {
   async query_array(query) {
     return this._scoped(async () => {
       const events = [];
-      await store().query(
-        (e) => events.push(this.registry.query_gate(e.name)(e)),
-        query
-      );
+      await store().query((e) => {
+        events.push(this.registry.query_gate(e.name)(e));
+      }, query);
       return events;
     });
   }
@@ -4788,6 +4788,144 @@ function reaction_on(event, events, builder) {
   };
 }
 
+// src/builders/event-builder.ts
+import { z as z4 } from "zod";
+var def_of = (schema) => schema._zod?.def ?? schema.def;
+function to_read_schema(schema, found) {
+  const def = def_of(schema);
+  if (!def) return schema;
+  switch (def.type) {
+    case "date":
+      found.date = true;
+      return z4.coerce.date();
+    case "object": {
+      const shape = def.shape;
+      if (!shape) return schema;
+      const next = {};
+      for (const [key, inner] of Object.entries(shape))
+        next[key] = to_read_schema(inner, found);
+      return z4.looseObject(next);
+    }
+    case "array":
+      return z4.array(to_read_schema(def.element, found));
+    case "record":
+      return z4.record(
+        z4.string(),
+        to_read_schema(def.valueType, found)
+      );
+    case "union":
+      return z4.union(
+        def.options.map(
+          (o) => to_read_schema(o, found)
+        )
+      );
+    case "optional":
+      return to_read_schema(def.innerType, found).optional();
+    case "nullable":
+      return to_read_schema(def.innerType, found).nullable();
+    default:
+      return schema;
+  }
+}
+function event_tags(schema) {
+  const sensitive2 = [];
+  const collect = (node) => {
+    const shape = def_of(node)?.shape;
+    if (shape) {
+      for (const key of Object.keys(shape))
+        if (is_pii(shape[key])) sensitive2.push(key);
+      return;
+    }
+    const options = node.options;
+    if (Array.isArray(options)) for (const option of options) collect(option);
+  };
+  collect(schema);
+  const found = { date: false };
+  const read_schema = to_read_schema(schema, found);
+  return {
+    sensitive: [...new Set(sensitive2)],
+    parse: found.date ? (data) => read_schema.parse(data) : void 0
+  };
+}
+function make_event_reader(tags, disclosure, predicate = null) {
+  const { sensitive: sensitive2, parse: parse2 } = tags;
+  if (!parse2 && sensitive2.length === 0) return void 0;
+  const gate = sensitive2.length === 0 ? IDENTITY_GATE : disclosure === "strip" ? ((event) => pii_strip(event, sensitive2)) : make_gate(sensitive2, predicate);
+  if (!parse2) return gate;
+  return ((event, actor) => gate({ ...event, data: parse2(event.data) }, actor));
+}
+function build_events(registry, states, lanes, owners) {
+  const declared = /* @__PURE__ */ new Set([DEFAULT_LANE, ...lanes.map((l) => l.name)]);
+  const lane_errors = [];
+  const tags = /* @__PURE__ */ new Map();
+  const sensitive2 = /* @__PURE__ */ new Map();
+  const query_readers = /* @__PURE__ */ new Map();
+  const handler_readers = /* @__PURE__ */ new Map();
+  for (const [event_name, def] of Object.entries(
+    registry.events
+  )) {
+    for (const [handler_name, reaction] of def.reactions) {
+      if (typeof reaction.resolver === "function") continue;
+      const resolver = reaction.resolver;
+      const claimed = owners.batch_handlers.has(resolver.target) || owners.fold_targets.has(resolver.target);
+      if (claimed && !owners.projection_reactions.has(reaction))
+        throw new Error(
+          `Reaction on target "${resolver.target}" conflicts with the projection that already serves it \u2014 a target is served by one batch handler or one state projection, and a reaction to it would never run`
+        );
+      if (resolver.lane && !declared.has(resolver.lane))
+        lane_errors.push(
+          `Reaction "${handler_name}" on "${event_name}" targets undeclared lane "${resolver.lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. Add \`.withLane({ name: "${resolver.lane}", ... })\` to act() or correct the .to() declaration.`
+        );
+    }
+    const event = event_tags(def.schema);
+    tags.set(event_name, event);
+    if (event.sensitive.length > 0) sensitive2.set(event_name, event.sensitive);
+    const query_reader = make_event_reader(event, "redact", null);
+    if (query_reader) query_readers.set(event_name, query_reader);
+    const handler_reader = make_event_reader(event, "strip");
+    if (handler_reader) {
+      handler_readers.set(event_name, handler_reader);
+      for (const [name, reaction] of def.reactions) {
+        const inner = reaction.handler;
+        const wrapped = (evt, stream, app) => inner(handler_reader(evt), stream, app);
+        Object.defineProperty(wrapped, "name", { value: inner.name });
+        reaction.handler = wrapped;
+        def.reactions.set(name, reaction);
+      }
+    }
+  }
+  if (lane_errors.length > 0) throw new Error(lane_errors[0]);
+  for (const state2 of states.values()) {
+    const state_fields = /* @__PURE__ */ new Map();
+    for (const event_name of Object.keys(state2.events)) {
+      const fields = sensitive2.get(event_name);
+      if (fields) state_fields.set(event_name, fields);
+    }
+    if (state_fields.size > 0) {
+      if (state2.snap)
+        throw new Error(
+          `State "${state2.name}" cannot snapshot \u2014 events {${[...state_fields.keys()].join(", ")}} carry sensitive fields. Snapshots write derived state into __snapshot__.data, which forget_pii cannot reach. Remove .snap() or remove sensitive(...) markers.`
+        );
+      state2.pii_aware = true;
+      state2.message = (validated) => {
+        const fields = state_fields.get(validated.name);
+        return fields ? pii_split(validated, fields) : validated;
+      };
+    }
+    const readers = /* @__PURE__ */ new Map();
+    for (const event_name of Object.keys(state2.events)) {
+      const event = tags.get(event_name);
+      const reader = event && make_event_reader(event, "redact", state2.disclose ?? null);
+      if (reader) readers.set(event_name, reader);
+    }
+    const snap2 = make_event_reader(event_tags(state2.state), "redact", null);
+    if (snap2) readers.set(SNAP_EVENT, snap2);
+    if (readers.size === 0) continue;
+    state2.view = (event, actor) => (readers.get(event.name) ?? IDENTITY_GATE)(event, actor);
+  }
+  return { sensitive: sensitive2, query_readers, handler_readers };
+}
+
 // src/builders/act-builder.ts
 function register_batch_handler(proj, batch_handlers) {
   if (!proj.batchHandler || !proj.target) return;
@@ -4799,25 +4937,10 @@ function register_batch_handler(proj, batch_handlers) {
   }
   batch_handlers.set(proj.target, proj.batchHandler);
 }
-function validate_lane_references(registry, lanes) {
-  const declared = /* @__PURE__ */ new Set([DEFAULT_LANE, ...lanes.map((l) => l.name)]);
-  for (const [event_name, def] of Object.entries(registry.events)) {
-    const entry = def;
-    for (const [handlerName, reaction] of entry.reactions) {
-      const resolver = reaction.resolver;
-      if (typeof resolver === "function") continue;
-      const lane = resolver.lane;
-      if (lane && !declared.has(lane)) {
-        throw new Error(
-          `Reaction "${handlerName}" on "${event_name}" targets undeclared lane "${lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. Add \`.withLane({ name: "${lane}", ... })\` to act() or correct the .to() declaration.`
-        );
-      }
-    }
-  }
-}
 function act() {
   const states = /* @__PURE__ */ new Map();
   const _sf = /* @__PURE__ */ new Map();
+  const _hr = /* @__PURE__ */ new Map();
   const _qg = /* @__PURE__ */ new Map();
   const _dp = /* @__PURE__ */ new Map();
   const _de = /* @__PURE__ */ new Map();
@@ -4848,13 +4971,10 @@ function act() {
   const fold_specs = [];
   const lanes = [];
   let _built = false;
-  const pii_wrap = (original) => {
+  const read_wrap = (original) => {
     const wrapped = async (events, stream) => {
-      const stripped = events.map((e) => {
-        const f = _sf.get(e.name);
-        return f ? pii_strip(e, f) : e;
-      });
-      return original(stripped, stream);
+      const read = events.map((e) => _hr.get(e.name)?.(e) ?? e);
+      return original(read, stream);
     };
     const reset = original[FOLD_RESET];
     if (reset) Object.defineProperty(wrapped, FOLD_RESET, { value: reset });
@@ -4865,14 +4985,14 @@ function act() {
     for (const spec of fold_specs) {
       handlers.set(
         spec.target,
-        pii_wrap(
+        read_wrap(
           make_fold_handler(
             spec.merged,
             spec.flush,
             spec.config,
             patch_fn,
             // Head loads strip sensitive keys like the warm path (#1320).
-            (event_name) => _sf.get(event_name) ?? []
+            registry.sensitive_fields
           )
         )
       );
@@ -4990,67 +5110,22 @@ function act() {
             config: fold.config
           });
         }
-        for (const register of Object.values(registry.events)) {
-          for (const reaction of register.reactions.values()) {
-            if (typeof reaction.resolver === "function") continue;
-            const target = reaction.resolver.target;
-            const claimed = batch_handlers.has(target) || fold_specs.some((f) => f.target === target);
-            if (claimed && !projection_reactions.has(reaction))
-              throw new Error(
-                `Reaction on target "${target}" conflicts with the projection that already serves it \u2014 a target is served by one batch handler or one state projection, and a reaction to it would never run`
-              );
-          }
-        }
+        const built = build_events(registry, states, lanes, {
+          batch_handlers,
+          fold_targets: new Set(fold_specs.map((f) => f.target)),
+          projection_reactions
+        });
+        for (const [name, fields] of built.sensitive) _sf.set(name, fields);
+        for (const [name, gate] of built.query_readers) _qg.set(name, gate);
+        for (const [name, gate] of built.handler_readers) _hr.set(name, gate);
         finalize_deprecations();
-        validate_lane_references(registry, lanes);
-        for (const [event_name, reg] of Object.entries(
-          registry.events
-        )) {
-          const fields = pii_fields(reg.schema);
-          if (fields.length === 0) continue;
-          _sf.set(event_name, fields);
-          _qg.set(event_name, make_gate(fields, null));
-          for (const [name, reaction] of reg.reactions) {
-            const inner = reaction.handler;
-            const wrapped = (event, stream, app) => inner(pii_strip(event, fields), stream, app);
-            Object.defineProperty(wrapped, "name", { value: inner.name });
-            reaction.handler = wrapped;
-            reg.reactions.set(name, reaction);
-          }
-        }
         for (const state2 of states.values()) {
           if (state2.disclose) _dp.set(state2.name, state2.disclose);
           if (state2.autoclose) _ac.set(state2.name, state2.autoclose);
           if (state2.archive) _aa.set(state2.name, state2.archive);
-          const fields_by_event = /* @__PURE__ */ new Map();
-          for (const event_name of Object.keys(state2.events)) {
-            const fields = _sf.get(event_name);
-            if (fields) fields_by_event.set(event_name, fields);
-          }
-          if (fields_by_event.size === 0) continue;
-          if (state2.snap) {
-            const offending = [...fields_by_event.keys()];
-            throw new Error(
-              `State "${state2.name}" cannot snapshot \u2014 events {${offending.join(", ")}} carry sensitive fields. Snapshots write derived state into __snapshot__.data, which forget_pii cannot reach. Remove .snap() or remove sensitive(...) markers.`
-            );
-          }
-          const disclose = state2.disclose ?? null;
-          state2.pii_aware = true;
-          const view_gates = /* @__PURE__ */ new Map();
-          for (const [event_name, fields] of fields_by_event) {
-            view_gates.set(event_name, make_gate(fields, disclose));
-          }
-          state2.view = (event, actor) => (view_gates.get(event.name) ?? IDENTITY_GATE)(
-            event,
-            actor
-          );
-          state2.message = (validated) => {
-            const fields = fields_by_event.get(validated.name);
-            return fields ? pii_split(validated, fields) : validated;
-          };
         }
         for (const [target, original] of batch_handlers) {
-          batch_handlers.set(target, pii_wrap(original));
+          batch_handlers.set(target, read_wrap(original));
         }
         synthesize_autoclose_reactions(
           registry,
@@ -5409,11 +5484,11 @@ var CsvFile = class {
         // payload must not depend on whether it came back through a store or
         // through a CSV restore (#1399). The `created` column below has
         // always been parsed explicitly; the JSON columns were missed.
-        data: JSON.parse(fields[2], dateReviver),
+        data: JSON.parse(fields[2]),
         stream: fields[3],
         version: Number.parseInt(fields[4], 10),
         created: new Date(fields[5]),
-        meta: JSON.parse(fields[6], dateReviver)
+        meta: JSON.parse(fields[6])
       };
       await Promise.resolve(callback(event));
       count++;