@rotorsoft/act 1.14.0 → 1.15.0

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-QKVY5QAQ.js";
+} from "./chunk-DBQT3ALY.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -45,7 +45,7 @@ import {
   pii_strip,
   sensitive
 } from "./chunk-4TJN4G7L.js";
-import "./chunk-5WRI5ZAA.js";
+import "./chunk-YLJ4XMA6.js";
 
 // src/signals.ts
 process.once("SIGINT", async (arg) => {
@@ -489,25 +489,59 @@ var PASS_FACTORIES = {
 
 // src/internal/autoclose-config.ts
 import { z } from "zod";
-var DEFAULT_AUTOCLOSE_CYCLE_MS = 6e4;
+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({
-  autocloseCycleMs: z.number().min(1e4).max(36e5).default(DEFAULT_AUTOCLOSE_CYCLE_MS),
+  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)
+  closeOnError: z.boolean().default(false),
+  autocloseWindow: AutocloseWindowSchema.optional()
 });
 function resolveAutocloseConfig(options) {
   return AutocloseOptionsSchema.parse({
-    autocloseCycleMs: options?.autocloseCycleMs,
+    autocloseCycleMinutes: options?.autocloseCycleMinutes,
     closeBatchSize: options?.closeBatchSize,
     closeYieldMs: options?.closeYieldMs,
-    closeOnError: options?.closeOnError
+    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 in_autoclose_window(window, now) {
+  if (!window) return true;
+  const hour = hour_in_zone(now, window.timeZone);
+  return window.start < window.end ? hour >= window.start && hour < window.end : hour >= window.start || hour < window.end;
+}
 
 // src/internal/close-cycle.ts
+var SAFETY_PROBE_PAGE_SIZE = 1e3;
 async function run_close_cycle(targets, deps) {
   const target_map = new Map(targets.map((t) => [t.stream, t]));
   const streams = [...target_map.keys()];
@@ -516,7 +550,8 @@ async function run_close_cycle(targets, deps) {
   const safe = await partition_by_safety(
     stream_info,
     deps.reactive_events_size,
-    skipped
+    skipped,
+    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
   );
   if (!safe.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
   const { guarded, guard_events } = await guard_with_tombstones(
@@ -559,17 +594,37 @@ async function scan_stream_heads(streams) {
   }
   return out;
 }
-async function partition_by_safety(stream_info, reactive_events_size, skipped) {
+async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size) {
   if (reactive_events_size === 0) return [...stream_info.keys()];
   const pending_set = /* @__PURE__ */ new Set();
-  await store().query_streams((position) => {
-    const source_re = position.source ? RegExp(position.source) : void 0;
-    for (const [stream, info] of stream_info) {
-      if ((!source_re || source_re.test(stream)) && position.at < info.max_id) {
-        pending_set.add(stream);
-      }
+  const source_regex = /* @__PURE__ */ new Map();
+  const get_regex = (source) => {
+    let re = source_regex.get(source);
+    if (!re) {
+      re = new RegExp(source);
+      source_regex.set(source, re);
     }
-  });
+    return re;
+  };
+  const targets = [...stream_info.keys()];
+  let after;
+  for (; ; ) {
+    let last;
+    const { count } = await store().query_streams(
+      (position) => {
+        last = position.stream;
+        const source_re = position.source ? get_regex(position.source) : void 0;
+        for (const [stream, info] of stream_info) {
+          if ((!source_re || source_re.test(stream)) && position.at < info.max_id) {
+            pending_set.add(stream);
+          }
+        }
+      },
+      { after, limit: page_size, source_matches: targets }
+    );
+    if (count < page_size) break;
+    after = last;
+  }
   const safe = [];
   for (const [stream] of stream_info) {
     if (pending_set.has(stream)) skipped.push(stream);
@@ -690,54 +745,54 @@ async function run_autoclose_cycle(deps) {
   let predicate_errors = 0;
   const truncated = /* @__PURE__ */ new Map();
   const skipped = [];
-  const stats = await s.query_stats(
-    {},
-    { count: true, exclude: [TOMBSTONE_EVENT] }
-  );
-  const flush_batch = async (candidates2) => {
-    if (candidates2.length === 0) return;
-    const result = await run_close_cycle(candidates2, {
-      reactive_events_size: deps.reactive_events_size,
-      event_to_state: deps.event_to_state,
-      load: deps.load,
-      tombstone: deps.tombstone,
-      logger: deps.logger,
-      correlation: deps.correlation
-    });
-    for (const [stream, entry] of result.truncated) {
-      truncated.set(stream, entry);
-    }
-    for (const stream of result.skipped) skipped.push(stream);
-    await yield_between_batches(deps.config.closeYieldMs);
-  };
-  let candidates = [];
-  for (const [stream, { head, count }] of stats) {
-    inspected += 1;
-    const owner = deps.event_to_state.get(head.name);
-    if (!owner) continue;
-    const predicate = deps.autoclose_policy(owner.name);
-    if (!predicate) continue;
-    let close = false;
-    try {
-      close = predicate(stream, head, count ?? 0);
-      evaluated += 1;
-    } catch (err) {
-      predicate_errors += 1;
-      deps.logger.error(
-        `Autoclose predicate for state "${owner.name}" threw on stream "${stream}": ${err instanceof Error ? err.message : String(err)}`
-      );
-      close = deps.config.closeOnError;
+  const page = deps.config.closeBatchSize;
+  let after;
+  for (; ; ) {
+    const stats = await s.query_stats(
+      {},
+      { count: true, exclude: [TOMBSTONE_EVENT], after, limit: page }
+    );
+    if (stats.size === 0) break;
+    inspected += stats.size;
+    const candidates = [];
+    for (const [stream, { head, count }] of stats) {
+      const owner = deps.event_to_state.get(head.name);
+      if (!owner) continue;
+      const predicate = deps.autoclose_policy(owner.name);
+      if (!predicate) continue;
+      let close = false;
+      try {
+        close = predicate(stream, head, count ?? 0);
+        evaluated += 1;
+      } catch (err) {
+        predicate_errors += 1;
+        deps.logger.error(
+          `Autoclose predicate for state "${owner.name}" threw on stream "${stream}": ${err instanceof Error ? err.message : String(err)}`
+        );
+        close = deps.config.closeOnError;
+      }
+      if (!close) continue;
+      const archiver = deps.autoclose_archiver(owner.name);
+      const archive = archiver ? () => archiver(stream, head) : void 0;
+      candidates.push({ stream, archive });
     }
-    if (!close) continue;
-    const archiver = deps.autoclose_archiver(owner.name);
-    const archive = archiver ? () => archiver(stream, head) : void 0;
-    candidates.push({ stream, archive });
-    if (candidates.length >= deps.config.closeBatchSize) {
-      await flush_batch(candidates);
-      candidates = [];
+    if (candidates.length > 0) {
+      const result = await run_close_cycle(candidates, {
+        reactive_events_size: deps.reactive_events_size,
+        event_to_state: deps.event_to_state,
+        load: deps.load,
+        tombstone: deps.tombstone,
+        logger: deps.logger,
+        correlation: deps.correlation
+      });
+      for (const [stream, entry] of result.truncated)
+        truncated.set(stream, entry);
+      for (const stream of result.skipped) skipped.push(stream);
+      await yield_between_batches(deps.config.closeYieldMs);
     }
+    if (stats.size < page) break;
+    after = [...stats.keys()].at(-1);
   }
-  await flush_batch(candidates);
   return {
     inspected,
     evaluated,
@@ -767,7 +822,7 @@ var AutocloseController = class {
     this._timer = setInterval(() => {
       this.run_once().catch(() => {
       });
-    }, this.deps.config.autocloseCycleMs);
+    }, this.deps.config.autocloseCycleMinutes * 6e4);
     this._timer.unref();
     return true;
   }
@@ -799,6 +854,8 @@ var AutocloseController = class {
   async run_once() {
     if (this._running) return null;
     if (this.deps.breaker.state(Date.now()) === "open") return null;
+    if (!in_autoclose_window(this.deps.config.autocloseWindow, /* @__PURE__ */ new Date()))
+      return null;
     this._running = true;
     try {
       const correlation = close_correlation(
@@ -4073,7 +4130,7 @@ export {
   ConcurrencyError,
   ConsoleLogger,
   CsvFile,
-  DEFAULT_AUTOCLOSE_CYCLE_MS,
+  DEFAULT_AUTOCLOSE_CYCLE_MINUTES,
   DEFAULT_CLOSE_BATCH_SIZE,
   DEFAULT_CLOSE_YIELD_MS,
   DEFAULT_LANE,