@rotorsoft/act 1.20.0 → 1.21.0

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-TODGOWEZ.js";
+} from "./chunk-KBTC3NGQ.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -541,12 +541,22 @@ function in_autoclose_window(window, now) {
 
 // src/internal/autoclose-policy.ts
 import { z as z2 } from "zod";
-var MIN_AFTER_MS = 6e4;
-var AfterSchema = z2.object({
-  days: z2.number({ message: "autocloses: after.days must be a number" }).positive("autocloses: after.days must be > 0")
-}).refine((o) => o.days * 864e5 >= MIN_AFTER_MS, {
-  message: `autocloses: after resolves to < ${MIN_AFTER_MS}ms (one minute), which is too short to be a meaningful retention window`
+var DAY_MS = 864e5;
+var MIN_AFTER_DAYS = 1 / 1440;
+var MIN_KEEP_DAYS = 1;
+function days_after(date, days) {
+  return new Date(date.getTime() + days * DAY_MS);
+}
+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`)
+}).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(
@@ -568,16 +578,16 @@ var AutoclosePolicySchema = z2.object({
   after: AfterSchema.optional(),
   is: IsSchema.optional(),
   reaches: ReachesSchema.optional(),
-  or: OrBlockSchema.optional()
+  or: OrBlockSchema.optional(),
+  keep: KeepSchema.optional()
 }).strict().refine(
-  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0,
+  (o) => o.after !== void 0 || o.is !== void 0 || o.reaches !== void 0 || o.or !== void 0 || o.keep !== void 0,
   {
-    message: "autocloses: at least one of after / is / reaches / or must be specified \u2014 empty `{}` is a misconfiguration"
+    message: "autocloses: at least one of after / is / reaches / or / keep must be specified \u2014 empty `{}` is a misconfiguration"
   }
 );
 function compile_after(after) {
-  const after_ms = after.days * 864e5;
-  return (_stream, head) => Date.now() - head.created.getTime() >= after_ms;
+  return (_stream, head) => days_after(head.created, after.days) <= /* @__PURE__ */ new Date();
 }
 function compile_is(is) {
   const set = new Set(typeof is === "string" ? [is] : is);
@@ -586,13 +596,17 @@ function compile_is(is) {
 function compile_reaches(reaches) {
   return (_stream, _head, count) => count >= reaches;
 }
-function policy_min_after_ms(options) {
+function policy_min_after_days(options) {
   const parsed = AutoclosePolicySchema.parse(options);
   const windows = [];
-  if (parsed.after) windows.push(parsed.after.days * 864e5);
-  if (parsed.or?.after) windows.push(parsed.or.after.days * 864e5);
+  if (parsed.after) windows.push(parsed.after.days);
+  if (parsed.or?.after) windows.push(parsed.or.after.days);
   return windows.length ? Math.min(...windows) : void 0;
 }
+function policy_keep_days(options) {
+  const parsed = AutoclosePolicySchema.parse(options);
+  return parsed.keep?.days;
+}
 function compile_autoclose_policy(options) {
   const parsed = AutoclosePolicySchema.parse(options);
   const and_preds = [];
@@ -635,12 +649,20 @@ var CloseSignal = class extends Error {
    * event id when omitted.
    */
   at;
+  /**
+   * Windowed close (#1011): prune events older than this cutoff behind
+   * the closest safe snapshot instead of retiring the stream. Thrown by
+   * the autoclose reaction of a `.autocloses({ keep })` state; flows
+   * into {@link CloseTarget.before}. Omitted → a full close.
+   */
+  before;
   constructor(opts) {
     super("reaction requested close");
     this.name = "CloseSignal";
     this.stream = opts?.stream;
     this.archive = opts?.archive;
     this.at = opts?.at;
+    this.before = opts?.before;
   }
 };
 
@@ -664,7 +686,8 @@ function synthesize_autoclose_reactions(registry, states, config2) {
   for (const st of states.values()) {
     const predicate = st.autoclose;
     if (!predicate) continue;
-    const after_ms = st.autoclose_after_ms;
+    const after_days = st.autoclose_after_days;
+    const keep_days = st.autoclose_keep_days;
     const archiver = st.archive;
     const reaction = {
       // Run on a SYNTHETIC stream — `source` is the aggregate, `target` is a
@@ -688,7 +711,8 @@ function synthesize_autoclose_reactions(registry, states, config2) {
           });
         const stats = await store().query_stats([aggregate], {
           count: true,
-          exclude: [TOMBSTONE_EVENT]
+          tail: keep_days !== void 0 ? true : void 0,
+          exclude: keep_days !== void 0 ? [TOMBSTONE_EVENT, SNAP_EVENT] : [TOMBSTONE_EVENT]
         });
         const entry = stats.get(aggregate);
         if (!entry) return;
@@ -702,9 +726,24 @@ function synthesize_autoclose_reactions(registry, states, config2) {
             // aggregate) sees it caught up instead of blocking its own close.
             at: head.id
           });
-        if (after_ms !== void 0)
+        if (keep_days !== void 0) {
+          const cutoff = days_before_now(keep_days);
+          if (entry.tail.created < cutoff)
+            throw new CloseSignal({
+              stream: aggregate,
+              before: cutoff,
+              archive: archiver ? () => archiver(aggregate, head, cutoff) : void 0,
+              at: head.id
+            });
+        }
+        const dues = [];
+        if (after_days !== void 0)
+          dues.push(days_after(head.created, after_days));
+        if (keep_days !== void 0)
+          dues.push(days_after(entry.tail.created, keep_days));
+        if (dues.length)
           throw new DeferSignal({
-            at: new Date(head.created.getTime() + after_ms)
+            at: new Date(Math.min(...dues.map((d) => d.getTime())))
           });
       }
     };
@@ -1091,8 +1130,20 @@ var CircuitBreaker = class {
 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()];
+  for (const t of target_map.values()) {
+    if (t.before !== void 0 && t.restart)
+      throw new Error(
+        `close: \`before\` and \`restart\` are mutually exclusive (stream "${t.stream}") \u2014 a windowed close keeps the stream live behind a real snapshot; restart reseeds it`
+      );
+  }
+  const windowed = [...target_map.values()].filter(
+    (t) => t.before !== void 0
+  );
+  const full = [...target_map.values()].filter((t) => t.before === void 0);
   const skipped = [];
