@rotorsoft/act 1.32.25 → 1.32.27

package/dist/index.cjs

@@ -1406,10 +1406,8 @@ var ALL_LANES = /* @__PURE__ */ Symbol("act-1103/all-lanes");
 function classify_registry(registry, states) {
   const statics = /* @__PURE__ */ new Map();
   const target_lanes = /* @__PURE__ */ new Map();
-  const reactive_events = /* @__PURE__ */ new Set();
   const event_to_lanes = /* @__PURE__ */ new Map();
   for (const [name, register] of Object.entries(registry.events)) {
-    if (register.reactions.size > 0) reactive_events.add(name);
     for (const reaction of register.reactions.values()) {
       if (typeof reaction.resolver === "function") {
         event_to_lanes.set(name, ALL_LANES);
@@ -1447,7 +1445,6 @@ function classify_registry(registry, states) {
   }
   return {
     static_targets: [...statics.values()],
-    reactive_events,
     event_to_state,
     event_to_lanes
   };
@@ -2604,7 +2601,7 @@ async function run_full_closes(full, target_map, deps, skipped) {
   }
   const safe = await partition_by_safety(
     stream_info,
-    deps.reactive_events_size,
+    deps.reactive,
     skipped,
     deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE,
     deps.catch_up_correlation
@@ -2641,8 +2638,8 @@ async function run_full_closes(full, target_map, deps, skipped) {
   );
 }
 async function run_windowed_closes(windowed, deps, skipped) {
-  const checkpoint = deps.reactive_events_size > 0 ? await deps.catch_up_correlation(Number.MAX_SAFE_INTEGER) : -1;
-  const min_at = deps.reactive_events_size > 0 ? await probe_min_watermarks(
+  const checkpoint = deps.reactive ? await deps.catch_up_correlation(Number.MAX_SAFE_INTEGER) : -1;
+  const min_at = deps.reactive ? await probe_min_watermarks(
     windowed.map((t) => t.stream),
     deps.probe_page_size ?? SAFETY_PROBE_PAGE_SIZE,
     checkpoint
@@ -2730,8 +2727,8 @@ async function scan_stream_heads(streams) {
   }
   return out;
 }
-async function partition_by_safety(stream_info, reactive_events_size, skipped, page_size, catch_up_correlation2) {
-  if (reactive_events_size === 0) return [...stream_info.keys()];
+async function partition_by_safety(stream_info, reactive, skipped, page_size, catch_up_correlation2) {
+  if (!reactive) return [...stream_info.keys()];
   let needed = -1;
   for (const info of stream_info.values())
     needed = Math.max(needed, info.max_id);
@@ -3017,13 +3014,25 @@ var CorrelateCycle = class {
     const after = Math.max(this._checkpoint, query.after || -1);
     const correlated = /* @__PURE__ */ new Map();
     let last_id = after;
+    let stopped = false;
     const found = await store2().query(
       (event) => {
-        last_id = event.id;
+        if (stopped) return;
         const register = this._registry.events[event.name];
         if (register) {
           for (const reaction of register.reactions.values()) {
-            const resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+            let resolved;
+            try {
+              resolved = typeof reaction.resolver === "function" ? reaction.resolver(event) : reaction.resolver;
+            } catch (error) {
+              stopped = true;
+              report_once(
+                this._reported,
+                `resolver|${reaction.handler.name}|${event.id}`,
+                `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}. Correlation stops before this event until the resolver stops throwing; work already found keeps draining.`
+              );
+              return;
+            }
             if (!resolved) continue;
             let lane = resolved.lane;
             if (lane !== void 0 && !this._declared_lanes.has(lane)) {
@@ -3072,6 +3081,7 @@ var CorrelateCycle = class {
             correlated.set(resolved.target, entry);
           }
         }
+        last_id = event.id;
       },
       // Resolvers see `pii: null`: correlate runs actor-less, and one
       // undecryptable row would otherwise stop every stream's reactions.
@@ -3113,7 +3123,7 @@ var CorrelateCycle = class {
       return { subscribed, last_id, marked, scanned: true };
     }
     this._checkpoint = last_id;
-    this._armed = found === query.limit;
+    this._armed = stopped || found === query.limit;
     return { subscribed: 0, last_id, marked: 0, scanned: true };
   }
   /**
@@ -3997,6 +4007,22 @@ function fetch_failure_policy(registry) {
     }
   return { blockOnError, maxRetries };
 }
+function resolver_failed(lease, { error, options }) {
+  log().error(error);
+  const block2 = options.blockOnError && lease.retry >= options.maxRetries;
+  return {
+    lease,
+    handled: 0,
+    acked_at: lease.at,
+    error,
+    ...block2 ? { block: true } : {
+      next_attempt_at: Date.now() + compute_backoff_delay(
+        lease.retry,
+        options.backoff ?? DEFAULT_BACKOFF
+      )
+    }
+  };
+}
 function warn_misrouted(seen, stream, handler, event) {
   report_once(
     seen,
@@ -4030,13 +4056,23 @@ async function run_drain_cycle(deps, cycle) {
   );
   for (const f of fetched) {
     const { stream, events } = f;
+    let failed;
     const payloads = events.flatMap((event) => {
       const register = registry.events[event.name];
       if (!register) return [];
       return [...register.reactions.values()].filter((reaction) => {
         const resolver = reaction.resolver;
         const dynamic = typeof resolver === "function";
-        const resolved = dynamic ? resolver(event) : resolver;
+        let resolved;
+        try {
+          resolved = dynamic ? resolver(event) : resolver;
+        } catch (error) {
+          failed ??= {
+            error: `Resolver of reaction "${reaction.handler.name}" threw on ${String(event.name)} #${event.id} (stream "${event.stream}"): ${String(error)}`,
+            options: reaction.options
+          };
+          return false;
+        }
         if (!resolved || resolved.target !== stream) return false;
         if (!dynamic || !batch_handlers.has(stream)) return true;
         warn_misrouted(
@@ -4048,7 +4084,7 @@ async function run_drain_cycle(deps, cycle) {
         return false;
       }).map((reaction) => ({ ...reaction, event }));
     });
-    fetch_map.set(stream, { fetch: f, payloads });
+    fetch_map.set(stream, { fetch: f, payloads, failed });
   }
   const handled = await Promise.all(
     leased.map((lease) => {
@@ -4069,6 +4105,8 @@ async function run_drain_cycle(deps, cycle) {
         };
         return Promise.resolve(failed);
       }
+      if (entry.failed)
+        return Promise.resolve(resolver_failed(lease, entry.failed));
       const at = entry.fetch.events.at(-1)?.id || fetch_window_at;
       const { payloads } = entry;
       const exhausted = budget_exhausted(
@@ -4548,7 +4586,8 @@ var Act = class {
   _breaker;
   _listen;
   _drain;
-  _reactive_events;
+  /** Whether any event has a reaction; nothing arms without one. */
+  _reactive;
   _drain_controllers;
   _correlate;
   _settle;
@@ -4678,7 +4717,7 @@ var Act = class {
     });
     this._handle_batch = build_handle_batch(this._logger);
     const classification = classify_registry(this.registry, this._states);
-    this._reactive_events = classification.reactive_events;
+    this._reactive = classification.event_to_lanes.size > 0;
     this._event_to_state = classification.event_to_state;
     this._event_to_lanes = classification.event_to_lanes;
     this._listen = options.listen !== false;
@@ -4725,8 +4764,18 @@ var Act = class {
         on_acked: (acked) => this.emit("acked", acked),
         on_blocked: (blocked) => this.emit("blocked", blocked),
         // Reaction-requested close: the same machinery as `app.close`.
+        // A store failure reaches the breaker; anything else (the archive
+        // callback is app code) is logged here, never counted.
         on_close: async (targets) => {
-          await this._run_close(targets);
+          try {
+            await this._run_close(targets);
+          } catch (error) {
+            if (error instanceof StoreError) throw error;
+            this._logger.error(
+              error,
+              `Reaction-requested close of ${targets.map((t) => `"${t.stream}"`).join(", ")} failed and was not retried; close it with app.close(...) once the cause is fixed.`
+            );
+          }
         },
         breaker: this._breaker,
         run_scoped: this._scoped,
@@ -4775,9 +4824,8 @@ var Act = class {
       declared_lanes: new Set(this._declared_lanes),
       // Built after the controllers, so their keys are the active lanes.
       shard: this._drain_controllers.size < this._declared_lanes.length ? [...this._drain_controllers.keys()] : void 0,
-      on_init: () => {
-        if (this._drain && this._reactive_events.size > 0) this._arm_all();
-      },
+      // Only reached on a draining app: writer-only ones never correlate.
+      on_init: () => this._arm_all(),
       on_init_async: this._drain ? () => this._seed_persisted_defers() : void 0
     });
   }
@@ -4874,7 +4922,7 @@ var Act = class {
   }
   /** Failures are logged, never thrown: `notify` is a hint. */
   async _wire_notify(s) {
-    if (this._reactive_events.size === 0) return void 0;
+    if (!this._reactive) return void 0;
     if (!s.notify) return void 0;
     if (!this._listen) return void 0;
     try {
@@ -4934,46 +4982,6 @@ var Act = class {
    * console.log(snapshots[0].state.count); // Current count after increment
    * ```
    *
-   * @example With error handling
-   * ```typescript
-   * try {
-   *   await app.do(
-   *     "withdraw",
-   *     { stream: "account-123", actor: { id: "user1", name: "Alice" } },
-   *     { amount: 1000 }
-   *   );
-   * } catch (error) {
-   *   if (error instanceof InvariantError) {
-   *     console.error("Business rule violated:", error.description);
-   *   } else if (error instanceof ConcurrencyError) {
-   *     console.error("Concurrent modification detected, retry...");
-   *   } else if (error instanceof ValidationError) {
-   *     console.error("Invalid payload:", error.details);
-   *   }
-   * }
-   * ```
-   *
-   * @example Reaction triggering another action (reactingTo auto-injected)
-   * ```typescript
-   * const app = act()
-   *   .withState(Order)
-   *   .withState(Inventory)
-   *   .on("OrderPlaced")
-   *     .do(async function reduceInventory(event, _stream, app) {
-   *       // Inside reaction handlers, reactingTo is auto-injected when omitted.
-   *       // The triggering event is used by default, maintaining the correlation chain.
-   *       await app.do(
-   *         "reduceStock",
-   *         { stream: "inventory-1", actor: { id: "sys", name: "system" } },
-   *         { amount: event.data.items.length }
-   *       );
-   *       // To use a different correlation, pass reactingTo explicitly:
-   *       // await app.do("reduceStock", target, payload, { reactingTo: customEvent });
-   *     })
-   *     .to("inventory-1")
-   *   .build();
-   * ```
-   *
    * @see {@link Target} for target structure
    * @see {@link Snapshot} for return value structure
    * @see {@link ValidationError}, {@link InvariantError}, {@link ConcurrencyError}
@@ -4989,10 +4997,9 @@ var Act = class {
         payload,
         do_options
       );
-      if (this._reactive_events.size > 0)
-        this._arm_for_event_names(
-          snapshots.map((s) => s.event.name)
-        );
+      this._arm_for_event_names(
+        snapshots.map((s) => s.event.name)
+      );
       this.emit("committed", snapshots);
       return snapshots;
     });
@@ -5039,26 +5046,6 @@ var Act = class {
    * console.log(`Found ${count} events from ${first?.id} to ${last?.id}`);
    * ```
    *
-   * @example Query specific event types
-   * ```typescript
-   * const { count } = await app.query(
-   *   { name: "UserCreated", limit: 100 },
-   *   (event) => {
-   *     console.log("User created:", event.data.email);
-   *   }
-   * );
-   * ```
-   *
-   * @example Query events in time range
-   * ```typescript
-   * const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
-   * const { count } = await app.query({
-   *   created_after: yesterday,
-   *   stream: "user-123"
-   * });
-   * console.log(`User had ${count} events in last 24 hours`);
-   * ```
-   *
    * @see {@link query_array} for loading events into memory
    */
   async query(query, callback) {
@@ -5090,14 +5077,6 @@ var Act = class {
    * events.forEach(event => console.log(event.name, event.data));
    * ```
    *
-   * @example Get recent events
-   * ```typescript
-   * const recent = await app.query_array({
-   *   stream: "user-123",
-   *   limit: 10
-   * });
-   * ```
-   *
    * @see {@link query} for large result sets
    */
   async query_array(query) {
@@ -5168,12 +5147,6 @@ var Act = class {
    * await app.drain();
    * ```
    *
-   * @example In production, prefer settle()
-   * ```typescript
-   * await app.do("CreateItem", target, input);
-   * app.settle(); // debounced correlate→drain, emits "settled"
-   * ```
-   *
    * @see {@link settle} for debounced correlate→drain with lifecycle events
    * @see {@link correlate} for dynamic stream discovery
    * @see {@link start_correlations} for automatic correlation
@@ -5185,6 +5158,7 @@ var Act = class {
     return this._scoped(() => this._drain_all(options));
   }
   _arm_all() {
+    if (!this._reactive) return;
     this._correlate.arm();
     for (const c of this._drain_controllers.values()) c.arm();
   }
@@ -5240,37 +5214,20 @@ var Act = class {
    * on reaction resolvers. It then registers these streams so they'll be picked up by
    * the next drain cycle.
    *
-   * @param query - Query filter to scan for new correlations
    * @param query - Scan filter — see {@link Query} for fields (typically
    *   `{ after: <event-id>, limit: <count> }`)
-   * @returns Object with newly leased streams and last scanned event ID
+   * @returns The number of newly subscribed streams and the last scanned event id
    *
    * @example Manual correlation
    * ```typescript
    * // Scan for new streams
-   * const { leased, last_id } = await app.correlate({ after: 0, limit: 100 });
-   * console.log(`Found ${leased.length} new streams`);
+   * const { subscribed, last_id } = await app.correlate({ after: 0, limit: 100 });
+   * console.log(`Subscribed ${subscribed} new streams`);
    *
    * // Save last_id for next scan
    * await saveCheckpoint(last_id);
    * ```
    *
-   * @example Dynamic stream creation
-   * ```typescript
-   * const app = act()
-   *   .withState(User)
-   *   .withState(UserStats)
-   *   .on("UserLoggedIn")
-   *     .do(async (event) => ["incrementLoginCount", {}])
-   *     .to((event) => ({
-   *       target: `stats-${event.stream}` // Dynamic target per user
-   *     }))
-   *   .build();
-   *
-   * // Discover stats streams as users log in
-   * await app.correlate();
-   * ```
-   *
    * @see {@link start_correlations} for automatic periodic correlation
    * @see {@link stop_correlations} to stop automatic correlation
    */
@@ -5283,8 +5240,7 @@ var Act = class {
     if (!this._drain) return { subscribed: 0, last_id: -1, scanned: false };
     return this._scoped(async () => {
       const { subscribed, last_id, marked, scanned } = await this._correlate.correlate(query, lease);
-      if ((subscribed > 0 || marked > 0) && this._reactive_events.size > 0)
-        this._arm_all();
+      if (subscribed > 0 || marked > 0) this._arm_all();
       if (subscribed > 0) this._on_discovered?.(subscribed);
       return { subscribed, last_id, scanned };
     });
@@ -5376,12 +5332,6 @@ var Act = class {
    * app.settle({ eventLimit: 1000 });   // emits "settled" when fully replayed
    * ```
    *
-   * @example Rebuild a projection (tests / scripts)
-   * ```typescript
-   * await app.reset(["my-projection"]);
-   * await app.drain({ eventLimit: 1000 });   // small streams: one pass is enough
-   * ```
-   *
    * @see {@link Store.reset} for the underlying store primitive
    * @see {@link settle} for the debounced full-catch-up loop
    */
@@ -5390,7 +5340,7 @@ var Act = class {
       const count = await store2().reset(input);
       for (const handler of this._batch_handlers.values())
         handler[FOLD_RESET]?.();
-      if (count > 0 && this._reactive_events.size > 0) this._arm_all();
+      if (count > 0) this._arm_all();
       return count;
     });
   }
@@ -5424,7 +5374,7 @@ var Act = class {
   async unblock(input) {
     return this._scoped(async () => {
       const count = await store2().unblock(input);
-      if (count > 0 && this._reactive_events.size > 0) this._arm_all();
+      if (count > 0) this._arm_all();
       return count;
     });
   }
@@ -5460,11 +5410,6 @@ var Act = class {
    * await cache().clear();   // operator's responsibility
    * ```
    *
-   * @example Copy one store into another
-   * ```typescript
-   * await app.restore(pg, {}, sqlite);
-   * ```
-   *
    * @see {@link Store.restore} for the underlying driver-pattern primitive.
    */
   async restore(source, opts = {}, sink) {
@@ -5603,16 +5548,6 @@ var Act = class {
    * await app.prioritize({ stream: "^proj-orders$", stream_exact: false }, 10);
    * ```
    *
-   * @example Drop all audit projections to background
-   * ```typescript
-   * await app.prioritize({ source: "^audit-" }, -5);
-   * ```
-   *
-   * @example Reset everyone to default
-   * ```typescript
-   * await app.prioritize({}, 0);
-   * ```
-   *
    * @see {@link Store.prioritize} for the underlying primitive
    * @see {@link claim} for how priority biases scheduling
    */
@@ -5623,7 +5558,7 @@ var Act = class {
   async _run_close(targets) {
     const close_actor = { id: "$close", name: "close" };
     const result = await run_close_cycle(targets, {
-      reactive_events_size: this._reactive_events.size,
+      reactive: this._reactive,
       catch_up_correlation: (until) => catch_up_correlation(
         this._correlate,
         (limit) => this.correlate({ limit }),
@@ -5676,27 +5611,6 @@ var Act = class {
    *   { stream: "order-456" },
    * ]);
    * ```
-   *
-   * @example Close with restart (state loaded automatically after guard)
-   * ```typescript
-   * await app.close([
-   *   { stream: "counter-1", restart: true },
-   *   { 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: [] };