@rotorsoft/act 1.31.13 → 1.31.15

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) => {
@@ -916,6 +917,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";
@@ -1869,18 +1879,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`"
 });
@@ -2623,10 +2698,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 };
 }
@@ -2637,7 +2712,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,
@@ -2679,7 +2754,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) {
@@ -2851,6 +2930,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,
@@ -3357,6 +3437,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
@@ -3435,7 +3517,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);
@@ -3464,7 +3547,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());
   }
   /**
@@ -3713,13 +3796,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;
@@ -4913,70 +4996,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)]);
@@ -5762,6 +5818,7 @@ export {
   cache,
   config,
   dateReviver,
+  default_scope,
   dispose,
   disposeAndExit,
   extend,