@rotorsoft/act 1.31.13 → 1.31.15

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(
@@ -2547,6 +2562,15 @@ var CircuitBreaker = class {
     this._cooldown_ms = config2.cooldownMs;
     this._hooks = hooks;
   }
+  /**
+   * True when the store has failed at least once since the last pass that
+   * went all the way through. The breaker can still read "closed" here: it
+   * only opens after several failures in a row, so this catches the first
+   * one, which `state()` cannot.
+   */
+  get failing() {
+    return this._failures > 0;
+  }
   /** Current state given the wall-clock `now`. */
   state(now) {
     if (this._opened_at === void 0) return "closed";
@@ -3500,18 +3524,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`"
 });
@@ -4254,10 +4343,10 @@ function trace_cycle(logger, leased, fetched, handled, acked, blocked) {
 }
 
 // src/internal/drain-cycle.ts
-function budget_exhausted(lease, options) {
-  if (!options?.blockOnError || lease.retry <= options.maxRetries)
+function budget_exhausted(lease, options, store_failing) {
+  if (store_failing || !options?.blockOnError || lease.retry <= options.maxRetries)
     return void 0;
-  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the lease was lost on every attempt, so the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. Raise leaseMillis for this handler, then unblock the stream.`;
+  const error = `Blocking ${lease.stream} after ${lease.retry} claims with no acknowledged progress \u2014 the retry budget (${options.maxRetries}) was spent without the handler ever reporting an error. That means every attempt lost its lease before it could ack: raise leaseMillis for this handler, then unblock the stream.`;
   log().error(error);
   return { lease, handled: 0, acked_at: lease.at, error, block: true };
 }
@@ -4268,7 +4357,7 @@ function warn_misrouted(seen, stream, handler, event) {
     `Reaction "${handler}" on "${event}" resolved to target "${stream}", which a projection already serves. A target is served by one batch handler or one state projection, so this reaction can never run \u2014 and delivering to it would hand the projection an aggregate from another stream. Skipping it. The equivalent static \`.to({ target })\` is rejected at build; a dynamic resolver's target is only knowable here.`
   );
 }
-async function run_drain_cycle(ops, registry, batch_handlers, misrouted, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
+async function run_drain_cycle(ops, registry, batch_handlers, misrouted, store_failing, handle, handle_batch, lagging, leading, eventLimit, leaseMillis, on_blocked, lane) {
   const leased = await ops.claim(
     lagging,
     leading,
@@ -4310,7 +4399,11 @@ async function run_drain_cycle(ops, registry, batch_handlers, misrouted, handle,
       const entry = fetch_map.get(lease.stream);
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
-      const exhausted = budget_exhausted(lease, payloads[0]?.options);
+      const exhausted = budget_exhausted(
+        lease,
+        payloads[0]?.options,
+        store_failing
+      );
       if (exhausted) return Promise.resolve(exhausted);
       const batchHandler = batch_handlers.get(lease.stream);
       if (batchHandler && payloads.length > 0) {
@@ -4482,6 +4575,7 @@ var DrainController = class {
         this._deps.registry,
         this._deps.batch_handlers,
         this._misrouted,
+        this._deps.breaker.failing,
         this._deps.handle,
         this._deps.handle_batch,
         lagging,
@@ -4988,6 +5082,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
@@ -5066,7 +5162,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);
@@ -5095,7 +5192,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());
   }
   /**
@@ -5344,13 +5441,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;
@@ -6348,7 +6445,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") {
@@ -6357,7 +6454,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)) {
@@ -6544,70 +6641,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)]);
@@ -7394,6 +7464,7 @@ function write_line(writer, line) {
   cache,
   config,
   dateReviver,
+  default_scope,
   dispose,
   disposeAndExit,
   extend,