@rotorsoft/act 1.31.14 → 1.31.16

package/dist/index.js

@@ -12,6 +12,7 @@ import {
   config,
   current_reacting,
   dateReviver,
+  default_scope,
   dispose,
   disposeAndExit,
   extend,
@@ -24,7 +25,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-IO2OOCOR.js";
+} from "./chunk-T2AT4N6B.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -45,13 +46,13 @@ import {
   TargetSchema,
   ValidationError,
   ZodEmpty,
-  is_pii,
   make_gate,
   pii_fields,
+  pii_schemas,
   pii_split,
   pii_strip,
   sensitive
-} from "./chunk-D5MBFIKL.js";
+} from "./chunk-7IBF4FTQ.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -1729,14 +1730,17 @@ var CorrelateCycle = class {
               upgraded,
               correlated_at: void 0
             };
-            const held = correlated.has(resolved.target) ? entry.lane : recorded?.lane;
-            if (held !== void 0 && lane !== void 0 && held !== lane && priority === entry.priority)
+            const seen_in_scan = correlated.has(resolved.target);
+            const held_lane = (seen_in_scan ? entry.lane : recorded?.lane) ?? DEFAULT_LANE;
+            const held_priority = seen_in_scan ? entry.priority : recorded?.priority;
+            const resolved_lane = lane ?? DEFAULT_LANE;
+            if (held_priority === priority && held_lane !== resolved_lane)
               report_lane_conflict(
                 this._reported,
                 reaction.handler.name,
                 resolved.target,
-                held,
-                lane
+                held_lane,
+                resolved_lane
               );
             if (carried.priority > entry.priority) {
               entry.priority = carried.priority;
@@ -1878,18 +1882,83 @@ function close_correlation(correlator, actor) {
   });
 }
 
-// src/internal/defer-config.ts
+// src/internal/date-reviver.ts
 import { z as z3 } from "zod";
