@rotorsoft/act 1.23.6 → 1.23.8

package/dist/index.cjs

@@ -445,32 +445,27 @@ function pii_split(emitted, fields) {
   return { name: emitted.name, data, pii };
 }
 function pii_gate(event, fields, predicate, actor) {
-  if (fields.length === 0) return event;
   const data = event.data;
-  if (event.pii == null) {
+  const { pii, ...rest } = event;
+  if (pii == null) {
     const shredded = { ...data };
     for (const f of fields) shredded[f] = SHREDDED;
-    return {
-      ...event,
-      data: shredded
-    };
+    return { ...rest, data: shredded };
   }
   const allowed = !!actor && !!predicate && predicate(event, actor);
   if (allowed) {
     return {
-      ...event,
-      data: {
-        ...data,
-        ...event.pii
-      }
+      ...rest,
+      data: { ...data, ...pii }
     };
   }
   const redacted = { ...data };
   for (const f of fields) redacted[f] = REDACTED;
-  return {
-    ...event,
-    data: redacted
-  };
+  return { ...rest, data: redacted };
+}
+var IDENTITY_GATE = (event) => event;
+function make_gate(fields, predicate) {
+  return (event, actor) => pii_gate(event, fields, predicate, actor);
 }
 function pii_strip(event, fields) {
   const data = event.data;
@@ -2044,84 +2039,8 @@ var PASS_FACTORIES = {
   "clock-anomalies": make_clock_anomalies_pass
 };
 
-// src/internal/autoclose-config.ts
-var import_zod5 = require("zod");
-var DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
-var DEFAULT_CLOSE_BATCH_SIZE = 64;
-var DEFAULT_CLOSE_YIELD_MS = 0;
-var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
-function is_valid_time_zone(tz) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: tz });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var AutocloseWindowSchema = import_zod5.z.object({
-  start: import_zod5.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
-  end: import_zod5.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
-  timeZone: import_zod5.z.string().refine(is_valid_time_zone, {
-    message: "autocloseWindow.timeZone must be a valid IANA time zone"
-  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
-}).refine((w) => w.start !== w.end, {
-  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
-});
-var AutocloseOptionsSchema = import_zod5.z.object({
-  autocloseCycleMinutes: import_zod5.z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
-  closeBatchSize: import_zod5.z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
-  closeYieldMs: import_zod5.z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
-  closeOnError: import_zod5.z.boolean().default(false),
-  autocloseWindow: AutocloseWindowSchema.optional()
-});
-function resolveAutocloseConfig(options) {
-  return AutocloseOptionsSchema.parse({
-    autocloseCycleMinutes: options?.autocloseCycleMinutes,
-    closeBatchSize: options?.closeBatchSize,
-    closeYieldMs: options?.closeYieldMs,
-    closeOnError: options?.closeOnError,
-    autocloseWindow: options?.autocloseWindow
-  });
-}
-function hour_in_zone(now, timeZone) {
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    hour: "2-digit",
-    hourCycle: "h23"
-  }).formatToParts(now);
-  return Number(parts.find((p) => p.type === "hour")?.value);
-}
-function hour_in_range(hour, start, end) {
-  return start < end ? hour >= start && hour < end : hour >= start || hour < end;
-}
-function is_dst_gap_open(now, timeZone, start) {
-  const hour = hour_in_zone(now, timeZone);
-  if (hour <= start) return false;
-  const prev = hour_in_zone(new Date(now.getTime() - 36e5), timeZone);
-  return prev === start - 1 && hour === start + 1;
-}
-function in_autoclose_window(window, now) {
-  if (!window) return true;
-  const hour = hour_in_zone(now, window.timeZone);
-  return hour_in_range(hour, window.start, window.end) || is_dst_gap_open(now, window.timeZone, window.start);
-}
-function next_window_open(window, now) {
-  const start_ms = now.getTime();
-  for (let h = 0; h <= 48; h++) {
-    const candidate = new Date(start_ms + h * 36e5);
-    if (hour_in_zone(candidate, window.timeZone) === window.start)
-      return candidate;
-    const boundary = new Date(
-      candidate.getTime() - candidate.getTime() % 36e5
-    );
-    if (is_dst_gap_open(boundary, window.timeZone, window.start))
-      return boundary;
-  }
-  return new Date(start_ms + 864e5);
-}
-
 // src/internal/autoclose-policy.ts
-var import_zod6 = require("zod");
+var import_zod5 = require("zod");
 var DAY_MS = 864e5;
 var MIN_AFTER_DAYS = 1 / 1440;
 var MIN_KEEP_DAYS = 1;
