@rotorsoft/act 1.19.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]
@@ -1556,7 +1661,7 @@ var DEFAULT_BATCH = 500;
 async function snap(snapshot) {
   const { id, stream, name, meta, version } = snapshot.event;
   try {
-    await store().commit(
+    const [committed] = await store().commit(
       stream,
       [{ name: SNAP_EVENT, data: snapshot.state }],
       {
@@ -1566,6 +1671,7 @@ async function snap(snapshot) {
       version
       // IMPORTANT! - state events are committed right after the snapshot event
     );
+    return committed;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     log().warn(
@@ -1778,7 +1884,7 @@ async function action(me, action2, target, payload, options) {
       const snapshot = await load(me, { stream, actor: target.actor });
       if (snapshot.event?.name === TOMBSTONE_EVENT)
         throw new StreamClosedError(stream);
-      const expected = expectedVersion ?? snapshot.event?.version;
+      const expected = expectedVersion ?? (snapshot.version >= 0 ? snapshot.version : void 0);
       if (me.given) {
         const invariants = me.given[action2] || [];
         invariants.forEach(({ valid: valid2, description }) => {
@@ -1860,18 +1966,22 @@ async function action(me, action2, target, payload, options) {
         };
       });
       const last = snapshots.at(-1);
-      const snapped = me.snap?.(last);
+      const contiguous = committed[0].version === snapshot.version + 1;
+      const snapped = contiguous && me.snap?.(last);
+      const snap_event = snapped ? await snap(last) : void 0;
       if (!me.pii_aware) {
-        cache().set(stream, {
-          stream,
-          state: last.state,
-          version: last.event.version,
-          event_id: last.event.id,
-          patches: snapped ? 0 : last.patches,
-          snaps: snapped ? last.snaps + 1 : last.snaps
-        }).catch((err) => log().error(err));
+        if (contiguous)
+          cache().set(stream, {
+            stream,
+            state: last.state,
+            version: snap_event?.version ?? last.event.version,
+            event_id: snap_event?.id ?? last.event.id,
+            patches: snap_event ? 0 : last.patches,
+            snaps: snap_event ? last.snaps + 1 : last.snaps
+          }).catch((err) => log().error(err));
+        else
+          cache().invalidate(stream).catch((err) => log().error(err));
       }
-      if (snapped) void snap(last);
       return snapshots;
     } catch (error) {
       if (!(error instanceof ConcurrencyError)) throw error;
@@ -2321,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,
@@ -3625,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
@@ -3643,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: [] };
@@ -3740,6 +3880,7 @@ function act() {
     autoclose_archiver: (state_name) => _aa.get(state_name) ?? null
   };
   const pending_projections = [];
+  const fold_projections = [];
   const batch_handlers = /* @__PURE__ */ new Map();
   const lanes = [];
   let _built = false;
@@ -3805,6 +3946,8 @@ function act() {
     withProjection: (proj) => {
       merge_projection(proj, registry.events);
       register_batch_handler(proj, batch_handlers);
+      if (proj.fold)
+        fold_projections.push(proj);
       return builder;
     },
     withActor: () => builder,
@@ -3818,6 +3961,26 @@ function act() {
         for (const proj of pending_projections) {
           merge_projection(proj, registry.events);
           register_batch_handler(proj, batch_handlers);
+          if (proj.fold) fold_projections.push(proj);
+        }
+        for (const proj of fold_projections) {
+          const fold = proj.fold;
+          const merged = states.get(fold.name);
+          if (!merged)
+            throw new Error(
+              `State projection "${proj.target}" folds "${fold.name}", which is not registered \u2014 add it via withState/withSlice before build()`
+            );
+          const missing = Object.keys(merged.events).filter(
+            (event_name) => !(event_name in proj.events)
+          );
+          if (missing.length > 0)
+            throw new Error(
+              `State projection "${proj.target}" of "${fold.name}" is missing events ${missing.join(", ")} \u2014 pass every partial of the state to .of()`
+            );
+          batch_handlers.set(
+            proj.target,
+            make_fold_handler(merged, fold.flush, fold.config)
+          );
         }
         finalize_deprecations();
         validate_lane_references(registry, lanes);
@@ -3960,39 +4123,52 @@ function _projection(target) {
           batchHandler: handler
         })
       }),
-      of: (state2, options = {}) => {
+      of: (...args) => {
         if (Object.keys(events).length > 0)
           throw new Error(
             `Projection "${target}" mixes .of() with .on() handlers \u2014 a projection either folds a state or declares handlers, never both`
           );
+        const is_state = (a) => !!a && typeof a.init === "function";
+        const partials = args.filter(is_state);
+        const options = args.find((a) => !is_state(a)) ?? {};
+        if (partials.length === 0)
+          throw new Error(`Projection "${target}" .of() requires a state`);
+        const name = partials[0].name;
+        for (const partial of partials)
+          if (partial.name !== name)
+            throw new Error(
+              `Projection "${target}" .of() partials must share one state name \u2014 got "${name}" and "${partial.name}"`
+            );
         const config2 = resolveFoldConfig(options);
         const fold_events = {};
-        for (const [name, schema] of Object.entries(state2.events)) {
-          const noop = {
-            [`${target}_fold`]: async () => {
-            }
-          }[`${target}_fold`];
-          fold_events[name] = {
-            schema,
-            reactions: /* @__PURE__ */ new Map([
-              [
-                `${target}_fold`,
-                {
-                  handler: noop,
-                  resolver: { target },
-                  options: { blockOnError: true, maxRetries: 3 }
-                }
-              ]
-            ])
-          };
-        }
+        for (const partial of partials)
+          for (const [event_name, schema] of Object.entries(partial.events)) {
+            if (event_name in fold_events) continue;
+            const noop = {
+              [`${target}_fold`]: async () => {
+              }
+            }[`${target}_fold`];
+            fold_events[event_name] = {
+              schema,
+              reactions: /* @__PURE__ */ new Map([
+                [
+                  `${target}_fold`,
+                  {
+                    handler: noop,
+                    resolver: { target },
+                    options: { blockOnError: true, maxRetries: 3 }
+                  }
+                ]
+              ])
+            };
+          }
         return {
           flush: (handler) => ({
             build: () => ({
               _tag: "Projection",
               events: fold_events,
               target,
-              batchHandler: make_fold_handler(state2, handler, config2)
+              fold: { name, flush: handler, config: config2 }
             })
           })
         };
@@ -4139,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) {