-var DeferDurationSchema = z3.object({
-  days: z3.number().positive().optional(),
-  hours: z3.number().positive().optional(),
-  minutes: z3.number().positive().optional()
+var def_of = (schema) => schema._zod?.def ?? schema.def;
+function variant_schema(schema) {
+  const shape = def_of(schema)?.shape;
+  if (!shape) {
+    const dates = date_reviver_schema(schema);
+    return { schema: dates ?? schema, dated: !!dates };
+  }
+  const next = {};
+  let dated = false;
+  for (const [key, field] of Object.entries(shape)) {
+    const dates = date_reviver_schema(field);
+    if (dates) dated = true;
+    next[key] = (dates ?? field).optional();
+  }
+  return { schema: z3.looseObject(next), dated };
+}
+function date_reviver_schema(schema) {
+  const def = def_of(schema);
+  if (!def) return void 0;
+  const inner = () => date_reviver_schema(def.innerType);
+  switch (def.type) {
+    case "date":
+      return z3.coerce.date();
+    case "object": {
+      const shape = def.shape;
+      if (!shape) return void 0;
+      const dated = {};
+      for (const [key, field] of Object.entries(shape)) {
+        const dates = date_reviver_schema(field);
+        if (dates) dated[key] = dates.optional();
+      }
+      return Object.keys(dated).length ? z3.looseObject(dated) : void 0;
+    }
+    case "array": {
+      const element = date_reviver_schema(def.element);
+      return element && z3.array(element);
+    }
+    case "tuple": {
+      const items = def.items.map((i) => date_reviver_schema(i));
+      return items.some(Boolean) ? z3.tuple(items.map((i) => i ?? z3.unknown())) : void 0;
+    }
+    case "record": {
+      const value = date_reviver_schema(def.valueType);
+      return value && z3.record(z3.string(), value);
+    }
+    case "union": {
+      const variants = def.options.map(variant_schema);
+      return variants.some((v) => v.dated) ? z3.union(variants.map((v) => v.schema)) : void 0;
+    }
+    case "nullable":
+      return inner()?.nullable();
+    case "optional":
+    case "nonoptional":
+    case "readonly":
+    case "default":
+    case "prefault":
+    case "catch":
+      return inner();
+    default:
+      return void 0;
+  }
+}
+
+// src/internal/defer-config.ts
+import { z as z4 } from "zod";
+var DeferDurationSchema = z4.object({
+  days: z4.number().positive().optional(),
+  hours: z4.number().positive().optional(),
+  minutes: z4.number().positive().optional()
 }).strict().refine((d) => d.days != null || d.hours != null || d.minutes != null, {
   message: "defer: a duration needs at least one of days, hours, or minutes"
 });
-var DeferWhenSchema = z3.object({
+var DeferWhenSchema = z4.object({
   after: DeferDurationSchema.optional(),
-  at: z3.date().optional()
+  at: z4.date().optional()
 }).strict().refine((w) => w.after === void 0 !== (w.at === void 0), {
   message: "defer: specify exactly one of `after` or `at`"
 });
@@ -3371,6 +3440,8 @@ var Act = class {
    * per-Act ports (ACT-501). No-op when the Act is unscoped — so the singleton
    * path keeps reading fresh `store()`/`cache()` per call, which matters for
    * tests that dispose and re-seed mid-suite. */
+  /** This Act's ports: its own bag, or the singleton adapters. */
+  _ports;
   _scoped;
   /**
    * Correlation-id generator for originating actions. Bound at
@@ -3449,7 +3520,8 @@ var Act = class {
     this._batch_handlers = batch_handlers;
     this._lanes = lanes;
     validate_only_lanes(options, lanes);
-    this._scoped = make_run_scoped(options.scoped);
+    this._ports = options.scoped ?? default_scope();
+    this._scoped = make_run_scoped(this._ports);
     this._correlator = options.correlator ?? default_correlator;
     this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
@@ -3478,7 +3550,7 @@ var Act = class {
     this._audit_deps = this._build_audit_deps();
     this._correlate = this._build_correlate(options, classification);
     this._settle = this._build_settle(options);
-    this._notify_disposer = this._wire_notify(options.scoped?.store ?? store());
+    this._notify_disposer = this._wire_notify(this._ports.store);
     register_weak_disposer(new WeakRef(this), (self) => self.shutdown());
   }
   /**
@@ -3727,13 +3799,13 @@ var Act = class {
       this._shutdown_promise = (async () => {
         this.stop_correlations();
         await this._scoped(() => this._correlate.release_correlation());
+        const disposer = await this._notify_disposer;
+        if (disposer) await disposer();
         this.stop_settling();
         this._breaker.stop();
         for (const c of this._drain_controllers.values()) c.stop();
         await this._await_inflight(options?.graceMs);
         this._emitter.removeAllListeners();
-        const disposer = await this._notify_disposer;
-        if (disposer) await disposer();
       })();
     }
     return this._shutdown_promise;
@@ -4927,70 +4999,43 @@ 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;
-  }
-}
+import { z as z5 } from "zod";
 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);
+  const pii = pii_schemas(schema);
+  const pii_dates = {};
+  for (const [key, field] of Object.entries(pii)) {
+    const dates = date_reviver_schema(field);
+    if (dates) pii_dates[key] = dates.optional();
+  }
+  const data_reviver_schema = date_reviver_schema(schema);
+  const revive = (schema2) => (data) => {
+    const revived = schema2.safeParse(data);
+    return revived.success ? revived.data : data;
   };
-  collect(schema);
-  const found = { date: false };
-  const read_schema = to_read_schema(schema, found);
+  const dated_pii = Object.keys(pii_dates).length > 0;
   return {
-    sensitive: [...new Set(sensitive2)],
-    parse: found.date ? (data) => read_schema.parse(data) : void 0
+    sensitive: Object.keys(pii),
+    date_reviver: data_reviver_schema && revive(data_reviver_schema),
+    pii_date_reviver: dated_pii ? revive(z5.looseObject(pii_dates)) : 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 { sensitive: sensitive2, date_reviver, pii_date_reviver } = tags;
+  if (!date_reviver && 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));
+  if (!date_reviver) return gate;
+  const revive_pii = disclosure === "redact" && predicate ? pii_date_reviver : void 0;
+  return ((event, actor) => {
+    const pii = event.pii;
+    return gate(
+      {
+        ...event,
+        data: date_reviver(event.data),
+        ...revive_pii && actor && pii != null ? { pii: revive_pii(pii) } : {}
+      },
+      actor
+    );
+  });
 }
 function build_events(registry, states, lanes, owners) {
   const declared = /* @__PURE__ */ new Set([DEFAULT_LANE, ...lanes.map((l) => l.name)]);
@@ -5776,6 +5821,7 @@ export {
   cache,
   config,
   dateReviver,
+  default_scope,
   dispose,
   disposeAndExit,
   extend,