@rotorsoft/act 1.23.5 → 1.23.7

package/dist/index.cjs

@@ -907,7 +907,18 @@ var InMemoryStore = class {
   async query(callback, query) {
     await sleep();
     let count = 0;
+    let floor_index = -1;
+    if (query?.with_snaps && query.stream_exact && query.stream !== void 0 && query.after === void 0) {
+      for (let j = this._events.length - 1; j >= 0; j--) {
+        const e = this._events[j];
+        if (e.stream === query.stream && e.name === SNAP_EVENT) {
+          floor_index = j;
+          break;
+        }
+      }
+    }
     if (query?.backward) {
+      const floor_id = floor_index >= 0 ? this._events[floor_index].id : -1;
       let i = (query?.before !== void 0 ? this._first_index_after(query.before - 1) : this._events.length) - 1;
       while (i >= 0) {
         const e = this._events[i--];
@@ -915,6 +926,7 @@ var InMemoryStore = class {
         if (query?.created_before && e.created >= query.created_before)
           continue;
         if (query.after !== void 0 && e.id <= query.after) break;
+        if (floor_id >= 0 && e.id < floor_id) break;
         if (query.created_after && e.created <= query.created_after) continue;
         await Promise.resolve(
           callback(this._with_pii(e))
@@ -923,16 +935,7 @@ var InMemoryStore = class {
         if (query?.limit && count >= query.limit) break;
       }
     } else {
-      let i = this._first_index_after(query?.after ?? -1);
-      if (query?.with_snaps && query.stream_exact && query.stream !== void 0 && query.after === void 0 && query.created_before === void 0 && query.created_after === void 0) {
-        for (let j = this._events.length - 1; j >= 0; j--) {
-          const e = this._events[j];
-          if (e.stream === query.stream && e.name === SNAP_EVENT) {
-            i = j;
-            break;
-          }
-        }
-      }
+      let i = floor_index >= 0 ? floor_index : this._first_index_after(query?.after ?? -1);
       while (i < this._events.length) {
         const e = this._events[i++];
         if (query && !this.in_query(query, e)) continue;
@@ -2041,84 +2044,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;
@@ -2128,21 +2055,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()
@@ -2152,7 +2079,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(),
@@ -2208,6 +2135,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 {
   /**
@@ -2388,6 +2353,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({
@@ -2595,11 +2677,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, {
@@ -2618,14 +2703,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;
@@ -3293,6 +3370,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));
@@ -3503,7 +3584,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;
@@ -4042,16 +4130,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;
@@ -5078,6 +5156,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));
@@ -5640,6 +5719,7 @@ var Act = class {
    * @see {@link correlate} for manual correlation
    */
   settle(options = {}) {
+    resolveSettleConfig(options);
     if (!this._drain) return;
     this._settle.schedule(options);
   }
@@ -5760,11 +5840,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) {
@@ -6081,6 +6162,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;
       }