@requence/service 0.8.2-edge.1156 → 0.8.2-edge.1159

package/build/types/helpers/src/protocol/index.d.ts

@@ -1,6 +1,7 @@
 export * from './clientProperties.ts';
 export * from './command.ts';
 export * from './configurationScript.ts';
+export * from './logicExecutionTime.ts';
 export * from './logicLanguages.ts';
 export * from './loopDetection.ts';
 export * from './nodeType.ts';

package/build/types/helpers/src/protocol/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA"}

package/build/types/helpers/src/protocol/logicExecutionTime.d.ts

@@ -0,0 +1,22 @@
+import type { TemplateTree } from './templateNodeTypes.ts';
+/**
+ * Floor for a logic node's `maxExecutionTime`, in milliseconds. The ceiling is
+ * deployment-dependent (`env.MAX_LOGIC_EXECUTION_TIME`), so it is always passed
+ * in rather than declared here.
+ */
+export declare const MIN_LOGIC_EXECUTION_TIME = 100;
+export interface LogicExecutionTimeError {
+    detail: string;
+    nodeId: string;
+}
+/**
+ * Range check for every logic node's max execution time, shared by the backend
+ * save-time check (`validateTemplateTree`) and the frontend's live canvas
+ * monitor so the bound and the wording cannot drift apart.
+ *
+ * `max: null` means the ceiling is not known — the frontend before its meta
+ * query resolves — and only the floor is checked then; checking against the
+ * placeholder would flag every logic node in the graph.
+ */
+export declare function validateLogicExecutionTime(templateTree: TemplateTree, max: number | null): LogicExecutionTimeError[];
+//# sourceMappingURL=logicExecutionTime.d.ts.map

package/build/types/helpers/src/protocol/logicExecutionTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logicExecutionTime.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/logicExecutionTime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAE1D;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAE3C,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,EAC1B,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,uBAAuB,EAAE,CAmC3B"}

package/build/types/helpers/src/utils/requenceCallback.d.ts

@@ -1,17 +1,167 @@
 import { z } from 'zod/v4';
-declare const callbackObjectSchema: z.ZodObject<{
-    sourceId: z.ZodString;
+/**
+ * The reference tag of a **callback** — a function a service emitted alongside
+ * its data, which a downstream node may invoke back at the emitting service.
+ *
+ * One tag, not one per lifetime: what a consumer receives is an invokable
+ * function either way, and the position it addresses in the node's declared
+ * output schema is the same. Deliberately still separate from a
+ * `RequenceHandler` (`surfaceHandler.ts` says why in both directions).
+ */
+export declare const REQUENCE_CALLBACK_TAG = "RequenceCallback";
+/**
+ * How long a callback can be reached, decided by **where the function was
+ * written** — the same rule surfaces established for handler props (#59), and
+ * the only thing that actually bounds the closure's life:
+ *
+ * - `connection` — a function written inline in the handler. It closes over the
+ *   running message, so only that process can serve it and it dies when the
+ *   delivery settles. Addressed by the registering connection plus an id in its
+ *   registry.
+ * - `durable` — a function declared once at module scope with
+ *   `createDurableCallback`, addressed by the stable name it was declared under
+ *   and carrying the per-emission data the author *bound* to it instead of
+ *   capturing. It names no connection at all, so any instance of the service
+ *   version can run it, now or after a redeploy (#147).
+ *
+ * `outputName`/`propertyPath` ride on every arm. The durable arm does not need
+ * them to be *routed*, but they are what the operator's existing invocation-
+ * argument validation addresses — same reasoning as `uiId`/`path` on both
+ * surface-handler arms.
+ */
+declare const callbackObjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    __REQUENCE_type: z.ZodLiteral<"RequenceCallback">;
+    lifetime: z.ZodLiteral<"connection">;
     outputName: z.ZodNullable<z.ZodString>;
     propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    sourceId: z.ZodString;
     callbackId: z.ZodUUID;
+}, z.core.$strip>, z.ZodObject<{
     __REQUENCE_type: z.ZodLiteral<"RequenceCallback">;
-}, z.core.$strip>;
+    lifetime: z.ZodLiteral<"durable">;
+    outputName: z.ZodNullable<z.ZodString>;
+    propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    name: z.ZodString;
+    nodeId: z.ZodString;
+    bound: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>], "lifetime">;
 export type CallbackObject = z.infer<typeof callbackObjectSchema>;
