@requence/service 0.8.3 → 0.8.4

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # @requence/service
 
+## 0.8.4
+
+### Patch Changes
+
+- 87f2347: A failed `act()` releases its defer key, and fails the node instead of parking it.
+
+  **The key leaked on every exit path but the last one.** `act(messageKey, actor)`
+  added the key to a per-connection `Set` at the top and deleted it only as the
+  final statement, with no `try`/`finally`. A malformed key, a throwing actor, a
+  rejected send or — the routine one — a trailing `publish({ done: true })` that
+  rejects with `Channel ended, no reply will be forthcoming` on a broker blip all
+  left the key in the set for the life of the process. Every later `act()` with it
+  threw `a defer key can only be used once` _before publishing anything_, so the
+  one operation that could recover the message was the operation the leak blocked.
+  The node upstream stayed parked and perfectly resumable; the pod simply refused
+  to talk to it until it restarted. Reported from production as a transient hiccup
+  that hung an accounting pipeline forever and turned a "re-deliver the answers"
+  action into a silent no-op.
+
+  The key is now released in a `finally`. The `Set` therefore means "an `act()` for
+  this key is in flight right now", which is the only thing a per-connection,
+  in-memory set can enforce — a second worker, or this one after a restart, was
+  never held by it. Nor is a defer key one-shot to begin with: the operator rewinds
+  a deferred message's index space whenever the acting **connection** changes
+  (`createStateMachine.ts`), precisely so a re-attach after a restart lands, and it
+  is `done` that spends the key. So the set is a mutual-exclusion lock, not a spend
+  ledger.
+
+  **And an actor that threw reported nothing at all.** Only a failed publish
+  reached the abort channel; a throw from the actor itself propagated straight out
+  of `act()` with no `abort` and no `done`, leaving the node deferred forever with
+  nothing logged anywhere. The arm now covers the actor, the generator loop, the
+  sends and the settle gate — everything between the resume row and the done
+  marker, all of which leave the same wreckage: whatever the actor already sent is
+  published _and_ already dispatched downstream, while the emission that ended the
+  actor never happened.
+
+  Re-attaching is not a way out of that, on either connection. On a **new**
+  connection the operator rewinds the index space, so the re-publish lands — but
+  `used` is deliberately not reset, so on a LINEAR node the first re-published
+  value trips `cannot send multiple times in linear mode` and fails the node with a
+  message that names the wrong problem. On the **same** connection nothing rewinds:
+  every re-publish is discarded as a duplicate index and only the done marker
+  lands, quietly completing the node with the _first_ attempt's data. So the node
+  now fails there and then, with the actor's own error, over the same channel a
+  failed publish already used.
+
+  The one exit that is a real recovery is deliberately left outside that arm: if
+  only the `done` publish fails, every value the actor sent did land and the node is
+  merely missing its marker, so re-running `act()` with the same key completes it —
+  which is exactly the call the leaked key used to refuse.
+
+  Two smaller fixes ride along. The abort publish is itself guarded, because the
+  channel that would carry it is usually the reason the arm was entered — the
+  failure is logged and the actor's original error stays the one the caller sees.
+  And the callback registry is now freed on both paths, not just the happy one.
+
+  **The Python SDK had neither arm, and no defer-key guard at all.** Both are
+  ported, along with the registry leak: `Service.act` now refuses a key already in
+  flight (locked, because `act()` is the one entry point an author calls from their
+  own threads), releases it in a `finally`, and aborts on a failure — flushing
+  first, since Python's `abort` only schedules its publish. Its settle gate already
+  raised an `ExceptionGroup`, which nothing caught, so that case was broken there
+  too; the group is unwrapped to its first entry so the node's error message is the
+  diagnosis rather than a sub-exception count. `BaseException` is deliberately not
+  caught: a `KeyboardInterrupt` or `sys.exit()` inside an actor is the caller ending
+  the process, not a node failing. Those still release the key.
+
 ## 0.8.3
 
 ### Patch Changes

