@rotorsoft/act 1.31.20 → 1.31.22

package/dist/index.js

@@ -3840,11 +3840,19 @@ var Act = class {
    * It is waited on like any cycle, and deriving from the lanes alone gave
    * it a budget of `0` whenever it was the only thing running — which
    * returned before the wait it was about to be added to.
+   *
+   * A lane configured `leaseMillis: 0` takes the fallback rather than its
+   * own value, which is why this coalesces on falsy and not just on absent
+   * (#1647). A zero-length lease expires the instant it is granted, so it
+   * has no answer to offer for "how long may a handler hold this stream" —
+   * it is the pinned-no-lease case spelled with a number, and #1617 already
+   * settled what that case is worth. Taking it literally derived a budget
+   * of `0` and abandoned the very cycle this had just found running.
    */
   _derive_grace_ms(running, settling) {
     let max = settling ? DEFAULT_SHUTDOWN_GRACE_MS : 0;
     for (const c of running)
-      max = Math.max(max, c.lease_millis ?? DEFAULT_SHUTDOWN_GRACE_MS);
+      max = Math.max(max, c.lease_millis || DEFAULT_SHUTDOWN_GRACE_MS);
     return Math.min(max, MAX_SHUTDOWN_GRACE_MS);
   }
   async _await_inflight(grace_ms) {
@@ -4870,6 +4878,25 @@ function register_new_state(state2, states, actions, events) {
     events[name] = { schema: state2.events[name], reactions: /* @__PURE__ */ new Map() };
   }
 }
+function pick_declared(existing, incoming, what, state_name) {
+  if (existing && incoming && existing !== incoming)
+    throw new Error(`Duplicate ${what} for state "${state_name}"`);
+  return incoming ?? existing;
+}
+function autoclose_of(existing, state2) {
+  pick_declared(
+    existing.autoclose,
+    state2.autoclose,
+    "autoclose policy",
+    state2.name
+  );
+  const owner = state2.autoclose ? state2 : existing;
+  return {
+    autoclose: owner.autoclose,
+    autoclose_after_days: owner.autoclose_after_days,
+    autoclose_keep_days: owner.autoclose_keep_days
+  };
+}
 function merge_into_existing(state2, existing, states, actions, events) {
   for (const name of Object.keys(state2.actions)) {
     if (existing.actions[name] === state2.actions[name]) continue;
@@ -4894,11 +4921,26 @@ function merge_into_existing(state2, existing, states, actions, events) {
     patch: merged_patch,
     on: { ...existing.on, ...state2.on },
     given: { ...existing.given, ...state2.given },
-    snap: state2.snap && existing.snap && state2.snap !== existing.snap ? (() => {
-      throw new Error(
-        `Duplicate snap strategy for state "${state2.name}"`
-      );
-    })() : state2.snap || existing.snap
+    snap: pick_declared(existing.snap, state2.snap, "snap strategy", state2.name),
+    // Per-action retry policy is keyed by action name, so the two partials'
+    // maps combine. Left `undefined` when neither declared one, so the
+    // orchestrator's `me.options?.[action]` lookup is unchanged.
+    options: existing.options || state2.options ? { ...existing.options, ...state2.options } : void 0,
+    disclose: pick_declared(
+      existing.disclose,
+      state2.disclose,
+      "disclosure predicate",
+      state2.name
+    ),
+    archive: pick_declared(
+      existing.archive,
+      state2.archive,
+      "archiver",
+      state2.name
+    ),
+    // `.autocloses(...)` sets its two day fields alongside the predicate, so
+    // the whole triple travels together from whichever partial declared it.
+    ...autoclose_of(existing, state2)
   };
   states.set(state2.name, merged);
   for (const name of Object.keys(merged.actions)) {