@rotorsoft/act 1.31.14 → 1.31.16

package/dist/index.cjs

@@ -68,6 +68,7 @@ __export(index_exports, {
   cache: () => cache2,
   config: () => config,
   dateReviver: () => dateReviver,
+  default_scope: () => default_scope,
   dispose: () => dispose,
   disposeAndExit: () => disposeAndExit,
   extend: () => extend,
@@ -407,23 +408,28 @@ function is_pii(schema) {
     cur = inner;
   }
 }
-function pii_fields(schema) {
+function pii_schemas(schema) {
   const shape = schema.shape;
   if (shape && typeof shape === "object") {
-    const fields = [];
-    for (const key of Object.keys(shape)) {
-      if (is_pii(shape[key])) fields.push(key);
-    }
+    const fields = {};
+    for (const key of Object.keys(shape))
+      if (is_pii(shape[key])) fields[key] = shape[key];
     return fields;
   }
   const options = schema.options;
   if (Array.isArray(options)) {
-    const fields = /* @__PURE__ */ new Set();
+    const fields = {};
     for (const option of options)
-      for (const key of pii_fields(option)) fields.add(key);
-    return [...fields];
+      for (const [key, field] of Object.entries(
+        pii_schemas(option)
+      ))
+        fields[key] ??= field;
+    return fields;
   }
-  return [];
+  return {};
+}
+function pii_fields(schema) {
+  return Object.keys(pii_schemas(schema));
 }
 function pii_split(emitted, fields) {
   const data = { ...emitted.data };
@@ -1607,7 +1613,7 @@ var import_node_async_hooks = require("async_hooks");
 var scoped = new import_node_async_hooks.AsyncLocalStorage();
 var reacting = new import_node_async_hooks.AsyncLocalStorage();
 function make_run_scoped(bag) {
-  return bag ? (fn) => scoped.run(bag, fn) : (fn) => fn();
+  return (fn) => scoped.run(bag, fn);
 }
 function current_ports() {
   return scoped.getStore();
@@ -1661,6 +1667,15 @@ var _cache = port(function cache(adapter) {
 var cache2 = ((adapter) => {
   return current_ports()?.cache ?? _cache(adapter);
 });
+var default_scope = () => DEFAULT_SCOPE;
+var DEFAULT_SCOPE = {
+  get store() {
+    return _store();
+  },
+  get cache() {
+    return _cache();
+  }
+};
 async function disposeAndExit(code = "EXIT") {
   if (code === "ERROR" && config().env === "production") {
     log().warn(
@@ -3360,14 +3375,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;
@@ -3509,18 +3527,83 @@ function close_correlation(correlator, actor) {
   });
 }
 
-// src/internal/defer-config.ts
+// src/internal/date-reviver.ts
 var import_zod7 = require("zod");
-var DeferDurationSchema = import_zod7.z.object({
-  days: import_zod7.z.number().positive().optional(),
-  hours: import_zod7.z.number().positive().optional(),
-  minutes: import_zod7.z.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: import_zod7.z.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 import_zod7.z.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 ? import_zod7.z.looseObject(dated) : void 0;
+    }
+    case "array": {
+      const element = date_reviver_schema(def.element);
+      return element && import_zod7.z.array(element);
+    }
+    case "tuple": {
+      const items = def.items.map((i) => date_reviver_schema(i));
+      return items.some(Boolean) ? import_zod7.z.tuple(items.map((i) => i ?? import_zod7.z.unknown())) : void 0;
+    }
+    case "record": {
+      const value = date_reviver_schema(def.valueType);
+      return value && import_zod7.z.record(import_zod7.z.string(), value);
+    }
+    case "union": {
+      const variants = def.options.map(variant_schema);
+      return variants.some((v) => v.dated) ? import_zod7.z.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
+var import_zod8 = require("zod");
+var DeferDurationSchema = import_zod8.z.object({
+  days: import_zod8.z.number().positive().optional(),
+  hours: import_zod8.z.number().positive().optional(),
+  minutes: import_zod8.z.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 = import_zod7.z.object({
+var DeferWhenSchema = import_zod8.z.object({
   after: DeferDurationSchema.optional(),
-  at: import_zod7.z.date().optional()
+  at: import_zod8.z.date().optional()
 }).strict().refine((w) => w.after === void 0 !== (w.at === void 0), {
   message: "defer: specify exactly one of `after` or `at`"
 });
@@ -5002,6 +5085,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
@@ -5080,7 +5165,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);
@@ -5109,7 +5195,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 ?? store2());
+    this._notify_disposer = this._wire_notify(this._ports.store);
     register_weak_disposer(new WeakRef(this), (self) => self.shutdown());
   }
   /**
@@ -5358,13 +5444,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;
@@ -6362,7 +6448,7 @@ var Act = class {
 };
 
 // src/builders/merge.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 function base_type_name(zodType) {
   let t = zodType;
   while (typeof t.unwrap === "function") {
@@ -6371,7 +6457,7 @@ function base_type_name(zodType) {
   return t.constructor.name;
 }
 function merge_schemas(existing, incoming, state_name) {
-  if (existing instanceof import_zod8.ZodObject && incoming instanceof import_zod8.ZodObject) {
+  if (existing instanceof import_zod9.ZodObject && incoming instanceof import_zod9.ZodObject) {
     const existing_shape = existing.shape;
     const incoming_shape = incoming.shape;
     for (const key of Object.keys(incoming_shape)) {
@@ -6558,70 +6644,43 @@ function reaction_on(event, events, builder) {
 }
 
 // src/builders/event-builder.ts
-var import_zod9 = require("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 import_zod9.z.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 import_zod9.z.looseObject(next);
-    }
-    case "array":
-      return import_zod9.z.array(to_read_schema(def.element, found));
-    case "record":
-      return import_zod9.z.record(
-        import_zod9.z.string(),
-        to_read_schema(def.valueType, found)
-      );
-    case "union":
-      return import_zod9.z.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;
-  }
-}
+var import_zod10 = require("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(import_zod10.z.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)]);
@@ -7408,6 +7467,7 @@ function write_line(writer, line) {
   cache,
   config,
   dateReviver,
+  default_scope,
   dispose,
   disposeAndExit,
   extend,