package/build/index.js

@@ -2008,7 +2008,7 @@ function createConnection({
       clientProperties: {
         ...connectionOptions?.clientProperties,
         ...buildServiceClientProperties({
-          libVersion: "javascript@0.8.3",
+          libVersion: "javascript@0.8.4",
           serviceVersion: version,
           connectionId,
           prefetch,
@@ -2569,7 +2569,7 @@ function createConnection({
           begin: true,
           epoch,
           ...buildServiceIdentityHeaders({
-            libVersion: "javascript@0.8.3",
+            libVersion: "javascript@0.8.4",
             name,
             holdsSlot: !(isGeneratorHandler && mode === "CONTINUOUS")
           })
@@ -2805,107 +2805,113 @@ function createConnection({
         throw new Error("a defer key can only be used once");
       }
       activeMessageKeys.add(messageKey);
-      let publishIndex = 0;
-      const { taskId, messageId, ...options } = messageKeySchema.parse(messageKey);
-      const activeMessage = async () => {
-        if (activeMessages.has(messageId)) {
-          await activeMessages.get(messageId);
-        }
-      };
-      const registeredCallbackIds = new Set;
-      const outbound = createOutboundBoundary(options);
-      const growth = callbackGrowth.forDelivery({ taskId });
-      const registerCallback = (callback, path2) => {
-        const callbackId = crypto.randomUUID();
-        registeredCallbackIds.add(callbackId);
-        callbacks.set(callbackId, {
-          callback,
-          onCallbackInvoke: dispatchInvocation
-        });
-        growth.record(path2);
-        return { sourceId: connectionId, callbackId };
-      };
-      const dispatchInvocation = (invocation) => {
-        outbound.track(outbound.send(invocation.arg, {
-          outputName: invocation.outputName,
-          onCallback: registerCallback
-        }).then((data) => publish({
-          index: 0,
-          version,
+      try {
+        let publishIndex = 0;
+        const { taskId, messageId, ...options } = messageKeySchema.parse(messageKey);
+        const activeMessage = async () => {
+          if (activeMessages.has(messageId)) {
+            await activeMessages.get(messageId);
+          }
+        };
+        const registeredCallbackIds = new Set;
+        const outbound = createOutboundBoundary(options);
+        const growth = callbackGrowth.forDelivery({ taskId });
+        const registerCallback = (callback, path2) => {
+          const callbackId = crypto.randomUUID();
+          registeredCallbackIds.add(callbackId);
+          callbacks.set(callbackId, {
+            callback,
+            onCallbackInvoke: dispatchInvocation
+          });
+          growth.record(path2);
+          return { sourceId: connectionId, callbackId };
+        };
+        const dispatchInvocation = (invocation) => {
+          outbound.track(outbound.send(invocation.arg, {
+            outputName: invocation.outputName,
+            onCallback: registerCallback
+          }).then((data) => publish({
+            index: 0,
+            version,
+            taskId,
+            messageId,
+            data: invocationPayload(invocation, data),
+            outputName: invocation.outputName,
+            propertyPath: invocation.propertyPath,
+            ...invocationHeaders(invocation, options.nodeId)
+          })));
+        };
+        const publishDeps = {
+          outbound,
+          registerCallback,
           taskId,
           messageId,
-          data: invocationPayload(invocation, data),
-          outputName: invocation.outputName,
-          propertyPath: invocation.propertyPath,
-          ...invocationHeaders(invocation, options.nodeId)
-        })));
-      };
-      const publishDeps = {
-        outbound,
-        registerCallback,
-        taskId,
-        messageId,
-        nextIndex: () => publishIndex++,
-        gate: activeMessage
-      };
-      const renderSurface = buildRender(publishDeps);
-      const sendApi = {
-        ...buildSendApi(publishDeps),
-        render(ui, props, renderOptions) {
-          renderSurface({
-            ui,
-            props,
-            surfaceId: renderOptions?.surfaceId ?? DEFAULT_SURFACE_ID
-          });
-        },
-        async abort(error) {
-          await activeMessage();
-          channelWrapper.publish(`${exchange}-retry`, "operator", error instanceof Error ? error.message : error, {
-            persistent: true,
-            correlationId: messageId,
-            expiration: 0,
-            priority: 0,
-            contentType: "text/plain",
-            headers: {
-              taskId,
-              index: publishIndex++,
-              abort: true
+          nextIndex: () => publishIndex++,
+          gate: activeMessage
+        };
+        const renderSurface = buildRender(publishDeps);
+        const sendApi = {
+          ...buildSendApi(publishDeps),
+          render(ui, props, renderOptions) {
+            renderSurface({
+              ui,
+              props,
+              surfaceId: renderOptions?.surfaceId ?? DEFAULT_SURFACE_ID
+            });
+          },
+          async abort(error) {
+            await activeMessage();
+            channelWrapper.publish(`${exchange}-retry`, "operator", error instanceof Error ? error.message : error, {
+              persistent: true,
+              correlationId: messageId,
+              expiration: 0,
+              priority: 0,
+              contentType: "text/plain",
+              headers: {
+                taskId,
+                index: publishIndex++,
+                abort: true
+              }
+            });
+          }
+        };
+        announceResume({ taskId, messageId });
+        try {
+          const result = await actor(sendApi);
+          if (result != null && typeof result === "object" && ((Symbol.asyncIterator in result) || (Symbol.iterator in result))) {
+            const iterable = result;
+            for await (const value of iterable) {
+              if (value !== undefined) {
+                await sendApi.send(value);
+              }
             }
-          });
-        }
-      };
-      announceResume({ taskId, messageId });
-      const result = await actor(sendApi);
-      if (result != null && typeof result === "object" && ((Symbol.asyncIterator in result) || (Symbol.iterator in result))) {
-        const iterable = result;
-        for await (const value of iterable) {
-          if (value !== undefined) {
-            await sendApi.send(value);
+          } else if (result !== undefined) {
+            await sendApi.send(result);
+          }
+          await new Promise((resolve2) => setImmediate(resolve2));
+          await activeMessage();
+          await outbound.settle();
+        } catch (error) {
+          registeredCallbackIds.forEach((id) => callbacks.delete(id));
+          const first = error instanceof AggregateError && error.errors[0] instanceof Error ? error.errors[0] : error instanceof Error ? error : new Error(String(error));
+          try {
+            await sendApi.abort(first);
+          } catch (abortError) {
+            simple_default.error("Requence act() could not report its failure to the operator:", abortError);
           }
+          throw error;
         }
-      } else if (result !== undefined) {
-        await sendApi.send(result);
-      }
-      await new Promise((resolve2) => setImmediate(resolve2));
-      await activeMessage();
-      try {
-        await outbound.settle();
-      } catch (error) {
         registeredCallbackIds.forEach((id) => callbacks.delete(id));
-        const first = error instanceof AggregateError && error.errors[0] instanceof Error ? error.errors[0] : error instanceof Error ? error : new Error(String(error));
-        await sendApi.abort(first);
+        await publish({
+          index: publishIndex++,
+          version,
+          messageId,
+          taskId,
+          done: true
+        });
+      } finally {
         activeMessageKeys.delete(messageKey);
-        throw error;
       }
-      registeredCallbackIds.forEach((id) => callbacks.delete(id));
-      await publish({
-        index: publishIndex++,
-        version,
-        messageId,
-        taskId,
-        done: true
-      });
-      activeMessageKeys.delete(messageKey);
     }
   };
   return api;
@@ -3140,5 +3146,5 @@ export {
   PayloadTooLargeError
 };
 
-//# debugId=A75FE0293DB162D764756E2164756E21
+//# debugId=00BE6DF82B2A72F564756E2164756E21
 //# sourceMappingURL=index.js.map