+export type CallbackLifetime = CallbackObject['lifetime'];
 export declare function isCallbackObject(data: unknown): data is CallbackObject;
 export type RequenceCallback<T> = (arg: T) => void;
 export type WrappedRequenceCallback<T> = RequenceCallback<T> & {
     response(): Promise<T>;
 };
 export declare function createCallback<T>(callback?: (arg: T) => void): WrappedRequenceCallback<T>;
+/**
+ * What a `.for(bound)` reference carries before the boundary completes it: the
+ * declaration's name and the data bound to this emission. The position
+ * (`outputName`/`propertyPath`) is added where it is known — the value walk —
+ * exactly as it is for the connection arm.
+ */
+export interface DurableCallbackBinding {
+    readonly name: string;
+    readonly bound: unknown;
+}
+/**
+ * Mints the value an author emits in place of a closure — the thing
+ * `createDurableCallback(...).for(bound)` returns (#147).
+ *
+ * It is a **function** carrying the binding on a symbol, rather than the wire
+ * object it will become, for two reasons that both come from the transformer:
+ *
+ * - The egress walk only offers *complex* values to a handler, and a plain
+ *   object is traversable structure — a literal reference would be walked
+ *   straight through and emitted without the `outputName`/`propertyPath` the
+ *   operator validates against, which no schema parse downstream would accept.
+ *   A function is complex, and the callback handler already claims every one.
+ * - The walk memoizes object-identity values at their *first* path, so one
+ *   reference reused at two positions would carry the wrong `propertyPath` for
+ *   the second. Functions bypass that memo by design.
+ *
+ * It also matches the type it is cast to: the property a consumer reads is
+ * declared `RequenceCallback<Arg>`, and a consumer calls it. Calling it *here*,
+ * in the emitting service, is the author's mistake — a durable callback runs
+ * where the invocation is delivered, never inline — so it says so rather than
+ * doing nothing.
+ */
+export declare function createDurableCallbackReference<Arg>(binding: DurableCallbackBinding): RequenceCallback<Arg>;
+/**
+ * The binding a value carries, or `undefined` when it is an ordinary function —
+ * which is how the callback handler tells the two lifetimes apart on egress.
+ */
+export declare function readDurableCallbackBinding(value: unknown): DurableCallbackBinding | undefined;
+/**
+ * The per-version **callbacks queue**: where a durable invocation waits until
+ * some instance of that service version consumes it.
+ *
+ * Derived from the version's dispatch queue rather than composed from the
+ * service and version names, for the reason `serviceHandlerQueueName` is: the
+ * two can then never drift, and a dev-overlay connection — which consumes a
+ * rewritten dispatch queue — gets a callbacks queue of its own for free.
+ */
+export declare function serviceCallbackQueueName(dispatchQueue: string): string;
+export declare function isDevOverlayCallbackQueue(queueName: string): boolean;
+/**
+ * How long a durable invocation may wait in the callbacks queue before the
+ * broker drops it.
+ *
+ * The queue is **not a mailbox**. A callback invoked today and run whenever
+ * somebody next deploys is the silent-effect outcome #116 removed for surfaces,
+ * and it is worse here: nothing checks reachability before a graph calls
+ * `context.input.delete()`, so the TTL is the only bound there is. All it has to
+ * bridge is a rolling redeploy, a scale-to-zero that started a moment ago or a
+ * replica that took the invocation and died — the same seconds the surface
+ * handler queue bridges, hence the same number.
+ *
+ * Expiry is not a drop: the queue dead-letters to `error`, so an expired
+ * invocation comes back to the operator carrying its own task and is reported on
+ * the node the callback belongs to.
+ */
+export declare const DURABLE_CALLBACK_INVOCATION_TTL_MS = 60000;
+/**
+ * The callbacks queue's declaration arguments, as **one** object, because two
+ * parties declare that queue — ui/backend's provisioner and the service SDK on
+ * connect — and a broker answers a mismatch with a 406 that kills the declaring
+ * channel. Anything short of a shared literal is a service that will not start.
+ *
+ * Note for whoever changes this: declaring a queue with a dead-letter exchange
+ * needs WRITE permission on that exchange, so the service AMQP user is granted
+ * it (`assertService`). It costs nothing — `error` is an internal exchange and
+ * the broker refuses a client publish to one however the permissions read.
+ */
+export declare const DURABLE_CALLBACK_QUEUE_ARGUMENTS: {
+    readonly messageTtl: 60000;
+    readonly deadLetterExchange: 'error';
+};
+/**
+ * The header a durable callback invocation is stamped with, for the same reason
+ * a durable surface handler invocation carries one
+ * (`SURFACE_HANDLER_INVOCATION_HEADER`): it is published `mandatory` into the
+ * `service` exchange, so one whose queue is gone comes back to the operator
+ * looking like any other undeliverable service message — and every other arm
+ * there fails the node.
+ *
+ * A callback the graph chose to call is not the node's failure, so this is what
+ * tells that consumer to *report* instead. A header rather than the routing key's
+ * `-callbacks` suffix, which a service actually named `…-callbacks` would forge.
+ */
+export declare const DURABLE_CALLBACK_INVOCATION_HEADER = "durableCallbackInvocation";
+/**
+ * One durable callback invocation, as it travels on the queue above.
+ *
+ * `name` is the whole address: the consuming instance looks it up in the
+ * process-global registry `createDurableCallback` writes and calls what it
+ * finds. Everything else is either the handler's arguments or the way back.
+ */
+export declare const durableCallbackInvocationSchema: z.ZodObject<{
+    taskId: z.ZodUUID;
+    nodeId: z.ZodString;
+    name: z.ZodString;
+    bound: z.ZodOptional<z.ZodUnknown>;
+    arg: z.ZodOptional<z.ZodUnknown>;
+    configuration: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type DurableCallbackInvocation = z.infer<typeof durableCallbackInvocationSchema>;
 export {};
 //# sourceMappingURL=requenceCallback.d.ts.map

package/build/types/helpers/src/utils/requenceCallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requenceCallback.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/requenceCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,QAAA,MAAM,oBAAoB;;;;;;iBAMxB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAEtE;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;AAClD,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG;IAC7D,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;CACvB,CAAA;AAED,wBAAgB,cAAc,CAAC,CAAC,EAC9B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,GAC1B,uBAAuB,CAAC,CAAC,CAAC,CAa5B"}
+{"version":3,"file":"requenceCallback.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/requenceCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qBAAqB,CAAA;AAIvD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;+BAoDxB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC,UAAU,CAAC,CAAA;AAEzD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAEtE;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;AAClD,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG;IAC7D,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;CACvB,CAAA;AAED,wBAAgB,cAAc,CAAC,CAAC,EAC9B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,GAC1B,uBAAuB,CAAC,CAAC,CAAC,CAa5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAWD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAChD,OAAO,EAAE,sBAAsB,GAC9B,gBAAgB,CAAC,GAAG,CAAC,CAmBvB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,sBAAsB,GAAG,SAAS,CAYpC;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEtE;AAiBD,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kCAAkC,QAAS,CAAA;AAExD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gCAAgC;aAC3C,UAAU;aACV,kBAAkB,EAAE,OAAO;CACnB,CAAA;AAEV;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kCAAkC,8BAA8B,CAAA;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;;;;;iBAkC1C,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAA"}

package/build/types/service/src/boundary.d.ts

@@ -21,6 +21,15 @@ export interface OutboundBoundaryOptions {
      * answer for the deferred path, which has no dispatch to echo.
      */
     wireCodec?: WireCodec;
+    /**
+     * The node this boundary emits for, as the operator dispatched it
+     * (`options.nodeId`, and the defer key on the `act()` path).
+     *
+     * Constant for the whole message, which is why it sits here rather than in
+     * `OutboundSendOptions`: it is the address a **durable** callback reference is
+     * routed and configured by (#150), not something one emission decides.
+     */
+    nodeId?: string;
     signal?: AbortSignal;
     fetch?: typeof globalThis.fetch;
     /** Sink for best-effort degradation notices. Defaults to `logger.warn`. */

package/build/types/service/src/boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../../src/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAI1D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAA;AACtE,OAAO,EAAqB,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAcjE,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;AAE3D,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,2EAA2E;IAC3E,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;CAC9C;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,0EAA0E;IAC1E,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAA;IAChD;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,2BAA2B,CAAC,kBAAkB,CAAC,CAAA;IAClE;;;OAGG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACjE,oEAAoE;IACpE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IACtC;;;;;OAKG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,uBAAuB,GAC5B,gBAAgB,CAoGlB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,kEAAkE;IAClE,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;IAC7D;;;;OAIG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;CAC5E;AAED,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,CAAC,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;CAC9D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,sBAA2B,UAE7D,OAAO,SACP,qBAAqB,KAC1B,OAAO,CAAC,OAAO,CAAC,CAiBpB"}
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../../../src/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAI1D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAA;AACtE,OAAO,EAAqB,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAcjE,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;AAE3D,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,2EAA2E;IAC3E,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;CAC9C;AAED,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,0EAA0E;IAC1E,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAA;IAChD;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,2BAA2B,CAAC,kBAAkB,CAAC,CAAA;IAClE;;;OAGG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACjE,oEAAoE;IACpE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IACtC;;;;;OAKG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,uBAAuB,GAC5B,gBAAgB,CAqGlB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,kEAAkE;IAClE,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;IAC7D;;;;OAIG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAA;CAC5E;AAED,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,CAAC,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAA;CAC9D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,GAAE,sBAA2B,UAE7D,OAAO,SACP,qBAAqB,KAC1B,OAAO,CAAC,OAAO,CAAC,CAiBpB"}

package/build/types/service/src/callbackGrowth.d.ts

@@ -0,0 +1,102 @@
+import type { TransformPath } from '@requence/transformer';
+/**
+ * Where the first warning lands under a **dev overlay**.
+ *
+ * Deliberately low, and that is the point of the whole feature (#151): a hundred
+ * emissions in a `bun run dev` session already means a generator is minting
+ * closures in a loop, and catching it there is worth far more than catching it in
+ * production. A one-shot fan-out never reaches it.
+ */
+export declare const DEV_OVERLAY_FIRST_WARNING = 100;
+/**
+ * Where the first warning lands for a **deployed** version.
+ *
+ * A thousand entries is ~200 KB of registry — well below any real concern, and
+ * far above any legitimate one-shot fan-out. It is the step count, not this
+ * number, that makes the growth visible.
+ */
+export declare const DEPLOYED_FIRST_WARNING = 1000;
+export interface CallbackGrowthOptions {
+    /**
+     * How this service names itself in a log line — `<service>@<version>`, the
+     * dispatch queue's own name, so the line matches what the deployment calls it.
+     */
+    readonly service: string;
+    /** A dev overlay warns ten times earlier. See {@link DEV_OVERLAY_FIRST_WARNING}. */
+    readonly devOverlay: boolean;
+    /**
+     * The live size of the **connection's** registry.
+     *
+     * Read rather than counted, so it includes everything the connection holds —
+     * other deliveries' callbacks and rendered handler props alike — and shrinks
+     * when a delivery settles. Read *after* the registration that prompted it, so
+     * the number in the warning is the number the process is holding.
+     */
+    readonly connectionCount: () => number;
+    /**
+     * Where a crossing goes: the running service's own log, and nothing else.
+     *
+     * This warning is for the person writing the service, in the terminal they are
+     * writing it in. It is not a task event — nobody watching a run can act on it,
+     * and the author is the only one who can.
+     */
+    readonly warn: (message: string) => void;
+}
+export interface DeliveryGrowthOptions {
+    /** The task this delivery belongs to, so the warning can be traced to a run. */
+    readonly taskId: string;
+}
+export interface DeliveryGrowth {
+    /**
+     * One **connection-bound** registration, at the position it was written.
+     * Called after the entry is in the registry, so the connection count a warning
+     * states is the number the process is holding.
+     *
+     * A durable reference never reaches it: it registers nothing, so there is
+     * nothing to count and nothing to warn about.
+     */
+    record(path: TransformPath): void;
+}
+export interface CallbackGrowthWatch {
+    /** A recorder for one delivery, whose counter is its own. */
+    forDelivery(options: DeliveryGrowthOptions): DeliveryGrowth;
+}
+/**
+ * Tells the author of a service whose inline closures are piling up — and tells
+ * them **which `yield`** is doing it (#151).
+ *
+ * Shipping `createDurableCallback` does not stop anyone writing an inline closure
+ * in a generator, and that is still the easier thing to write. This warning is
+ * therefore also the migration path: it is what moves existing services over,
+ * with no deprecation and no dual code path.
+ *
+ * It goes to the **service's own log** and nowhere else. It is not a task event:
+ * the only person who can act on it is the one writing the service, and putting
+ * it on a run would show it to everyone who cannot.
+ *
+ * **Two counters**, because they answer different questions and both are O(1):
+ *
+ * - **per delivery** — identifies the one generator doing it. This is the
+ *   teaching signal, and it is what the property paths belong to.
+ * - **per connection** — what actually threatens the process: a worker holding
+ *   fifty concurrent tasks at nine hundred callbacks each is at forty-five
+ *   thousand without any single delivery tripping its own threshold.
+ *
+ * Both are stated in one warning, and a registration that crosses both emits it
+ * **once** — a fresh connection running one generator crosses them on the same
+ * registration, and two near-identical warnings would read as a bug in the
+ * warning rather than as a bug in the service.
+ *
+ * **Steps, not a line per registration**, which would be a line per email: the
+ * crossing, then each power of ten above it. A threshold jumps straight past a
+ * count it is already below, so a connection that arrives at forty-five thousand
+ * says so once rather than climbing there one decade per registration.
+ *
+ * **No cap and no eviction.** A hard cap is the rejected bounded-registry
+ * alternative wearing a different hat: it kills a legitimate long-lived handle at
+ * an arbitrary number, the author cannot exempt one, and it becomes a tuning knob
+ * nobody can set correctly. Loud and degrading beats silent and truncating — so
+ * nothing here refuses a registration or returns anything a caller could act on.
+ */
+export declare function createCallbackGrowthWatch({ service, devOverlay, connectionCount, warn, }: CallbackGrowthOptions): CallbackGrowthWatch;
+//# sourceMappingURL=callbackGrowth.d.ts.map

package/build/types/service/src/callbackGrowth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbackGrowth.d.ts","sourceRoot":"","sources":["../../../../src/callbackGrowth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAG1D;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,OAAQ,CAAA;AAK3C,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,oFAAoF;IACpF,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,MAAM,CAAA;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CACzC;AAED,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAAA;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC,6DAA6D;IAC7D,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAAA;CAC5D;AAiED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,OAAO,EACP,UAAU,EACV,eAAe,EACf,IAAI,GACL,EAAE,qBAAqB,GAAG,mBAAmB,CA2C7C"}

package/build/types/service/src/createAmqpConnection.d.ts

@@ -90,6 +90,7 @@ export declare const messageKeySchema: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString
     streamUrl: string | undefined;
     maxPayloadSize: number | undefined;
     maxFileSize: number | undefined;
+    nodeId: string | undefined;
 }, [string, string, ...string[]]>>;
 export declare const connectionOptionsSchema: z.ZodObject<{
     url: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>;

package/build/types/service/src/createAmqpConnection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createAmqpConnection.d.ts","sourceRoot":"","sources":["../../../../src/createAmqpConnection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"createAmqpConnection.d.ts","sourceRoot":"","sources":["../../../../src/createAmqpConnection.ts"],"names":[],"mappings":"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"}

package/build/types/service/src/durableCallback.d.ts

@@ -0,0 +1,223 @@
+import type { RequenceCallback } from '../../helpers/src/index.js';
+/**
+ * The node configuration a durable callback is handed, named **either way**:
+ * write the type, or write the name of the service **version** it belongs to
+ * and have it looked up.
+ *
+ * ```ts
+ * ConfigurationOf<ImapOptions>  // → ImapOptions
+ * ConfigurationOf<'receiver'>   // → the `receiver` version's configuration
+ * ```
+ *
+ * The version-name form is the one to prefer: the type is generated into
+ * `requence-env.d.ts` beside the version it belongs to, so naming the version
+ * is the only form that cannot drift from what the node actually sends.
+ *
+ * A name that matches no version resolves to **itself**, which is deliberate
+ * rather than an oversight: a typo then fails at the first use with the
+ * misspelling quoted in the error (`Property 'host' does not exist on type
+ * '"recevier"'`), which says more than a `never` would — and it leaves a
+ * service whose configuration genuinely is a string alone.
+ *
+ * `Versions` exists only so this is testable. The SDK's own `global.d.ts`
+ * declares `RequenceService.Version` **empty** — a generated
+ * `requence-env.d.ts` is what fills it in a service's package — and merging a
+ * version into it from inside this package breaks the SDK's own generics, which
+ * only compile because the table has no keys. So the table is a defaulted
+ * parameter rather than a hard reference, and nobody passes it.
+ */
+export type ConfigurationOf<T, Versions = RequenceService.Version> = T extends keyof Versions ? Versions[T] extends {
+    configuration: infer C;
+} ? C : unknown : T;
+/**
+ * The one key a durable callback may not bind, because the context already has
+ * it.
+ *
+ * There is exactly one, and it is checked rather than worked around: a
+ * precedence rule ("configuration wins", "bound wins") would mean an author's
+ * data silently disappearing or a node's credentials silently replaced, and
+ * neither is something a reader of the handler could see.
+ */
+declare const RESERVED_CONTEXT_KEY = "configuration";
+/**
+ * What a durable callback is told about the invocation it is running — and
+ * deliberately all of it (#147).
+ *
+ * There is no message here, no task, no connection. That is exactly what makes
+ * a durable callback durable: it may run in an instance that never saw the
+ * emission, started after the emitting process died. What it does get is the
+ * two things that survive that:
+ *
+ * - the bound data itself, spread across the context — what the emitting
+ *   handler attached at `.for(…)` in place of capturing it.
+ * - `configuration` — the node's **static** configuration, so the callback can
+ *   rebuild whatever the emitting handler had open (an IMAP connection, an API
+ *   client) rather than hold it.
+ *
+ * The bound data is spread rather than parked under a field of its own, so
+ * there is no second word to keep consistent with `.for(…)`:
+ * `deleteMail.for({ uid })` is read as `{ uid }`. The cost is the one reserved
+ * key above, and it is a compile error and a throw rather than a shadow.
+ *
+ * Computed configuration (`configurationFunctions`, evaluated per dispatch) is
+ * not available: it is a property of one dispatch, and this call belongs to
+ * none.
+ */
+export type DurableCallbackContext<Bound, Configuration> = Bound extends object ? Bound & {
+    readonly configuration: Configuration;
+} : {
+    readonly configuration: Configuration;
+};
+/**
+ * The bound data as `.for(…)` takes it: the declared shape, minus the one key
+ * the context has already spent.
+ *
+ * A `void` binding passes through untouched rather than intersected, which is
+ * what keeps `notify.for()` callable with no argument at all.
+ */
+export type Bindable<Bound> = Bound extends object ? Bound & {
+    [K in typeof RESERVED_CONTEXT_KEY]?: never;
+} : Bound;
+/**
+ * The author's function.
+ *
+ * `arg` comes first because it is the *consumer's* half — what a downstream
+ * node passed when it called `context.input.delete(…)`, and the only parameter
+ * the emitted `RequenceCallback<Arg>` declares. Everything the emitting service
+ * put there is the context, because from the running callback's point of view
+ * the bound data and the node's configuration are the same kind of thing: what
+ * this invocation was given, none of it written here.
+ */
+export type DurableCallbackHandler<Arg, Bound, Configuration> = (arg: Arg, context: DurableCallbackContext<Bound, Configuration>) => unknown;
+/**
+ * A callback declared once at module scope, and what to do with it.
+ */
+export interface DurableCallbackHandle<Arg, Bound> {
+    /** The stable address this was declared under. */
+    readonly name: string;
+    /**
+     * Binds this emission's data and returns the value to emit — a reference
+     * naming the declaration and carrying the data, not a closure over it.
+     *
+     * Typed as the `RequenceCallback<Arg>` a consumer receives, because that is
+     * what the position in the node's output schema declares and what a downstream
+     * logic node holds. The value is not callable here: a durable callback runs
+     * where its invocation is delivered.
+     */
+    for(bound: Bindable<Bound>): RequenceCallback<Arg>;
+}
+/**
+ * What {@link createDurableCallback} hands back.
+ *
+ * With nothing to bind (`Bound` at its `void` default) the declaration **is**
+ * the value to emit, so `.for()` can be left off entirely:
+ *
+ * ```ts
+ * yield { subject: mail.subject, acknowledge }        // no binding
+ * yield { delete: deleteMail.for({ uid: mail.uid }) } // a binding
+ * ```
+ *
+ * That is not a special case at runtime — the handle is a reference that bound
+ * nothing, which is exactly what `.for()` would have produced. It is the type
+ * that is careful: the call signature appears **only** when `Bound` is `void`,
+ * so a callback that needs a binding cannot be emitted without one. Without
+ * that gate the omission would compile and the handler would destructure
+ * `undefined` off a context that was never given its data.
+ */
+export type DurableCallback<Arg, Bound> = Bound extends void ? DurableCallbackHandle<Arg, Bound> & RequenceCallback<Arg> : DurableCallbackHandle<Arg, Bound>;
+interface Registration {
+    handler: DurableCallbackHandler<any, any, any>;
+}
+/**
+ * Declares a callback **once**, so what a service emits per message is a
+ * reference rather than a closure (#147).
+ *
+ * ```ts
+ * const deleteMail = createDurableCallback<void, { uid: string }, 'receiver'>(
+ *   'deleteMail',
+ *   async (_arg, { uid, configuration }) => {
+ *     const client = await connect(configuration) // rebuilt, never captured
+ *     await client.messageDelete(uid)
+ *     client.close()
+ *   },
+ * )
+ *
+ * createService('receiver', async function* () {
+ *   for await (const mail of mails) {
+ *     yield { subject: mail.subject, delete: deleteMail.for({ uid: mail.uid }) }
+ *   }
+ * })
+ * ```
+ *
+ * A callback with nothing to bind is emitted as itself — see
+ * {@link DurableCallback}:
+ *
+ * ```ts
+ * const acknowledge = createDurableCallback('acknowledge', async () => …)
+ *
+ * yield { subject: mail.subject, acknowledge }
+ * ```
+ *
+ * **Where you write the function decides how long it lives** — the rule surfaces
+ * established for handler props (#59). A function written inline in the handler
+ * closes over the running message: only that process can serve it, it dies when
+ * the delivery settles, and until then it is held in the connection's registry
+ * along with everything it captured. For a CONTINUOUS handler that is one
+ * delivery holding a generator for the life of the task, so the registry grows
+ * by one entry per emitted function per emission and nothing frees it for weeks.
+ * Declared here instead, there is one entry per declaration however many
+ * messages go by, and an invocation can be served by an instance started after
+ * the emitting one died.
+ *
+ * Write it inline when it genuinely needs the live process — a handle on an open
+ * stream, a client the handler is mid-conversation with. Declare it here when it
+ * needs only data, and bind that data with `.for(…)`.
+ *
+ * The three type arguments are the three things the two sides disagree about,
+ * in the order the *reader* meets them:
+ *
+ * 1. `Arg` — what a consumer passes. This is the emitted
+ *    `RequenceCallback<Arg>`, so it is what the node's output schema declares.
+ *    Defaults to `void`: a callback the graph calls with nothing.
+ * 2. `Bound` — what `.for(…)` attaches per emission, and what the handler's
+ *    context is made of. An object (it is spread) or `void`, which lets the
+ *    declaration be emitted with no `.for()` at all. A scalar is refused,
+ *    because a spread has nowhere to put one.
+ * 3. `Configuration` — the node's configuration, given as a type **or** as the
+ *    name of the version to look it up from ({@link ConfigurationOf}).
+ *
+ * `Configuration` does not infer from an annotated handler, because it is
+ * resolved through a conditional type. Naming the version is both shorter and
+ * the only form that cannot drift, so state all three.
+ *
+ * A second declaration under the same name **throws**, for the reason a
+ * duplicate `createUI` id does: the name is the whole address, so an ambiguous
+ * one is an invocation reaching the *wrong* handler — which reads like a bug in
+ * the handler — and that is worse than a service that refuses to start.
+ */
+export declare function createDurableCallback<Arg = void, Bound extends object | void = void, Configuration = unknown>(name: string, handler: DurableCallbackHandler<Arg, Bound, ConfigurationOf<Configuration>>): DurableCallback<Arg, Bound>;
+/**
+ * The callback a durable invocation names, or `undefined` when this process
+ * declared none under that name.
+ */
+export declare function findDurableCallback(name: string): Registration | undefined;
+/**
+ * The context an invocation runs against: its bound data, with the node's
+ * configuration beside it.
+ *
+ * Built here rather than at the consume site so the reserved-key check and the
+ * spread stay in one place — `bound` comes off the wire as `unknown`, so this is
+ * the second party that has to enforce what {@link DurableCallback.for} enforced
+ * on the way out. Another SDK, or a hand-published invocation, has not been
+ * through that.
+ */
+export declare function durableCallbackContext(name: string, bound: unknown, configuration: unknown): Record<string, unknown>;
+/**
+ * How many callbacks this process has declared.
+ *
+ * Not exported from the package: it exists so the invariant the feature is for —
+ * one entry per declaration, whatever the emission count — is assertable.
+ */
+export declare function durableCallbackCount(): number;
+export {};
+//# sourceMappingURL=durableCallback.d.ts.map

package/build/types/service/src/durableCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durableCallback.d.ts","sourceRoot":"","sources":["../../../../src/durableCallback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,eAAe,CACzB,CAAC,EACD,QAAQ,GAAG,eAAe,CAAC,OAAO,IAChC,CAAC,SAAS,MAAM,QAAQ,GACxB,QAAQ,CAAC,CAAC,CAAC,SAAS;IAAE,aAAa,EAAE,MAAM,CAAC,CAAA;CAAE,GAC5C,CAAC,GACD,OAAO,GACT,CAAC,CAAA;AAEL;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,kBAAkB,CAAA;AA6B5C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,sBAAsB,CAAC,KAAK,EAAE,aAAa,IAAI,KAAK,SAAS,MAAM,GAC3E,KAAK,GAAG;IAAE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;CAAE,CAAA;AAE7C;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,IAAI,KAAK,SAAS,MAAM,GAC9C,KAAK,GAAG;KAAG,CAAC,IAAI,OAAO,oBAAoB,CAAC,CAAC,EAAE,KAAK;CAAE,GACtD,KAAK,CAAA;AAET;;;;;;;;;GASG;AACH,MAAM,MAAM,sBAAsB,CAAC,GAAG,EAAE,KAAK,EAAE,aAAa,IAAI,CAC9D,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,sBAAsB,CAAC,KAAK,EAAE,aAAa,CAAC,KAClD,OAAO,CAAA;AAEZ;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,GAAG,EAAE,KAAK;IAC/C,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;;;;;;OAQG;IACH,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAA;CACnD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,CAAC,GAAG,EAAE,KAAK,IAAI,KAAK,SAAS,IAAI,GACxD,qBAAqB,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,GACzD,qBAAqB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AAErC,UAAU,YAAY;IACpB,OAAO,EAAE,sBAAsB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CAC/C;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,GAAG,IAAI,EACV,KAAK,SAAS,MAAM,GAAG,IAAI,GAAG,IAAI,EAClC,aAAa,GAAG,OAAO,EAEvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,sBAAsB,CAAC,GAAG,EAAE,KAAK,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC,GAC1E,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,CAwB7B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAE1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,aAAa,EAAE,OAAO,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGzB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/build/types/service/src/helpers.d.ts

@@ -50,11 +50,12 @@ export default function createContextHelper(options: {
     passthroughByteReferences?: boolean;
     onLog: (method: 'log' | 'warn' | 'info' | 'error', data: any[]) => void;
     onDefer: (reason?: string) => string;
-    onCallback: (params: {
-        sourceId: string;
-        callbackId: string;
-        outputName: string | null;
-        propertyPath: (string | number)[];
+    /**
+     * Dispatches an invocation of a callback the handler received in its input.
+     * Takes the whole reference — both lifetimes ride the one tag (#147) and only
+     * the caller knows how to route each arm.
+     */
+    onCallback: (payload: CallbackObject & {
         arg: unknown;
     }) => void;
     onRender: (params: {