@requence/service 0.8.3-edge.1191 → 0.8.4-edge.1197

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @requence/service
 
+## 0.8.3
+
+### Patch Changes
+
+- 621b48b: A callback that carries no data is now called with no argument:
+
+  ```ts
+  await context.input.mail.delete();
+  ```
+
+  The `null` it used to need was never the caller's to write. It is how the
+  **output schema** spells "this position carries nothing": `RequenceCallback<void>`
+  compiles to nothing typescript-json-schema has a root type for, and
+  `RequenceCallback<undefined>` compiles but silently drops the `callback` marker
+  along with the argument — so `RequenceCallback<null>` is the only declaration
+  available, and every call site paid for that. A callback that does carry data is
+  untouched, and a forgotten argument is still an error.
+
+  `RequenceCallback<T>` makes the argument optional exactly when `null extends T`,
+  through a conditional **tuple**: a conditional on the parameter type alone cannot
+  change the ARITY, and the arity is the whole point. Writing the `null` out still
+  works and still means the same thing.
+
+  Optionality at the call site is not enough by itself. The operator validates
+  every invocation against the callback's declared argument schema, which for this
+  kind of callback is `{ type: 'null' }` — so both reconstruction sites, the
+  `deserialize` in `@requence/callbacks` and its Python mirror, default an omitted
+  argument to `null` rather than letting `undefined` reach the wire. That default
+  is unconditional: a boundary holds a reference, never the emitting node's output
+  schema, and a callback that DOES declare data fails the same validation either
+  way — turning `undefined` into `null` there only changes which of the two it is
+  refused as.
+
+  The declaration is written out four times — `@requence/helpers` for both SDKs,
+  `RequenceTypes.ts` for the logic-node editor, and the two assignability
+  harnesses. The fifth copy, in `createJsonSchema.ts`, is deliberately an object
+  shape with no call signature and does not move with them. The editor's copy is
+  now asserted through the real language service, since it is the one that decides
+  whether a script compiles.
+
+- f71e500: A durable callback that could not be run is now reported on the node that emitted
+  it, instead of only in one service process's log.
+
+  Two things can go wrong once an invocation has been consumed: the deployed version
+  no longer declares the name, or the handler throws. Both were logged by the service
+  and acked — a requeue would rerun a side-effecting callback forever — and that log
+  is nowhere a template author looks. Combined with imapflow's `messageDelete`
+  returning `true` when the _server_ accepted the command rather than when it matched
+  a mail, a failed `mail.delete()` was indistinguishable from a delete that did
+  nothing. That silence is what made the stale computed-configuration bug beside it
+  cost an afternoon.
+
+  The counterpart already existed for an invocation **nobody consumed**
+  (`DURABLE_CALLBACK_INVOCATION_HEADER`, reported by the operator off the returned
+  copy). This is the other half, and only the consuming instance can see it, so both
+  SDKs publish it: `DURABLE_CALLBACK_ERROR_HEADER`, carrying the emitting node, the
+  declaration name and the error's **message** — not its stack, which belongs in the
+  service's log — cut at 500 characters at the source as well as in the update
+  schema.
+
+  It rides the ordinary result exchange with **no correlation id and no index**,
+  exactly like a surface interaction failure and a resume announcement: the handler
+  ran for no dispatch, so it has no message to be a result FOR, and every other arm
+  of the result path would have failed the emitting node for a callback the graph
+  chose to call.
+
+  The operator turns it into a `NODE_DEBUG` on that node — `severity: 'system'`
+  because the operator is speaking, `event: null` because nothing was re-sent and no
+  run ended. The node lookup, the "nowhere to report" arm and the update's shape are
+  shared with the undelivered path through one `reportCallbackOnNode`, since only the
+  sentence differs. Every failure of that lookup stays "nowhere to report": a run can
+  end while an invocation of it is still in flight, and a throw escaping there nacks a
+  delivery at the head of a single-active-consumer FIFO queue, where it wedges every
+  task on that shard.
+
+  **This makes a failure visible, not catchable.** The graph called the callback and
+  moved on long before the handler ran, so there is no call site left to throw at. A
+  callback is still `(arg) => void` in the call direction.
+
 ## 0.8.2
 
 ### Patch Changes

package/build/index.js

@@ -2008,7 +2008,7 @@ function createConnection({
       clientProperties: {
         ...connectionOptions?.clientProperties,
         ...buildServiceClientProperties({
-          libVersion: "javascript@0.8.3-edge.1191",
+          libVersion: "javascript@0.8.4-edge.1197",
           serviceVersion: version,
           connectionId,
           prefetch,
@@ -2569,7 +2569,7 @@ function createConnection({
           begin: true,
           epoch,
           ...buildServiceIdentityHeaders({
-            libVersion: "javascript@0.8.3-edge.1191",
+            libVersion: "javascript@0.8.4-edge.1197",
             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=8CEE2F38CC05117264756E2164756E21
+//# debugId=59535360ADC9F22B64756E2164756E21
 //# sourceMappingURL=index.js.map