@rotorsoft/act 1.33.6 → 1.33.8

package/dist/index.js

@@ -1174,8 +1174,6 @@ var CorrelateCycle = class {
   _static_targets;
   _cd;
   _on_init;
-  /** Runs once after `on_init`; re-seeds defer timers across a restart. */
-  _on_init_async;
   _declared_lanes;
   /** Report-once keys; per instance because `internal/` holds no module state. */
   _reported = /* @__PURE__ */ new Set();
@@ -1186,8 +1184,7 @@ var CorrelateCycle = class {
     max_subscribed_streams,
     declared_lanes,
     shard,
-    on_init,
-    on_init_async
+    on_init
   }) {
     this._key = shard ? `${registry_key(registry.events)}:${[...shard].sort().join(",")}` : registry_key(registry.events);
     this._dynamic_subscriptions = new LruMap(max_subscribed_streams);
@@ -1196,7 +1193,6 @@ var CorrelateCycle = class {
     this._static_targets = static_targets;
     this._cd = cd;
     this._on_init = on_init;
-    this._on_init_async = on_init_async;
   }
   get checkpoint() {
     return this._checkpoint;
@@ -1221,7 +1217,6 @@ var CorrelateCycle = class {
       ...this._static_targets
     ]);
     this._checkpoint = correlated_at >= 0 ? correlated_at : Math.max(-1, watermark - COLD_START_BACK_SCAN);
-    this._on_init?.();
     for (const { stream, priority = 0, lane } of this._static_targets) {
       this._static_subscriptions.set(stream, {
         floor: Number.POSITIVE_INFINITY,
@@ -1229,7 +1224,7 @@ var CorrelateCycle = class {
         lane
       });
     }
-    await this._on_init_async?.();
+    await this._on_init?.();
   }
   /** After `restore` replaced the log: forget everything and cold-start again. */
   restart() {
@@ -2354,7 +2349,6 @@ var EMPTY_DRAIN = {
 var RETRY = "";
 var DrainController = class {
   _armed = false;
-  _locked = false;
   _ratio = 0.5;
   /**
    * Local wake at the earliest parked (backoff or defer) visit, or at the
@@ -2422,8 +2416,8 @@ var DrainController = class {
     this._defer.stop();
   }
   async drain(options = {}) {
-    if (!this._armed || this._stopped) return EMPTY_DRAIN;
-    if (this._locked) return EMPTY_DRAIN;
+    if (!this._armed || this._stopped || this._inflight)
+      return EMPTY_DRAIN;
     const d = this._deps.defaults ?? {};
     const streamLimit = d.streamLimit ?? options.streamLimit ?? DEFAULT_STREAM_LIMIT;
     const eventLimit = options.eventLimit ?? DEFAULT_EVENT_LIMIT;
@@ -2431,7 +2425,6 @@ var DrainController = class {
     if (this._deps.breaker.state(Date.now()) === "open")
       return EMPTY_DRAIN;
     try {
-      this._locked = true;
       this._inflight = new Promise((done) => {
         this._inflight_done = done;
       });
@@ -2474,7 +2467,6 @@ var DrainController = class {
       return EMPTY_DRAIN;
     } finally {
       if (!this._stopped) this._defer.schedule();
-      this._locked = false;
       this._inflight = void 0;
       this._inflight_done?.();
       this._inflight_done = void 0;
@@ -2716,13 +2708,23 @@ function build_handle(deps) {
           handled++;
         }
       } catch (error) {
-        if (error instanceof DeferSignal)
-          return {
-            lease,
-            handled,
-            acked_at: at,
-            defer: resolve_defer_at(error.when, event)
-          };
+        if (error instanceof DeferSignal) {
+          let defer;
+          try {
+            defer = resolve_defer_at(error.when, event);
+          } catch (invalid) {
+            return finalize(
+              lease,
+              handled,
+              at,
+              invalid,
+              payload.options,
+              logger,
+              event.id
+            );
+          }
+          return { lease, handled, acked_at: at, defer };
+        }
         if (error instanceof CloseSignal)
           return {
             lease,
@@ -2908,7 +2910,6 @@ function validate_only_lanes(options, lanes) {
 var Act = class {
   _emitter = new EventEmitter();
   _breaker;
-  _listen;
   _drain;
   _auto_settle;
   /** Whether any event has a reaction; nothing arms without one. */
@@ -2989,14 +2990,6 @@ var Act = class {
   /** Runs a body so internal `store()`/`cache()` calls resolve to `_ports`. */
   _scoped;
   _correlator;
-  // Bound once, reused by every reaction payload.
-  _bound_do = this.do.bind(this);
-  _bound_load = this.load.bind(this);
-  _bound_query = this.query.bind(this);
-  _bound_query_array = this.query_array.bind(this);
-  _bound_forget = this.forget.bind(this);
-  _handle;
-  _handle_batch;
   _lanes;
   _close_lock = new CloseLock();
   /** Every lane a controller can exist for: `"default"` plus each declared one. */
@@ -3030,31 +3023,38 @@ var Act = class {
     this._correlator = options.correlator ?? default_correlator;
     this._es = build_es(this._logger, this._correlator, patch_fn);
     this._cd = build_drain(this._logger);
-    this._handle = build_handle({
+    const handle = build_handle({
       logger: this._logger,
       reaction_scope: make_reaction_scope({
-        do: this._bound_do,
-        load: this._bound_load,
-        query: this._bound_query,
-        query_array: this._bound_query_array,
-        forget: this._bound_forget
+        do: this.do.bind(this),
+        load: this.load.bind(this),
+        query: this.query.bind(this),
+        query_array: this.query_array.bind(this),
+        forget: this.forget.bind(this)
       })
     });
-    this._handle_batch = build_handle_batch(this._logger);
+    const handle_batch = build_handle_batch(this._logger);
     const classification = classify_registry(this.registry, this._states);
     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;
     this._drain = options.drain !== false;
     this._auto_settle = options.autoSettle !== false;
     this._breaker = this._build_breaker(options);
-    this._drain_controllers = this._build_drain_controllers(options, lanes);
+    this._drain_controllers = this._build_drain_controllers(
+      options,
+      lanes,
+      handle,
+      handle_batch
+    );
     this._advise_orphaned_lanes(options);
     this._audit_deps = this._build_audit_deps();
     this._correlate = this._build_correlate(options, classification);
     this._settle = this._build_settle(options);
-    this._notify_disposer = this._wire_notify(this._ports.store);
+    this._notify_disposer = this._wire_notify(
+      this._ports.store,
+      options.listen !== false
+    );
     register_weak_disposer(new WeakRef(this), (self) => self.shutdown());
   }
   /** Shared by drain, settle and autoclose; bad knobs throw at build. */
@@ -3070,7 +3070,7 @@ var Act = class {
     );
   }
   /** Apps that declare no lanes pass no lane filter to `claim`. */
-  _build_drain_controllers(options, lanes) {
+  _build_drain_controllers(options, lanes, handle, handle_batch) {
     const all_lanes = this._declared_lanes;
     const only_set = options.onlyLanes && options.onlyLanes.length > 0 ? new Set(options.onlyLanes) : void 0;
     const active_lanes = only_set ? all_lanes.filter((n) => only_set.has(n)) : all_lanes;
@@ -3083,8 +3083,8 @@ var Act = class {
         ops: this._cd,
         registry: this.registry,
         batch_handlers: this._batch_handlers,
-        handle: this._handle,
-        handle_batch: this._handle_batch,
+        handle,
+        handle_batch,
         on_acked: (acked) => this.emit("acked", acked),
         on_blocked: (blocked) => this.emit("blocked", blocked),
         // Reaction-requested close: the same machinery as `app.close`.
@@ -3149,8 +3149,10 @@ var Act = class {
       // 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,
       // 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
+      on_init: async () => {
+        this._arm_all();
+        await this._seed_persisted_defers();
+      }
     });
   }
   /** Cold start: an idle deferred stream still fires on time after a restart. */
@@ -3243,10 +3245,10 @@ var Act = class {
     }
   }
   /** Failures are logged, never thrown: `notify` is a hint. */
-  async _wire_notify(s) {
+  async _wire_notify(s, listen) {
     if (!this._reactive) return void 0;
     if (!s.notify) return void 0;
-    if (!this._listen) return void 0;
+    if (!listen) return void 0;
     try {
       return await s.notify((notification) => {
         try {
@@ -4308,37 +4310,49 @@ function register_lane(config2, lanes) {
       `Lane "${config2.name}" was already declared with a different config`
     );
 }
+function add_reaction(events, event, name, kind, make, builder) {
+  if (!name)
+    throw new Error(
+      `${kind} handler for "${String(event)}" must be a named function`
+    );
+  const label = kind === "Reaction" ? "reaction" : "projection handler";
+  if (events[event].reactions.has(name))
+    throw new Error(
+      `Duplicate ${label} "${name}" for event "${String(event)}". ${kind} handlers are keyed by function name; rename one of them.`
+    );
+  const reaction = make();
+  events[event].reactions.set(name, reaction);
+  return Object.assign(builder, {
+    to(resolver) {
+      reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
+      return builder;
+    }
+  });
+}
 function reaction_on(event, events, builder) {
-  const register = (handler, options, schedule) => {
-    if (!handler.name)
-      throw new Error(
-        `Reaction handler for "${String(event)}" must be a named function`
-      );
-    if (events[event].reactions.has(handler.name))
-      throw new Error(
-        `Duplicate reaction "${handler.name}" for event "${String(event)}". Reaction handlers are keyed by function name; rename one of them.`
-      );
-    if (schedule && typeof schedule !== "function") assert_defer_when(schedule);
-    const reaction = {
-      handler: schedule ? make_deferred(handler, schedule) : handler,
-      resolver: _this_,
-      // Validate the whole bag at the declaration site so a bad
-      // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
-      // not a NaN gate on the first retry.
-      options: resolveReactionConfig({
-        blockOnError: options?.blockOnError ?? DEFAULT_BLOCK_ON_ERROR,
-        maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
-        backoff: options?.backoff
-      })
-    };
-    events[event].reactions.set(handler.name, reaction);
-    return Object.assign(builder, {
-      to(resolver) {
-        reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-        return builder;
-      }
-    });
-  };
+  const register = (handler, options, schedule) => add_reaction(
+    events,
+    event,
+    handler.name,
+    "Reaction",
+    () => {
+      if (schedule && typeof schedule !== "function")
+        assert_defer_when(schedule);
+      return {
+        handler: schedule ? make_deferred(handler, schedule) : handler,
+        resolver: _this_,
+        // Validate the whole bag at the declaration site so a bad
+        // `maxRetries`/`backoff`/`blockOnError` throws ZodError at build,
+        // not a NaN gate on the first retry.
+        options: resolveReactionConfig({
+          blockOnError: options?.blockOnError ?? DEFAULT_BLOCK_ON_ERROR,
+          maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+          backoff: options?.backoff
+        })
+      };
+    },
+    builder
+  );
   return {
     do: (handler, options) => register(handler, options),
     defer: (schedule) => ({
@@ -4471,7 +4485,7 @@ function build_events(registry, states, lanes, owners) {
         throw new Error(
           `Reaction on target "${resolver.target}" conflicts with the projection that already serves it \u2014 a target is served by one batch handler or one state projection, and a reaction to it would never run`
         );
-      if (resolver.lane && !declared.has(resolver.lane))
+      if (resolver.lane !== void 0 && !declared.has(resolver.lane))
         lane_errors.push(
           `Reaction "${handler_name}" on "${event_name}" targets undeclared lane "${resolver.lane}". Declared lanes: ${[...declared].map((l) => `"${l}"`).join(", ")}. Add \`.withLane({ name: "${resolver.lane}", ... })\` to act() or correct the .to() declaration.`
         );
@@ -4767,31 +4781,22 @@ function _projection(target) {
       }
       return {
         do: (handler) => {
-          const reaction = {
-            handler,
-            resolver: default_resolver ?? _this_,
-            options: {
-              blockOnError: DEFAULT_BLOCK_ON_ERROR,
-              maxRetries: DEFAULT_MAX_RETRIES
-            }
-          };
-          const register = events[event];
-          if (!handler.name)
-            throw new Error(
-              `Projection handler for "${event}" must be a named function`
-            );
-          if (register.reactions.has(handler.name))
-            throw new Error(
-              `Duplicate projection handler "${handler.name}" for event "${event}". Projection handlers are keyed by function name; rename one of them.`
-            );
-          register.reactions.set(handler.name, reaction);
           const widened = base;
-          return Object.assign(widened, {
-            to(resolver) {
-              reaction.resolver = typeof resolver === "string" ? { target: resolver } : resolver;
-              return widened;
-            }
-          });
+          return add_reaction(
+            events,
+            event,
+            handler.name,
+            "Projection",
+            () => ({
+              handler,
+              resolver: default_resolver ?? _this_,
+              options: {
+                blockOnError: DEFAULT_BLOCK_ON_ERROR,
+                maxRetries: DEFAULT_MAX_RETRIES
+              }
+            }),
+            widened
+          );
         }
       };
     },