+  const windowed_result = windowed.length ? await run_windowed_closes(windowed, deps, skipped) : /* @__PURE__ */ new Map();
+  if (!full.length) return { truncated: windowed_result, skipped };
+  const streams = full.map((t) => t.stream);
   const stream_info = await scan_stream_heads(streams);
   const safe = await partition_by_safety(
     stream_info,
@@ -1100,7 +1151,7 @@ async function run_close_cycle(targets, deps) {
     skipped,
     deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
   );
-  if (!safe.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
+  if (!safe.length) return { truncated: windowed_result, skipped };
   const { guarded, guard_events } = await guard_with_tombstones(
     safe,
     stream_info,
@@ -1108,7 +1159,7 @@ async function run_close_cycle(targets, deps) {
     deps.tombstone,
     skipped
   );
-  if (!guarded.length) return { truncated: /* @__PURE__ */ new Map(), skipped };
+  if (!guarded.length) return { truncated: windowed_result, skipped };
   const seed_states = await load_restart_seeds(
     guarded,
     target_map,
@@ -1124,8 +1175,62 @@ async function run_close_cycle(targets, deps) {
     guard_events,
     deps.correlation
   );
+  for (const [stream, entry] of windowed_result) truncated.set(stream, entry);
   return { truncated, skipped };
 }
+async function run_windowed_closes(windowed, deps, skipped) {
+  const min_at = deps.reactive_events_size > 0 ? await probe_min_watermarks(
+    windowed.map((t) => t.stream),
+    deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE
+  ) : /* @__PURE__ */ new Map();
+  for (const t of windowed) {
+    if (t.archive) await t.archive();
+  }
+  const truncated = await store().truncate(
+    windowed.map((t) => ({
+      stream: t.stream,
+      before: t.before,
+      max_id: min_at.get(t.stream)
+    }))
+  );
+  for (const t of windowed) {
+    if (!truncated.has(t.stream)) skipped.push(t.stream);
+  }
+  return truncated;
+}
+async function probe_min_watermarks(streams, page_size) {
+  const min_at = /* @__PURE__ */ new Map();
+  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;
+  };
+  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 of streams) {
+          if (!source_re || source_re.test(stream)) {
+            const prev = min_at.get(stream);
+            if (prev === void 0 || position.at < prev)
+              min_at.set(stream, position.at);
+          }
+        }
+      },
+      { after, limit: page_size, source_matches: streams }
+    );
+    if (count < page_size) break;
+    after = last;
+  }
+  return min_at;
+}
 async function scan_stream_heads(streams) {
   const stats = await store().query_stats(streams, {
     exclude: [SNAP_EVENT]
@@ -2326,8 +2431,13 @@ function build_handle(deps) {
             acked_at: error.at ?? event.id,
             // Close the signalled stream (the autoclose reaction's aggregate,
             // which differs from its synthetic lease stream); a self-closing
-            // user reaction omits it and closes its own lease stream.
-            close: { stream: error.stream ?? stream, archive: error.archive }
+            // user reaction omits it and closes its own lease stream. A
+            // carried `before` makes it a windowed close (prune, not retire).
+            close: {
+              stream: error.stream ?? stream,
+              archive: error.archive,
+              before: error.before
+            }
           };
         return finalize(
           lease,
@@ -3630,7 +3740,19 @@ var Act = class {
    * 7. **Cache** — invalidate (tombstoned) or warm (restarted)
    * 8. **Emit "closed"** — lifecycle event with results
    *
-   * @param targets - Per-stream close options (stream, restart?, archive?)
+   * Targets carrying `before` take the **windowed** branch instead —
+   * close the books on a rolling window: probe the min consumer
+   * watermark (so the boundary never rises past a lagging reaction),
+   * run the archive callback against the cutoff, then prune the prefix
+   * below the closest safe `__snapshot__`. No tombstone guard (the
+   * pre-cutoff prefix is immutable), no seed, cache untouched — the
+   * stream stays live and keeps accepting actions. Requires the state
+   * to snapshot via `.snap(...)`; no qualifying snapshot ⇒ the stream
+   * lands in `skipped` (retry after the next snapshot). Windowed
+   * entries in the result echo `before` and carry the surviving
+   * boundary snapshot as `committed`.
+   *
+   * @param targets - Per-stream close options (stream, restart?, archive?, before?)
    * @returns `{ truncated: TruncateResult, skipped: string[] }`
    *
    * @example Archive and close
@@ -3648,6 +3770,19 @@ var Act = class {
    *   { stream: "counter-2" },  // tombstoned
    * ]);
    * ```
+   *
+   * @example Windowed close — keep the last 180 days of real events
+   * ```typescript
+   * const cutoff = new Date();
+   * cutoff.setDate(cutoff.getDate() - 180);
+   * await app.close([
+   *   {
+   *     stream: "ledger-acme",
+   *     before: cutoff,
+   *     archive: async () => { await archiveToS3("ledger-acme", cutoff); },
+   *   },
+   * ]);
+   * ```
    */
   async close(targets) {
     if (!targets.length) return { truncated: /* @__PURE__ */ new Map(), skipped: [] };
@@ -4180,10 +4315,16 @@ function action_builder(state2) {
           ".autocloses(...) requires a policy object; got " + typeof policy
         );
       }
+      if (policy.keep && !internal.snap) {
+        throw new Error(
+          ".autocloses({ keep }) requires .snap(...) earlier in the chain \u2014 a rolling window prunes behind a real snapshot, so a state that never snapshots has nothing to prune behind."
+        );
+      }
       internal.autoclose = compile_autoclose_policy(
         policy
       );
-      internal.autoclose_after_ms = policy_min_after_ms(policy);
+      internal.autoclose_after_days = policy_min_after_days(policy);
+      internal.autoclose_keep_days = policy_keep_days(policy);
       return builder;
     },
     archives(archive) {