@rotorsoft/act 1.14.1 → 1.15.0

package/dist/index.cjs

@@ -37,7 +37,7 @@ __export(index_exports, {
   ConcurrencyError: () => ConcurrencyError,
   ConsoleLogger: () => ConsoleLogger,
   CsvFile: () => CsvFile,
-  DEFAULT_AUTOCLOSE_CYCLE_MS: () => DEFAULT_AUTOCLOSE_CYCLE_MS,
+  DEFAULT_AUTOCLOSE_CYCLE_MINUTES: () => DEFAULT_AUTOCLOSE_CYCLE_MINUTES,
   DEFAULT_CLOSE_BATCH_SIZE: () => DEFAULT_CLOSE_BATCH_SIZE,
   DEFAULT_CLOSE_YIELD_MS: () => DEFAULT_CLOSE_YIELD_MS,
   DEFAULT_LANE: () => DEFAULT_LANE,
@@ -1169,8 +1169,18 @@ var InMemoryStore = class {
     const limit = query?.limit ?? 100;
     const after = query?.after;
     const blocked = query?.blocked;
+    const source_matches = query?.source_matches;
     const stream_re = query?.stream && !query.stream_exact ? new RegExp(query.stream) : void 0;
     const source_re = query?.source && !query.source_exact ? new RegExp(query.source) : void 0;
+    const reverse_cache = /* @__PURE__ */ new Map();
+    const reverse_match = (source) => {
+      let re = reverse_cache.get(source);
+      if (!re) {
+        re = new RegExp(source);
+        reverse_cache.set(source, re);
+      }
+      return source_matches.some((name) => re.test(name));
+    };
     const sorted = [...this._streams.values()].sort(
       (a, b) => a.stream.localeCompare(b.stream)
     );
@@ -1186,6 +1196,9 @@ var InMemoryStore = class {
         if (query.source_exact ? s.source !== query.source : !source_re.test(s.source))
           continue;
       }
+      if (source_matches !== void 0) {
+        if (s.source && !reverse_match(s.source)) continue;
+      }
       if (blocked !== void 0 && s.blocked !== blocked) continue;
       if (query?.lane !== void 0 && s.lane !== query.lane) continue;
       callback({
@@ -1228,6 +1241,8 @@ var InMemoryStore = class {
     const want_count = options?.count ?? false;
     const want_names = options?.names ?? false;
     const before = options?.before;
+    const after = options?.after;
+    const limit = options?.limit;
     const array_targets = Array.isArray(input) ? new Set(input) : null;
     const filter = Array.isArray(input) ? null : input;
     const stream_re = filter?.stream && !filter.stream_exact ? new RegExp(filter.stream) : void 0;
@@ -1266,13 +1281,17 @@ var InMemoryStore = class {
         a.names[n] = (a.names[n] ?? 0) + 1;
       }
     }
+    const ordered = [...acc.keys()].sort((x, y) => x.localeCompare(y));
     const out = /* @__PURE__ */ new Map();
-    for (const [stream, a] of acc) {
+    for (const stream of ordered) {
+      if (after !== void 0 && stream <= after) continue;
+      const a = acc.get(stream);
       const stats = { head: a.head };
       if (want_tail) stats.tail = a.tail;
       if (want_count) stats.count = a.count;
       if (want_names) stats.names = a.names;
       out.set(stream, stats);
+      if (limit !== void 0 && out.size >= limit) break;
     }
     return out;
   }
@@ -1871,25 +1890,59 @@ var PASS_FACTORIES = {
 
 // src/internal/autoclose-config.ts
 var import_zod5 = require("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 = 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({
-  autocloseCycleMs: import_zod5.z.number().min(1e4).max(36e5).default(DEFAULT_AUTOCLOSE_CYCLE_MS),
+  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)
+  closeOnError: import_zod5.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()];
@@ -1898,7 +1951,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(
@@ -1941,7 +1995,7 @@ 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();
   const source_regex = /* @__PURE__ */ new Map();
@@ -1953,14 +2007,25 @@ async function partition_by_safety(stream_info, reactive_events_size, skipped) {
     }
     return re;
   };
-  await store2().query_streams((position) => {
-    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);
-      }
-    }
-  });
+  const targets = [...stream_info.keys()];
+  let after;
+  for (; ; ) {
+    let last;
+    const { count } = await store2().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);
@@ -2081,54 +2146,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,
@@ -2158,7 +2223,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;
   }
@@ -2190,6 +2255,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(
@@ -5465,7 +5532,7 @@ function write_line(writer, line) {
   ConcurrencyError,
   ConsoleLogger,
   CsvFile,
-  DEFAULT_AUTOCLOSE_CYCLE_MS,
+  DEFAULT_AUTOCLOSE_CYCLE_MINUTES,
   DEFAULT_CLOSE_BATCH_SIZE,
   DEFAULT_CLOSE_YIELD_MS,
   DEFAULT_LANE,