@rotorsoft/act 1.32.26 → 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);
@@ -4589,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;
@@ -4719,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;
@@ -4826,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
     });
   }
@@ -4925,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 {
@@ -4985,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}
@@ -5040,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;
     });
@@ -5090,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) {
@@ -5141,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) {
@@ -5219,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
@@ -5236,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();
   }
@@ -5291,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
    */
@@ -5334,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 };
     });
@@ -5427,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
    */
@@ -5441,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;
     });
   }
@@ -5475,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;
     });
   }
@@ -5511,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) {
@@ -5654,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
    */
@@ -5674,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 }),
@@ -5727,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: [] };