@requence/service 0.8.3-edge.1190 → 0.8.3

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

@@ -205,8 +205,9 @@ function isCallbackObject(data) {
 function createCallback(callback) {
   const { promise, resolve: resolve2 } = Promise.withResolvers();
   const executor = (arg) => {
-    resolve2(arg);
-    callback?.(arg);
+    const value = arg === undefined ? null : arg;
+    resolve2(value);
+    callback?.(value);
   };
   return Object.assign(executor, {
     response() {
@@ -251,6 +252,13 @@ var durableCallbackInvocationSchema = z5.object({
   arg: z5.unknown().optional(),
   configuration: z5.unknown().optional()
 });
+var MAX_DURABLE_CALLBACK_ERROR_CHARS = 500;
+var DURABLE_CALLBACK_ERROR_HEADER = "durableCallbackError";
+var durableCallbackErrorReportSchema = z5.object({
+  nodeId: z5.string(),
+  name: z5.string(),
+  message: z5.string()
+});
 
 // ../helpers/src/utils/serviceRender.ts
 import { z as z6 } from "zod/v4";
@@ -1084,7 +1092,7 @@ function createRequenceCallbackHandler() {
     },
     isReference: (value) => isCallbackObject(value),
     deserialize(ref, ctx) {
-      return (arg) => {
+      return (arg = null) => {
         ctx.onCallbackInvoke?.({ ...ref, arg });
       };
     }
@@ -2000,7 +2008,7 @@ function createConnection({
       clientProperties: {
         ...connectionOptions?.clientProperties,
         ...buildServiceClientProperties({
-          libVersion: "javascript@0.8.3-edge.1190",
+          libVersion: "javascript@0.8.3",
           serviceVersion: version,
           connectionId,
           prefetch,
@@ -2142,6 +2150,28 @@ function createConnection({
       simple_default.error(`Requence: could not report a failed surface interaction on |${params.surface}|:`, error instanceof Error ? error.message : error);
     });
   };
+  const reportCallbackFailure = (payload, error) => {
+    const parsed = durableCallbackInvocationSchema.safeParse(payload);
+    if (!parsed.success) {
+      simple_default.error("Requence: cannot report a failed durable callback — the invocation names no task and node");
+      return;
+    }
+    const { taskId, nodeId, name: name2 } = parsed.data;
+    channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify({
+      nodeId,
+      name: name2,
+      message: (error instanceof Error ? error.message : String(error)).slice(0, MAX_DURABLE_CALLBACK_ERROR_CHARS)
+    })), {
+      contentType: "application/json",
+      persistent: true,
+      headers: {
+        taskId,
+        [DURABLE_CALLBACK_ERROR_HEADER]: true
+      }
+    }).catch((publishError) => {
+      simple_default.error(`Requence: could not report the failed durable callback |${name2}| of task |${taskId}|:`, publishError instanceof Error ? publishError.message : publishError);
+    });
+  };
   const announceResume = (params) => {
     channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify({ messageId: params.messageId })), {
       correlationId: params.messageId,
@@ -2252,10 +2282,13 @@ function createConnection({
         if (!message) {
           return;
         }
+        let payload;
         try {
-          await runDurableCallbackInvocation(JSON.parse(message.content.toString()));
+          payload = JSON.parse(message.content.toString());
+          await runDurableCallbackInvocation(payload);
         } catch (error) {
           simple_default.error("Requence: durable callback threw:", error instanceof Error ? error.stack ?? error.message : error);
+          reportCallbackFailure(payload, error);
         }
         safeAck(channel, message);
       });
@@ -2536,7 +2569,7 @@ function createConnection({
           begin: true,
           epoch,
           ...buildServiceIdentityHeaders({
-            libVersion: "javascript@0.8.3-edge.1190",
+            libVersion: "javascript@0.8.3",
             name,
             holdsSlot: !(isGeneratorHandler && mode === "CONTINUOUS")
           })
@@ -3107,5 +3140,5 @@ export {
   PayloadTooLargeError
 };
 
-//# debugId=29AC99BF6424ED2964756E2164756E21
+//# debugId=A75FE0293DB162D764756E2164756E21
 //# sourceMappingURL=index.js.map