@rotorsoft/act 1.23.5 → 1.23.7

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-DORIRU2I.js";
+} from "./chunk-C7H3GARW.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -496,84 +496,8 @@ var PASS_FACTORIES = {
   "clock-anomalies": make_clock_anomalies_pass
 };
 
-// src/internal/autoclose-config.ts
-import { z } from "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 = z.object({
-  start: z.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
-  end: z.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
-  timeZone: 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 = z.object({
-  autocloseCycleMinutes: z.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
-  closeBatchSize: z.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
-  closeYieldMs: z.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
-  closeOnError: 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
-import { z as z2 } from "zod";
+import { z } from "zod";
 var DAY_MS = 864e5;
 var MIN_AFTER_DAYS = 1 / 1440;
 var MIN_KEEP_DAYS = 1;
@@ -583,21 +507,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) => z2.object({
-  days: z2.number({ message: `autocloses: ${field}.days must be a number` }).positive(`autocloses: ${field}.days must be > 0`)
+var window_schema = (field, min_days, floor) => z.object({
+  days: 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 = z2.union([
-  z2.string().min(1, "autocloses: is must be a non-empty event name"),
-  z2.array(
-    z2.string().min(1, "autocloses: is entries must be non-empty event names")
+var IsSchema = z.union([
+  z.string().min(1, "autocloses: is must be a non-empty event name"),
+  z.array(
+    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 = z2.number({ message: "autocloses: reaches must be a number" }).int("autocloses: reaches must be an integer").min(1, "autocloses: reaches must be >= 1");
-var OrBlockSchema = z2.object({
+var ReachesSchema = 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 = z.object({
   after: AfterSchema.optional(),
   is: IsSchema.optional(),
   reaches: ReachesSchema.optional()
@@ -607,7 +531,7 @@ var OrBlockSchema = z2.object({
     message: "autocloses: `or` block must include at least one of after / is / reaches"
   }
 );
-var AutoclosePolicySchema = z2.object({
+var AutoclosePolicySchema = z.object({
   after: AfterSchema.optional(),
   is: IsSchema.optional(),
   reaches: ReachesSchema.optional(),
@@ -663,6 +587,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 {
   /**
@@ -843,6 +805,123 @@ function classify_registry(registry, states) {
   };
 }
 
+// src/internal/config.ts
+import { z as z2 } from "zod";
+var BackoffOptionsSchema = z2.object({
+  strategy: z2.enum(["fixed", "linear", "exponential"]),
+  baseMs: z2.number().min(0),
+  maxMs: z2.number().gt(0).optional(),
+  jitter: z2.boolean().optional()
+});
+var ReactionOptionsSchema = z2.object({
+  blockOnError: z2.boolean(),
+  maxRetries: z2.number().int().min(0),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveReactionConfig(options) {
+  return ReactionOptionsSchema.parse(options);
+}
+var ActionOptionsSchema = z2.object({
+  maxRetries: z2.number().int().min(0).optional(),
+  backoff: BackoffOptionsSchema.optional()
+});
+function resolveActionConfig(options) {
+  return ActionOptionsSchema.parse(options);
+}
+var LaneConfigSchema = z2.object({
+  name: z2.string().min(1),
+  leaseMillis: z2.number().min(0).optional(),
+  streamLimit: z2.number().int().min(0).optional(),
+  cycleMs: z2.number().min(0).optional()
+});
+function resolveLaneConfig(options) {
+  LaneConfigSchema.parse(options);
+  return options;
+}
+var DrainOptionsSchema = z2.object({
+  streamLimit: z2.number().int().min(0).optional(),
+  eventLimit: z2.number().int().min(0).optional(),
+  leaseMillis: z2.number().min(0).optional()
+});
+function resolveDrainConfig(options) {
+  if (options === void 0) return void 0;
+  DrainOptionsSchema.parse(options);
+  return options;
+}
+var SettleOptionsSchema = DrainOptionsSchema.extend({
+  debounceMs: z2.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: z2.number().int().min(0).optional()
+}).loose();
+function resolveSettleConfig(options) {
+  if (options === void 0) return void 0;
+  SettleOptionsSchema.parse(options);
+  return options;
+}
+var ActOptionsSchema = z2.object({
+  maxSubscribedStreams: z2.number().int().min(1).optional(),
+  settleDebounceMs: z2.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 = z2.object({
+  start: z2.number().int().min(0).max(23, { message: "autocloseWindow.start must be an hour in [0, 23]" }),
+  end: z2.number().int().min(0).max(23, { message: "autocloseWindow.end must be an hour in [0, 23]" }),
+  timeZone: z2.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 = z2.object({
+  autocloseCycleMinutes: z2.number().int().min(1).max(1440).default(DEFAULT_AUTOCLOSE_CYCLE_MINUTES),
+  closeBatchSize: z2.number().int().min(1).max(1024).default(DEFAULT_CLOSE_BATCH_SIZE),
+  closeYieldMs: z2.number().min(0).max(1e3).default(DEFAULT_CLOSE_YIELD_MS),
+  closeOnError: z2.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 = z2.object({
+  failureThreshold: z2.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
+  cooldownMs: z2.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 = z2.object({
+  flushEvery: z2.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
+  maxCachedStates: z2.number().int().min(1).default(DEFAULT_MAX_CACHED_STATES)
+});
+function resolveFoldConfig(options) {
+  return FoldOptionsSchema.parse(options);
+}
+
 // src/internal/defer-config.ts
 import { z as z3 } from "zod";
 var DeferDurationSchema = z3.object({
@@ -1050,11 +1129,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, {
@@ -1073,14 +1155,6 @@ function reaction_on(event, events, builder) {
 }
 
 // src/internal/circuit-breaker.ts
-import { z as z4 } from "zod";
-var DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 5;
-var DEFAULT_CIRCUIT_COOLDOWN_MS = 3e4;
-var CircuitBreakerOptionsSchema = z4.object({
-  failureThreshold: z4.number().int().min(1).default(DEFAULT_CIRCUIT_FAILURE_THRESHOLD),
-  cooldownMs: z4.number().int().min(100).max(36e5).default(DEFAULT_CIRCUIT_COOLDOWN_MS)
-});
-var resolveCircuitBreakerConfig = (options) => CircuitBreakerOptionsSchema.parse(options ?? {});
 var CircuitBreaker = class {
   _failures = 0;
   _opened_at;
@@ -1748,6 +1822,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));
@@ -1958,7 +2036,14 @@ async function load(me, target, callback, patch_fn = bare_patch) {
     {
       stream,
       stream_exact: true,
-      ...cached ? { after: cached.event_id } : { with_snaps: true, ...asOf }
+      // The snapshot resume floor is a current-state optimization: it only
+      // holds when the load has no window of its own. `time_travel` already
+      // captures that (any `asOf` bound set), so request `with_snaps` only for
+      // a non-time-travel cold load — a bounded load full-scans real events
+      // under its `asOf` filter. This is the single floor-eligibility decision
+      // for the whole system; the stores apply the floor whenever asked and
+      // never re-derive it (RFC 1274). The warm path resumes from `after`.
+      ...cached ? { after: cached.event_id } : { ...time_travel ? {} : { with_snaps: true }, ...asOf }
     }
   );
   const head_is_tombstone = event?.name === TOMBSTONE_EVENT;
@@ -2497,16 +2582,6 @@ var DrainController = class {
 };
 
 // src/internal/projection-fold.ts
-import { z as z5 } from "zod";
-var DEFAULT_FOLD_FLUSH_EVERY = 1e3;
-var DEFAULT_MAX_CACHED_STATES = 1e4;
-var FoldOptionsSchema = z5.object({
-  flushEvery: z5.number().int().min(1).default(DEFAULT_FOLD_FLUSH_EVERY),
-  maxCachedStates: z5.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 cache2 = /* @__PURE__ */ new Map();
   const row = ({ dirty: _, ...row2 }) => row2;
@@ -3533,6 +3608,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));
@@ -4095,6 +4171,7 @@ var Act = class {
    * @see {@link correlate} for manual correlation
    */
   settle(options = {}) {
+    resolveSettleConfig(options);
     if (!this._drain) return;
     this._settle.schedule(options);
   }
@@ -4215,11 +4292,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) {
@@ -4536,6 +4614,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;
       }