@@ -2131,21 +2050,21 @@ function days_after(date, days) {
 function days_before_now(days) {
   return new Date(Date.now() - days * DAY_MS);
 }
-var window_schema = (field, min_days, floor) => import_zod6.z.object({
-  days: import_zod6.z.number({ message: `autocloses: ${field}.days must be a number` }).positive(`autocloses: ${field}.days must be > 0`)
+var window_schema = (field, min_days, floor) => import_zod5.z.object({
+  days: import_zod5.z.number({ message: `autocloses: ${field}.days must be a number` }).positive(`autocloses: ${field}.days must be > 0`)
 }).refine((o) => o.days >= min_days, {
   message: `autocloses: ${field} resolves to < ${floor}, which is too short to be a meaningful retention window`
 });
 var AfterSchema = window_schema("after", MIN_AFTER_DAYS, "one minute");
 var KeepSchema = window_schema("keep", MIN_KEEP_DAYS, "one day");
-var IsSchema = import_zod6.z.union([
-  import_zod6.z.string().min(1, "autocloses: is must be a non-empty event name"),
-  import_zod6.z.array(
-    import_zod6.z.string().min(1, "autocloses: is entries must be non-empty event names")
+var IsSchema = import_zod5.z.union([
+  import_zod5.z.string().min(1, "autocloses: is must be a non-empty event name"),
+  import_zod5.z.array(
+    import_zod5.z.string().min(1, "autocloses: is entries must be non-empty event names")
   ).min(1, "autocloses: is must include at least one event name").readonly()
 ]);
-var ReachesSchema = import_zod6.z.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
-var OrBlockSchema = import_zod6.z.object({
+var ReachesSchema = import_zod5.z.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
+var OrBlockSchema = import_zod5.z.object({
   after: AfterSchema.optional(),
   is: IsSchema.optional(),
   reaches: ReachesSchema.optional()
@@ -2155,7 +2074,7 @@ var OrBlockSchema = import_zod6.z.object({
     message: "autocloses: `or` block must include at least one of after / is / reaches"
   }
 );
-var AutoclosePolicySchema = import_zod6.z.object({
+var AutoclosePolicySchema = import_zod5.z.object({
   after: AfterSchema.optional(),
   is: IsSchema.optional(),
   reaches: ReachesSchema.optional(),
@@ -2211,6 +2130,44 @@ function compile_autoclose_policy(options) {
   };
 }
 
+// src/internal/autoclose-window.ts
+function hour_in_zone(now, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(now);
+  return Number(parts.find((p) => p.type === "hour")?.value);
+}
+function hour_in_range(hour, start, end) {
+  return start < end ? hour >= start && hour < end : hour >= start || hour < end;
+}
+function is_dst_gap_open(now, timeZone, start) {
+  const hour = hour_in_zone(now, timeZone);
+  if (hour <= start) return false;
+  const prev = hour_in_zone(new Date(now.getTime() - 36e5), timeZone);
+  return prev === start - 1 && hour === start + 1;
+}
+function in_autoclose_window(window, now) {
+  if (!window) return true;
+  const hour = hour_in_zone(now, window.timeZone);
+  return hour_in_range(hour, window.start, window.end) || is_dst_gap_open(now, window.timeZone, window.start);
+}
+function next_window_open(window, now) {
+  const start_ms = now.getTime();
+  for (let h = 0; h <= 48; h++) {
+    const candidate = new Date(start_ms + h * 36e5);
+    if (hour_in_zone(candidate, window.timeZone) === window.start)
+      return candidate;
+    const boundary = new Date(
+      candidate.getTime() - candidate.getTime() % 36e5
+    );
+    if (is_dst_gap_open(boundary, window.timeZone, window.start))
+      return boundary;
+  }
+  return new Date(start_ms + 864e5);
+}
+
 // src/internal/close-signal.ts
 var CloseSignal = class extends Error {
   /**
@@ -2391,6 +2348,123 @@ function classify_registry(registry, states) {
   };
 }
 
+// src/internal/config.ts
+var import_zod6 = require("zod");
+var BackoffOptionsSchema = import_zod6.z.object({
+  strategy: import_zod6.z.enum(["fixed", "linear", "exponential"]),
+  baseMs: import_zod6.z.number().min(0),
+  maxMs: import_zod6.z.number().gt(0).optional(),
+  jitter: import_zod6.z.boolean().optional()
+});
+var ReactionOptionsSchema = import_zod6.z.object({
+  blockOnError: import_zod6.z.boolean(),
+  maxRetries: import_zod6.z.number().int().min(0),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveReactionConfig(options) {
+  return ReactionOptionsSchema.parse(options);
+}
+var ActionOptionsSchema = import_zod6.z.object({
+  maxRetries: import_zod6.z.number().int().min(0).optional(),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveActionConfig(options) {
+  return ActionOptionsSchema.parse(options);
+}
+var LaneConfigSchema = import_zod6.z.object({
+  name: import_zod6.z.string().min(1),
+  leaseMillis: import_zod6.z.number().min(0).optional(),
+  streamLimit: import_zod6.z.number().int().min(0).optional(),
+  cycleMs: import_zod6.z.number().min(0).optional()
+});
+function resolveLaneConfig(options) {
+  LaneConfigSchema.parse(options);
+  return options;
+}
+var DrainOptionsSchema = import_zod6.z.object({
+  streamLimit: import_zod6.z.number().int().min(0).optional(),
+  eventLimit: import_zod6.z.number().int().min(0).optional(),
+  leaseMillis: import_zod6.z.number().min(0).optional()
+});
+function resolveDrainConfig(options) {
+  if (options === void 0) return void 0;
+  DrainOptionsSchema.parse(options);
+  return options;
+}
+var SettleOptionsSchema = DrainOptionsSchema.extend({
+  debounceMs: import_zod6.z.number().min(0).optional(),
+  // `maxPasses` defaults to Infinity (no cap) when omitted; a present value is
+  // a non-negative integer — `0` is legal and means "run no passes".
+  maxPasses: import_zod6.z.number().int().min(0).optional()
+}).loose();
+function resolveSettleConfig(options) {
+  if (options === void 0) return void 0;
+  SettleOptionsSchema.parse(options);
+  return options;
+}
+var ActOptionsSchema = import_zod6.z.object({
+  maxSubscribedStreams: import_zod6.z.number().int().min(1).optional(),
+  settleDebounceMs: import_zod6.z.number().int().min(0).optional()
+}).loose();
+function resolveActConfig(options) {
+  if (options === void 0) return void 0;
+  ActOptionsSchema.parse(options);
+  return options;
+}
+var DEFAULT_AUTOCLOSE_CYCLE_MINUTES = 720;
+var DEFAULT_CLOSE_BATCH_SIZE = 64;
+var DEFAULT_CLOSE_YIELD_MS = 0;
+var DEFAULT_AUTOCLOSE_WINDOW_TZ = "UTC";
+function is_valid_time_zone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var AutocloseWindowSchema = import_zod6.z.object({
+  start: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
+  end: import_zod6.z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
+  timeZone: import_zod6.z.string().refine(is_valid_time_zone, {
+    message: "autocloseWindow.timeZone must be a valid IANA time zone"
+  }).default(DEFAULT_AUTOCLOSE_WINDOW_TZ)
+}).refine((w) => w.start !== w.end, {
+  message: "autocloseWindow.start and end must differ \u2014 an empty window disables autoclose"
+});
+var AutocloseOptionsSchema = import_zod6.z.object({
+  autocloseCycleMinutes: import_zod6.z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
+  closeBatchSize: import_zod6.z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
+  closeYieldMs: import_zod6.z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
+  closeOnError: import_zod6.z.boolean().default(false),
+  autocloseWindow: AutocloseWindowSchema.optional()
+});
+function resolveAutocloseConfig(options) {
+  return AutocloseOptionsSchema.parse({
+    autocloseCycleMinutes: options?.autocloseCycleMinutes,
+    closeBatchSize: options?.closeBatchSize,
+    closeYieldMs: options?.closeYieldMs,
+    closeOnError: options?.closeOnError,
+    autocloseWindow: options?.autocloseWindow
+  });
+}
+var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
+var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
+var CircuitBreakerOptionsSchema = import_zod6.z.object({
+  failureThreshold: import_zod6.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: import_zod6.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
+});
+var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
+var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
+var DEFAULT_MAX_CACHED_STATES = 1e4;
+var FoldOptionsSchema = import_zod6.z.object({
+  flushEvery: import_zod6.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: import_zod6.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+
 // src/internal/defer-config.ts
 var import_zod7 = require("zod");
 var DeferDurationSchema = import_zod7.z.object({
@@ -2598,11 +2672,14 @@ function reaction_on(event, events, builder) {
     const reaction = {
       handler: schedule ? make_deferred(handler, schedule) : handler,
       resolver: _this_,
-      options: {
+      // #1269: validate the whole bag at the declaration site so a bad
+      // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
+      // not a NaN gate on the first retry.
+      options: resolveReactionConfig({
         blockOnError: options?.blockOnError ?? true,
         maxRetries: options?.maxRetries ?? 3,
         backoff: options?.backoff
-      }
+      })
     };
     events[event].reactions.set(handler.name, reaction);
     return Object.assign(builder, {
@@ -2621,14 +2698,6 @@ function reaction_on(event, events, builder) {
 }
 
 // src/internal/circuit-breaker.ts
-var import_zod9 = require("zod");
-var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
-var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
-var CircuitBreakerOptionsSchema = import_zod9.z.object({
-  failureThreshold: import_zod9.z.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
-  cooldownMs: import_zod9.z.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
-});
-var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
 var CircuitBreaker = class {
   _failures = 0;
   _opened_at;
@@ -3296,6 +3365,10 @@ function compute_backoff_delay(retry, opts) {
       delay = opts.baseMs * 2 ** r;
       if (opts.maxMs !== void 0) delay = Math.min(delay, opts.maxMs);
       break;
+    default: {
+      const _never = opts.strategy;
+      throw new Error(`unknown backoff strategy: ${String(_never)}`);
+    }
   }
   if (opts.jitter) delay = delay * (0.5 + Math.random());
   return Math.max(0, Math.floor(delay));
@@ -4052,16 +4125,6 @@ var DrainController = class {
 };
 
 // src/internal/projection-fold.ts
-var import_zod10 = require("zod");
-var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
-var DEFAULT_MAX_CACHED_STATES = 1e4;
-var FoldOptionsSchema = import_zod10.z.object({
-  flushEvery: import_zod10.z.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
-  maxCachedStates: import_zod10.z.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
-});
-function resolveFoldConfig(options) {
-  return FoldOptionsSchema.parse(options);
-}
 function make_fold_handler(me, flush, config2, patch_fn = bare_patch) {
   const cache3 = /* @__PURE__ */ new Map();
   const row = ({ dirty: _, ...row2 }) => row2;
@@ -4982,9 +5045,10 @@ var Act = class {
       let first;
       let last;
       const count = await store2().query((e) => {
-        if (!first) first = e;
-        last = e;
-        callback?.(e);
+        const gated = this.registry.query_gate(e.name)(e);
+        if (!first) first = gated;
+        last = gated;
+        callback?.(gated);
       }, query);
       return { first, last, count };
     });
@@ -5018,7 +5082,10 @@ var Act = class {
   async query_array(query) {
     return this._scoped(async () => {
       const events = [];
-      await store2().query((e) => events.push(e), query);
+      await store2().query(
+        (e) => events.push(this.registry.query_gate(e.name)(e)),
+        query
+      );
       return events;
     });
   }
@@ -5088,6 +5155,7 @@ var Act = class {
    * @see {@link start_correlations} for automatic correlation
    */
   async drain(options = {}) {
+    resolveDrainConfig(options);
     if (!this._drain)
       return { fetched: [], leased: [], acked: [], blocked: [] };
     return this._scoped(() => this._drain_all(options));
@@ -5650,6 +5718,7 @@ var Act = class {
    * @see {@link correlate} for manual correlation
    */
   settle(options = {}) {
+    resolveSettleConfig(options);
     if (!this._drain) return;
     this._settle.schedule(options);
   }
@@ -5683,6 +5752,7 @@ function validate_lane_references(registry, lanes) {
 function act() {
   const states = /* @__PURE__ */ new Map();
   const _sf = /* @__PURE__ */ new Map();
+  const _qg = /* @__PURE__ */ new Map();
   const _dp = /* @__PURE__ */ new Map();
   const _de = /* @__PURE__ */ new Map();
   const _ac = /* @__PURE__ */ new Map();
@@ -5692,6 +5762,7 @@ function act() {
     actions: {},
     events: {},
     sensitive_fields: (event_name) => _sf.get(event_name) ?? [],
+    query_gate: (event_name) => _qg.get(event_name) ?? IDENTITY_GATE,
     disclosure_predicate: (state_name) => _dp.get(state_name) ?? null,
     deprecated_events: (state_name) => _de.get(state_name) ?? EMPTY_DEPRECATED,
     autoclose_policy: (state_name) => _ac.get(state_name) ?? null,
@@ -5770,11 +5841,12 @@ function act() {
     },
     withActor: () => builder,
     withLane: (config2) => {
-      register_lane(config2, lanes);
+      register_lane(resolveLaneConfig(config2), lanes);
       return builder;
     },
     on: (event) => reaction_on(event, registry.events, builder),
     build: (options) => {
+      resolveActConfig(options);
       const patch_fn = options?.validateFoldedState === true ? validating_patch : bare_patch;
       if (!_built) {
         for (const proj of pending_projections) {
@@ -5809,6 +5881,7 @@ function act() {
           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);
@@ -5835,10 +5908,12 @@ function act() {
           }
           const disclose = state2.disclose ?? null;
           state2.pii_aware = true;
-          state2.view = (event, actor) => pii_gate(
+          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,
-            fields_by_event.get(event.name) ?? [],
-            disclose,
             actor
           );
           state2.message = (validated) => {
@@ -6091,6 +6166,7 @@ function action_builder(state2) {
         throw new Error(`Duplicate action "${action2}"`);
       internal.actions[action2] = schema;
       if (options) {
+        resolveActionConfig(options);
         internal.options ??= {};
         internal.options[action2] = options;
       }