@lostgradient/weft 0.2.1 → 0.3.0

package/dist/version.d.ts

@@ -9,4 +9,4 @@
  * console.log(`Running Weft ${VERSION}`);
  * ```
  */
-export declare const VERSION = "0.2.1";
+export declare const VERSION = "0.3.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.2.1";
+export const VERSION = "0.3.0";

package/dist/worker/index.js

@@ -225,13 +225,14 @@ export class RemoteWorker {
       this.#failSocket();
       return;
     }
-    const activityFunction = this.#activityTable[task.activityName];
+    const tokenEcho = task.attemptToken !== void 0 ? { attemptToken: task.attemptToken } : {}, activityFunction = this.#activityTable[task.activityName];
     if (activityFunction === void 0) {
       this.#sendTaskResult({
         type: "taskResult",
         operationId: task.operationId,
         status: "failed",
-        error: `Unknown activity: ${task.activityName}`
+        error: `Unknown activity: ${task.activityName}`,
+        ...tokenEcho
       });
       return;
     }
@@ -244,7 +245,8 @@ export class RemoteWorker {
         type: "taskResult",
         operationId: task.operationId,
         status: "completed",
-        value: normalizeWorkerJsonValue(result)
+        value: normalizeWorkerJsonValue(result),
+        ...tokenEcho
       });
     } catch (error) {
       if (taskAbortController.signal.aborted)
@@ -253,14 +255,16 @@ export class RemoteWorker {
           operationId: task.operationId,
           status: "cancelled",
           cancelled: !0,
-          error: "Task cancelled"
+          error: "Task cancelled",
+          ...tokenEcho
         });
       else
         this.#sendTaskResult({
           type: "taskResult",
           operationId: task.operationId,
           status: "failed",
-          error: error instanceof Error ? error.message : String(error)
+          error: error instanceof Error ? error.message : String(error),
+          ...tokenEcho
         });
     } finally {
       this.#taskAbortControllers.delete(task.operationId);

package/dist/worker/long-poll.js

@@ -85,6 +85,7 @@ export class LongPollWorker {
   }
   async#executeTask(task, resultUrl) {
     this.#inFlight += 1;
+    const tokenEcho = task.attemptToken !== void 0 ? { attemptToken: task.attemptToken } : {};
     try {
       const activityFunction = this.#options.activities[task.activityName];
       if (activityFunction === void 0) {
@@ -94,6 +95,7 @@ export class LongPollWorker {
           body: JSON.stringify({
             operationId: task.operationId,
             workerId: task.workerId,
+            ...tokenEcho,
             status: "failed",
             error: `Unknown activity: ${task.activityName}`
           }),
@@ -108,6 +110,7 @@ export class LongPollWorker {
         body: JSON.stringify({
           operationId: task.operationId,
           workerId: task.workerId,
+          ...tokenEcho,
           status: "completed",
           value: result
         }),
@@ -121,6 +124,7 @@ export class LongPollWorker {
           body: JSON.stringify({
             operationId: task.operationId,
             workerId: task.workerId,
+            ...tokenEcho,
             status: "failed",
             error: error instanceof Error ? error.message : String(error)
           }),

package/dist/worker/protocol-messages.d.ts

@@ -100,6 +100,12 @@ export type CompletedTaskResultMessage = {
     readonly operationId: string;
     readonly status: 'completed';
     readonly value: RemoteWorkerJsonValue;
+    /**
+     * The per-dispatch token echoed from the {@link TaskMessage}. Optional on the
+     * wire so older workers still parse, but the server's completion handler
+     * rejects a result whose token does not match the current attempt.
+     */
+    readonly attemptToken?: string;
 };
 /**
  * Failed activity result message.
@@ -121,6 +127,8 @@ export type FailedTaskResultMessage = {
     readonly operationId: string;
     readonly status: 'failed';
     readonly error: string;
+    /** The per-dispatch token echoed from the {@link TaskMessage}. See {@link CompletedTaskResultMessage.attemptToken}. */
+    readonly attemptToken?: string;
 };
 /**
  * Cancelled activity result message.
@@ -144,6 +152,8 @@ export type CancelledTaskResultMessage = {
     readonly status: 'cancelled';
     readonly error: string;
     readonly cancelled?: true;
+    /** The per-dispatch token echoed from the {@link TaskMessage}. See {@link CompletedTaskResultMessage.attemptToken}. */
+    readonly attemptToken?: string;
 };
 /**
  * Registration acknowledgement sent after a worker is accepted.
@@ -224,6 +234,7 @@ export type ProtocolErrorMessage = {
  *   operationId: 'op-1',
  *   activityName: 'sendEmail',
  *   input: { to: 'user@example.com' },
+ *   attemptToken: '550e8400-e29b-41d4-a716-446655440000',
  * };
  * ```
  */
@@ -234,6 +245,15 @@ export type TaskMessage = {
     readonly input: RemoteWorkerJsonValue;
     readonly attempt?: number;
     readonly headers?: Readonly<Record<string, string>>;
+    /**
+     * Unique, unguessable token identifying this specific dispatch attempt. The
+     * current server always stamps one, and the worker must echo it back on the
+     * {@link CompletedTaskResultMessage} (or failed/cancelled variant) so the server
+     * can reject a stale completion from an earlier attempt that was reassigned to
+     * the same worker. Optional on the type because a frame from an older server may
+     * omit it; the worker simply has no token to echo in that case.
+     */
+    readonly attemptToken?: string;
 };
 /**
  * Activity cancellation request sent by the server.

package/dist/worker/protocol-schemas.d.ts

@@ -105,6 +105,10 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                     readonly const: "completed";
                 };
                 readonly value: JsonSchemaObject;
+                readonly attemptToken: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
             };
         }, {
             readonly type: "object";
@@ -124,6 +128,10 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                 readonly error: {
                     readonly type: "string";
                 };
+                readonly attemptToken: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
             };
         }, {
             readonly type: "object";
@@ -146,6 +154,10 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                 readonly cancelled: {
                     readonly const: true;
                 };
+                readonly attemptToken: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
             };
         }];
     };
@@ -171,6 +183,10 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                 readonly minimum: 1;
             };
             readonly headers: JsonSchemaObject;
+            readonly attemptToken: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
         };
     };
     readonly cancel: {
@@ -391,6 +407,10 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                             readonly const: "completed";
                         };
                         readonly value: JsonSchemaObject;
+                        readonly attemptToken: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
                     };
                 }, {
                     readonly type: "object";
@@ -410,6 +430,10 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                         readonly error: {
                             readonly type: "string";
                         };
+                        readonly attemptToken: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
                     };
                 }, {
                     readonly type: "object";
@@ -432,6 +456,10 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                         readonly cancelled: {
                             readonly const: true;
                         };
+                        readonly attemptToken: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
                     };
                 }];
             };
@@ -457,6 +485,10 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                         readonly minimum: 1;
                     };
                     readonly headers: JsonSchemaObject;
+                    readonly attemptToken: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
                 };
             };
             readonly cancel: {

package/dist/worker/protocol-schemas.js

@@ -52,7 +52,8 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
           type: { const: "taskResult" },
           operationId: { type: "string", minLength: 1 },
           status: { const: "completed" },
-          value: jsonValueSchema
+          value: jsonValueSchema,
+          attemptToken: { type: "string", minLength: 1 }
         }
       },
       {
@@ -63,7 +64,8 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
           type: { const: "taskResult" },
           operationId: { type: "string", minLength: 1 },
           status: { const: "failed" },
-          error: { type: "string" }
+          error: { type: "string" },
+          attemptToken: { type: "string", minLength: 1 }
         }
       },
       {
@@ -75,7 +77,8 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
           operationId: { type: "string", minLength: 1 },
           status: { const: "cancelled" },
           error: { type: "string" },
-          cancelled: { const: !0 }
+          cancelled: { const: !0 },
+          attemptToken: { type: "string", minLength: 1 }
         }
       }
     ]
@@ -90,7 +93,8 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
       activityName: { type: "string", minLength: 1 },
       input: jsonValueSchema,
       attempt: { type: "number", minimum: 1 },
-      headers: stringMapSchema
+      headers: stringMapSchema,
+      attemptToken: { type: "string", minLength: 1 }
     }
   },
   cancel: {

package/dist/worker/protocol-task-result.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Parser for the worker-to-server `taskResult` message.
+ *
+ * `taskResult` is a discriminated union over status `completed | failed |
+ * cancelled`. Variant dispatch uses a `satisfies Record<TaskResultStatus, …>`
+ * lookup so adding a new variant becomes a compile-time error. This cluster is
+ * split out of `./protocol.ts` so the canonical parser module stays focused on
+ * the top-level schema-to-guard dispatch a reviewer audits.
+ *
+ * @module worker/protocol-task-result
+ */
+import type { RemoteWorkerProtocolParseResult } from './protocol-internals.ts';
+import type { CancelledTaskResultMessage, CompletedTaskResultMessage, FailedTaskResultMessage } from './protocol-messages.ts';
+/**
+ * Worker-to-server task result message. Discriminated union over `status`.
+ *
+ * @example
+ * ```ts
+ * import type { TaskResultMessage } from '@lostgradient/weft/worker-protocol';
+ *
+ * const message: TaskResultMessage = {
+ *   type: 'taskResult', operationId: 'op-1', status: 'completed', value: { ok: true },
+ * };
+ * ```
+ */
+export type TaskResultMessage = CompletedTaskResultMessage | FailedTaskResultMessage | CancelledTaskResultMessage;
+/** Parse and validate a worker-to-server `taskResult` message into its typed variant. */
+export declare function parseTaskResultMessage(record: Record<string, unknown>): RemoteWorkerProtocolParseResult<TaskResultMessage>;

package/dist/worker/protocol-task-result.js

@@ -0,0 +1,76 @@
+import {
+  isNonEmptyString,
+  isRemoteWorkerJsonValue,
+  protocolFailure
+} from "./protocol-internals.js";
+function parseEchoedAttemptToken(record) {
+  const attemptToken = record.attemptToken;
+  if (attemptToken === void 0)
+    return { ok: !0, message: {} };
+  if (!isNonEmptyString(attemptToken))
+    return protocolFailure("invalid_message", "taskResult.attemptToken must be a non-empty string when present");
+  return { ok: !0, message: { attemptToken } };
+}
+function parseCompletedTaskResult(operationId, record) {
+  const value = record.value;
+  if (!isRemoteWorkerJsonValue(value))
+    return protocolFailure("invalid_message", "completed taskResult.value must be valid JSON");
+  const token = parseEchoedAttemptToken(record);
+  if (!token.ok)
+    return token;
+  return {
+    ok: !0,
+    message: { type: "taskResult", operationId, status: "completed", value, ...token.message }
+  };
+}
+function parseFailedTaskResult(operationId, record) {
+  const error = record.error;
+  if (typeof error !== "string")
+    return protocolFailure("invalid_message", "failed taskResult.error must be a string");
+  const token = parseEchoedAttemptToken(record);
+  if (!token.ok)
+    return token;
+  return {
+    ok: !0,
+    message: { type: "taskResult", operationId, status: "failed", error, ...token.message }
+  };
+}
+function parseCancelledTaskResult(operationId, record) {
+  const error = record.error;
+  if (typeof error !== "string")
+    return protocolFailure("invalid_message", "cancelled taskResult.error must be a string");
+  const cancelled = record.cancelled;
+  if (cancelled !== void 0 && cancelled !== !0)
+    return protocolFailure("invalid_message", "taskResult.cancelled must be true when present");
+  const token = parseEchoedAttemptToken(record);
+  if (!token.ok)
+    return token;
+  return {
+    ok: !0,
+    message: {
+      type: "taskResult",
+      operationId,
+      status: "cancelled",
+      error,
+      ...cancelled === !0 ? { cancelled } : {},
+      ...token.message
+    }
+  };
+}
+const TASK_RESULT_VARIANT_PARSERS = {
+  completed: parseCompletedTaskResult,
+  failed: parseFailedTaskResult,
+  cancelled: parseCancelledTaskResult
+};
+function isTaskResultStatus(value) {
+  return value === "completed" || value === "failed" || value === "cancelled";
+}
+export function parseTaskResultMessage(record) {
+  const operationId = record.operationId;
+  if (!isNonEmptyString(operationId))
+    return protocolFailure("invalid_message", "taskResult.operationId must be a non-empty string");
+  const status = record.status;
+  if (!isTaskResultStatus(status))
+    return protocolFailure("invalid_message", "taskResult.status must be completed, failed, or cancelled");
+  return TASK_RESULT_VARIANT_PARSERS[status](operationId, record);
+}

package/dist/worker/protocol.d.ts

@@ -3,7 +3,8 @@
  *
  * This module owns the parser trust boundary: every guard below maps to one
  * documented schema field. Wire-shape types live in `./protocol-messages.ts`,
- * JSON Schema documents in `./protocol-schemas.ts`, and internal helpers in
+ * JSON Schema documents in `./protocol-schemas.ts`, the `taskResult` variant
+ * parser in `./protocol-task-result.ts`, and internal helpers in
  * `./protocol-internals.ts`. All are re-exported so the public surface
  * `@lostgradient/weft/worker-protocol` stays a single import path.
  *
@@ -13,23 +14,11 @@ import type { RemoteWorkerProtocolFailure, RemoteWorkerProtocolParseResult } fro
 import { isRemoteWorkerJsonValue } from './protocol-internals.ts';
 import type { CancelMessage, CancelledTaskResultMessage, CompletedTaskResultMessage, FailedTaskResultMessage, HeartbeatMessage, ProtocolErrorMessage, RegisterAckMessage, RegisterErrorMessage, RegisterMessage, RemoteWorkerCapabilities, RemoteWorkerJsonValue, ShutdownMessage, TaskMessage } from './protocol-messages.ts';
 import { REMOTE_WORKER_MESSAGE_SCHEMAS, REMOTE_WORKER_PROTOCOL_JSON_SCHEMA } from './protocol-schemas.ts';
+import type { TaskResultMessage } from './protocol-task-result.ts';
 import type { RemoteWorkerProtocolVersion } from './protocol-version.ts';
 import { REMOTE_WORKER_MAX_PROTOCOL_VERSION, REMOTE_WORKER_MIN_PROTOCOL_VERSION, REMOTE_WORKER_PROTOCOL_VERSION, REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS } from './protocol-version.ts';
 export { REMOTE_WORKER_MAX_PROTOCOL_VERSION, REMOTE_WORKER_MESSAGE_SCHEMAS, REMOTE_WORKER_MIN_PROTOCOL_VERSION, REMOTE_WORKER_PROTOCOL_JSON_SCHEMA, REMOTE_WORKER_PROTOCOL_VERSION, REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS, isRemoteWorkerJsonValue, };
-export type { CancelMessage, CancelledTaskResultMessage, CompletedTaskResultMessage, FailedTaskResultMessage, HeartbeatMessage, ProtocolErrorMessage, RegisterAckMessage, RegisterErrorMessage, RegisterMessage, RemoteWorkerCapabilities, RemoteWorkerJsonValue, RemoteWorkerProtocolFailure, RemoteWorkerProtocolParseResult, RemoteWorkerProtocolVersion, ShutdownMessage, TaskMessage, };
-/**
- * Worker-to-server task result message. Discriminated union over `status`.
- *
- * @example
- * ```ts
- * import type { TaskResultMessage } from '@lostgradient/weft/worker-protocol';
- *
- * const message: TaskResultMessage = {
- *   type: 'taskResult', operationId: 'op-1', status: 'completed', value: { ok: true },
- * };
- * ```
- */
-export type TaskResultMessage = CompletedTaskResultMessage | FailedTaskResultMessage | CancelledTaskResultMessage;
+export type { CancelMessage, CancelledTaskResultMessage, CompletedTaskResultMessage, FailedTaskResultMessage, HeartbeatMessage, ProtocolErrorMessage, RegisterAckMessage, RegisterErrorMessage, RegisterMessage, RemoteWorkerCapabilities, RemoteWorkerJsonValue, RemoteWorkerProtocolFailure, RemoteWorkerProtocolParseResult, RemoteWorkerProtocolVersion, ShutdownMessage, TaskMessage, TaskResultMessage, };
 /**
  * Messages accepted from a worker stream client.
  *

package/dist/worker/protocol.js

@@ -1,2 +1,2 @@
 // @bun
-var h=Object.defineProperty;var q=(z)=>z;function T(z,B){this[z]=q.bind(null,B)}var a=(z,B)=>{for(var D in B)h(z,D,{get:B[D],enumerable:!0,configurable:!0,set:T.bind(B,D)})};var o=(z,B)=>()=>(z&&(B=z(z=0)),B);function F(z){return z!==null&&typeof z==="object"&&!Array.isArray(z)}function x(z){if(z===null||typeof z==="string"||typeof z==="boolean"||typeof z==="number"&&Number.isFinite(z))return!0;if(Array.isArray(z))return z.every(x);if(!F(z))return!1;return Object.values(z).every(x)}function U(z){return typeof z==="string"&&z.length>0}function L(z){return Array.isArray(z)&&z.every(U)}function K(z){if(!F(z))return!1;return Object.values(z).every((B)=>typeof B==="string")}function f(z){if(!F(z))return!1;return Object.values(z).every(x)}function G(z){return typeof z==="number"&&Number.isFinite(z)}function Q(z,B,D){return{ok:!1,error:{code:z,message:B,...D!==void 0?{requestedProtocolVersion:D}:{}}}}function A(z,B,D){let X={};for(let[Y,$,b,C]of D){let H=B[Y];if(H===void 0){if($)return{ok:!1,error:Q(z,C)};continue}if(!b(H))return{ok:!1,error:Q(z,C)};X[Y]=H}return{ok:!0,values:X}}var Z=2,W=2,k=2,I=[2];var j={$ref:"#/$defs/jsonValue"},w={type:"object",additionalProperties:j},M={type:"object",additionalProperties:{type:"string"}},J={const:Z},N={register:{type:"object",additionalProperties:!1,required:["type","protocolVersion","workerId","activities"],properties:{type:{const:"register"},protocolVersion:J,workerId:{type:"string",minLength:1},activities:{type:"array",items:{type:"string",minLength:1}},concurrency:{type:"number",minimum:1,maximum:1000},queue:{type:"string",minLength:1},deploymentName:{type:"string",minLength:1},buildId:{type:"string",minLength:1},runtimeVersion:{type:"string",minLength:1},gitSha:{type:"string",minLength:1},startedAt:{type:"number"},capabilities:w}},heartbeat:{type:"object",additionalProperties:!1,required:["type","workerId"],properties:{type:{const:"heartbeat"},workerId:{type:"string",minLength:1}}},taskResult:{oneOf:[{type:"object",additionalProperties:!1,required:["type","operationId","status","value"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"completed"},value:j}},{type:"object",additionalProperties:!1,required:["type","operationId","status","error"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"failed"},error:{type:"string"}}},{type:"object",additionalProperties:!1,required:["type","operationId","status","error"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"cancelled"},error:{type:"string"},cancelled:{const:!0}}}]},task:{type:"object",additionalProperties:!1,required:["type","operationId","activityName","input"],properties:{type:{const:"task"},operationId:{type:"string",minLength:1},activityName:{type:"string",minLength:1},input:j,attempt:{type:"number",minimum:1},headers:M}},cancel:{type:"object",additionalProperties:!1,required:["type","operationId"],properties:{type:{const:"cancel"},operationId:{type:"string",minLength:1}}},shutdown:{type:"object",additionalProperties:!1,required:["type"],properties:{type:{const:"shutdown"}}},registerAck:{type:"object",additionalProperties:!1,required:["type","protocolVersion","workerId","queue","activities","concurrency"],properties:{type:{const:"registerAck"},protocolVersion:J,workerId:{type:"string",minLength:1},queue:{type:"string",minLength:1},activities:{type:"array",items:{type:"string",minLength:1}},concurrency:{type:"number",minimum:1,maximum:1000}}},registerError:{type:"object",additionalProperties:!1,required:["type","code","message","supportedProtocolVersions"],properties:{type:{const:"registerError"},code:{enum:["invalid_registration","unsupported_protocol_version"]},message:{type:"string"},supportedProtocolVersions:{type:"array",items:J},requestedProtocolVersion:{type:"number"}}},protocolError:{type:"object",additionalProperties:!1,required:["type","code","message"],properties:{type:{const:"protocolError"},code:{enum:["invalid_json","invalid_message","unknown_message_type","registration_required"]},message:{type:"string"}}}},P={$schema:"https://json-schema.org/draft/2020-12/schema",$id:"https://weft.dev/schemas/remote-worker-protocol.v1.json",title:"Weft RemoteWorker Protocol v1",oneOf:Object.keys(N).map((z)=>({$ref:`#/$defs/messages/${z}`})),$defs:{jsonValue:{oneOf:[{type:"null"},{type:"boolean"},{type:"number"},{type:"string"},{type:"array",items:{$ref:"#/$defs/jsonValue"}},{type:"object",additionalProperties:{$ref:"#/$defs/jsonValue"}}]},jsonObject:w,messages:N}};var g=new Set(["register","heartbeat","taskResult"]),_=new Set(["registerAck","registerError","protocolError","task","cancel","shutdown"]);function y(z){if(z===Z)return{ok:!0,message:z};let B=G(z)?z:void 0;return Q("unsupported_protocol_version",`Unsupported RemoteWorker protocol version: ${String(z)}`,B)}var S=[["workerId",!0,U,"register.workerId must be a non-empty string"],["activities",!0,L,"register.activities must be an array of non-empty strings"],["concurrency",!1,G,"register.concurrency must be a finite number"],["queue",!1,U,"register.queue must be a non-empty string"],["deploymentName",!1,U,"register.deploymentName must be a non-empty string when present"],["buildId",!1,U,"register.buildId must be a non-empty string when present"],["runtimeVersion",!1,U,"register.runtimeVersion must be a non-empty string when present"],["gitSha",!1,U,"register.gitSha must be a non-empty string when present"],["startedAt",!1,G,"register.startedAt must be a finite number when present"],["capabilities",!1,f,"register.capabilities must be a JSON object when present"]];function E(z){let B=y(z.protocolVersion);if(!B.ok)return B;let D=A("invalid_registration",z,S);if(!D.ok)return D.error;return{ok:!0,message:{type:"register",protocolVersion:B.message,...D.values}}}function V(z){let B=z.workerId;if(!U(B))return Q("invalid_message","heartbeat.workerId must be a non-empty string");return{ok:!0,message:{type:"heartbeat",workerId:B}}}function O(z,B){let D=B.value;if(!x(D))return Q("invalid_message","completed taskResult.value must be valid JSON");return{ok:!0,message:{type:"taskResult",operationId:z,status:"completed",value:D}}}function m(z,B){let D=B.error;if(typeof D!=="string")return Q("invalid_message","failed taskResult.error must be a string");return{ok:!0,message:{type:"taskResult",operationId:z,status:"failed",error:D}}}function R(z,B){let D=B.error;if(typeof D!=="string")return Q("invalid_message","cancelled taskResult.error must be a string");let X=B.cancelled;if(X!==void 0&&X!==!0)return Q("invalid_message","taskResult.cancelled must be true when present");return{ok:!0,message:{type:"taskResult",operationId:z,status:"cancelled",error:D,...X===!0?{cancelled:X}:{}}}}var p={completed:O,failed:m,cancelled:R};function n(z){return z==="completed"||z==="failed"||z==="cancelled"}function i(z){let B=z.operationId;if(!U(B))return Q("invalid_message","taskResult.operationId must be a non-empty string");let D=z.status;if(!n(D))return Q("invalid_message","taskResult.status must be completed, failed, or cancelled");return p[D](B,z)}var v=[["operationId",!0,U,"task.operationId must be a non-empty string"],["activityName",!0,U,"task.activityName must be a non-empty string"],["input",!0,x,"task.input must be valid JSON"],["attempt",!1,G,"task.attempt must be a finite number"],["headers",!1,K,"task.headers must be a string map"]];function t(z){let B=A("invalid_message",z,v);if(!B.ok)return B.error;return{ok:!0,message:{type:"task",...B.values}}}function d(z){let B=z.operationId;if(!U(B))return Q("invalid_message","cancel.operationId must be a non-empty string");return{ok:!0,message:{type:"cancel",operationId:B}}}function s(){return{ok:!0,message:{type:"shutdown"}}}function u(z){let B=z.protocolVersion;if(B!==Z)return Q("invalid_message",`registerAck.protocolVersion must be ${String(Z)}`);let{workerId:D,queue:X,activities:Y,concurrency:$}=z;if(!U(D))return Q("invalid_message","registerAck.workerId must be a non-empty string");if(!U(X))return Q("invalid_message","registerAck.queue must be a non-empty string");if(!L(Y))return Q("invalid_message","registerAck.activities must be a string array");if(typeof $!=="number"||!Number.isFinite($))return Q("invalid_message","registerAck.concurrency must be a finite number");return{ok:!0,message:{type:"registerAck",protocolVersion:B,workerId:D,queue:X,activities:Y,concurrency:$}}}function c(z){let{code:B,message:D,supportedProtocolVersions:X,requestedProtocolVersion:Y}=z;if(B!=="invalid_registration"&&B!=="unsupported_protocol_version")return Q("invalid_message","registerError.code is not recognized");if(typeof D!=="string")return Q("invalid_message","registerError.message must be a string");if(!Array.isArray(X)||!X.every((b)=>b===Z))return Q("invalid_message","registerError.supportedProtocolVersions is invalid");if(Y!==void 0&&!G(Y))return Q("invalid_message","registerError.requestedProtocolVersion must be a finite number");return{ok:!0,message:{type:"registerError",code:B,message:D,supportedProtocolVersions:X,...Y!==void 0?{requestedProtocolVersion:Y}:{}}}}function l(z){let{code:B,message:D}=z;if(B!=="invalid_json"&&B!=="invalid_message"&&B!=="unknown_message_type"&&B!=="registration_required")return Q("invalid_message","protocolError.code is not recognized");if(typeof D!=="string")return Q("invalid_message","protocolError.message must be a string");return{ok:!0,message:{type:"protocolError",code:B,message:D}}}function Yz(z){if(!F(z))return Q("invalid_message","Worker protocol message must be a JSON object");let B=z.type;if(typeof B!=="string")return Q("invalid_message","Worker protocol message.type must be a string");if(!g.has(B))return Q("unknown_message_type",`Unknown worker message type: ${B}`);switch(B){case"register":return E(z);case"heartbeat":return V(z);case"taskResult":return i(z);default:return Q("unknown_message_type",`Unknown worker message type: ${B}`)}}function Zz(z){if(!F(z))return Q("invalid_message","Server protocol message must be a JSON object");let B=z.type;if(typeof B!=="string")return Q("invalid_message","Server protocol message.type must be a string");if(!_.has(B))return Q("unknown_message_type",`Unknown server message type: ${B}`);switch(B){case"registerAck":return u(z);case"registerError":return c(z);case"protocolError":return l(z);case"task":return t(z);case"cancel":return d(z);case"shutdown":return s();default:return Q("unknown_message_type",`Unknown server message type: ${B}`)}}export{Yz as parseWorkerToServerMessage,Zz as parseServerToWorkerMessage,x as isRemoteWorkerJsonValue,I as REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS,Z as REMOTE_WORKER_PROTOCOL_VERSION,P as REMOTE_WORKER_PROTOCOL_JSON_SCHEMA,W as REMOTE_WORKER_MIN_PROTOCOL_VERSION,N as REMOTE_WORKER_MESSAGE_SCHEMAS,k as REMOTE_WORKER_MAX_PROTOCOL_VERSION};
+var h=Object.defineProperty;var M=(z)=>z;function I(z,B){this[z]=M.bind(null,B)}var r=(z,B)=>{for(var D in B)h(z,D,{get:B[D],enumerable:!0,configurable:!0,set:I.bind(B,D)})};var o=(z,B)=>()=>(z&&(B=z(z=0)),B);function G(z){return z!==null&&typeof z==="object"&&!Array.isArray(z)}function U(z){if(z===null||typeof z==="string"||typeof z==="boolean"||typeof z==="number"&&Number.isFinite(z))return!0;if(Array.isArray(z))return z.every(U);if(!G(z))return!1;return Object.values(z).every(U)}function Y(z){return typeof z==="string"&&z.length>0}function j(z){return Array.isArray(z)&&z.every(Y)}function w(z){if(!G(z))return!1;return Object.values(z).every((B)=>typeof B==="string")}function q(z){if(!G(z))return!1;return Object.values(z).every(U)}function b(z){return typeof z==="number"&&Number.isFinite(z)}function Q(z,B,D){return{ok:!1,error:{code:z,message:B,...D!==void 0?{requestedProtocolVersion:D}:{}}}}function J(z,B,D){let X={};for(let[Z,x,H,C]of D){let L=B[Z];if(L===void 0){if(x)return{ok:!1,error:Q(z,C)};continue}if(!H(L))return{ok:!1,error:Q(z,C)};X[Z]=L}return{ok:!0,values:X}}var $=2,P=2,g=2,_=[2];var F={$ref:"#/$defs/jsonValue"},A={type:"object",additionalProperties:F},y={type:"object",additionalProperties:{type:"string"}},f={const:$},K={register:{type:"object",additionalProperties:!1,required:["type","protocolVersion","workerId","activities"],properties:{type:{const:"register"},protocolVersion:f,workerId:{type:"string",minLength:1},activities:{type:"array",items:{type:"string",minLength:1}},concurrency:{type:"number",minimum:1,maximum:1000},queue:{type:"string",minLength:1},deploymentName:{type:"string",minLength:1},buildId:{type:"string",minLength:1},runtimeVersion:{type:"string",minLength:1},gitSha:{type:"string",minLength:1},startedAt:{type:"number"},capabilities:A}},heartbeat:{type:"object",additionalProperties:!1,required:["type","workerId"],properties:{type:{const:"heartbeat"},workerId:{type:"string",minLength:1}}},taskResult:{oneOf:[{type:"object",additionalProperties:!1,required:["type","operationId","status","value"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"completed"},value:F,attemptToken:{type:"string",minLength:1}}},{type:"object",additionalProperties:!1,required:["type","operationId","status","error"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"failed"},error:{type:"string"},attemptToken:{type:"string",minLength:1}}},{type:"object",additionalProperties:!1,required:["type","operationId","status","error"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"cancelled"},error:{type:"string"},cancelled:{const:!0},attemptToken:{type:"string",minLength:1}}}]},task:{type:"object",additionalProperties:!1,required:["type","operationId","activityName","input"],properties:{type:{const:"task"},operationId:{type:"string",minLength:1},activityName:{type:"string",minLength:1},input:F,attempt:{type:"number",minimum:1},headers:y,attemptToken:{type:"string",minLength:1}}},cancel:{type:"object",additionalProperties:!1,required:["type","operationId"],properties:{type:{const:"cancel"},operationId:{type:"string",minLength:1}}},shutdown:{type:"object",additionalProperties:!1,required:["type"],properties:{type:{const:"shutdown"}}},registerAck:{type:"object",additionalProperties:!1,required:["type","protocolVersion","workerId","queue","activities","concurrency"],properties:{type:{const:"registerAck"},protocolVersion:f,workerId:{type:"string",minLength:1},queue:{type:"string",minLength:1},activities:{type:"array",items:{type:"string",minLength:1}},concurrency:{type:"number",minimum:1,maximum:1000}}},registerError:{type:"object",additionalProperties:!1,required:["type","code","message","supportedProtocolVersions"],properties:{type:{const:"registerError"},code:{enum:["invalid_registration","unsupported_protocol_version"]},message:{type:"string"},supportedProtocolVersions:{type:"array",items:f},requestedProtocolVersion:{type:"number"}}},protocolError:{type:"object",additionalProperties:!1,required:["type","code","message"],properties:{type:{const:"protocolError"},code:{enum:["invalid_json","invalid_message","unknown_message_type","registration_required"]},message:{type:"string"}}}},T={$schema:"https://json-schema.org/draft/2020-12/schema",$id:"https://weft.dev/schemas/remote-worker-protocol.v1.json",title:"Weft RemoteWorker Protocol v1",oneOf:Object.keys(K).map((z)=>({$ref:`#/$defs/messages/${z}`})),$defs:{jsonValue:{oneOf:[{type:"null"},{type:"boolean"},{type:"number"},{type:"string"},{type:"array",items:{$ref:"#/$defs/jsonValue"}},{type:"object",additionalProperties:{$ref:"#/$defs/jsonValue"}}]},jsonObject:A,messages:K}};function N(z){let B=z.attemptToken;if(B===void 0)return{ok:!0,message:{}};if(!Y(B))return Q("invalid_message","taskResult.attemptToken must be a non-empty string when present");return{ok:!0,message:{attemptToken:B}}}function O(z,B){let D=B.value;if(!U(D))return Q("invalid_message","completed taskResult.value must be valid JSON");let X=N(B);if(!X.ok)return X;return{ok:!0,message:{type:"taskResult",operationId:z,status:"completed",value:D,...X.message}}}function V(z,B){let D=B.error;if(typeof D!=="string")return Q("invalid_message","failed taskResult.error must be a string");let X=N(B);if(!X.ok)return X;return{ok:!0,message:{type:"taskResult",operationId:z,status:"failed",error:D,...X.message}}}function S(z,B){let D=B.error;if(typeof D!=="string")return Q("invalid_message","cancelled taskResult.error must be a string");let X=B.cancelled;if(X!==void 0&&X!==!0)return Q("invalid_message","taskResult.cancelled must be true when present");let Z=N(B);if(!Z.ok)return Z;return{ok:!0,message:{type:"taskResult",operationId:z,status:"cancelled",error:D,...X===!0?{cancelled:X}:{},...Z.message}}}var k={completed:O,failed:V,cancelled:S};function E(z){return z==="completed"||z==="failed"||z==="cancelled"}function W(z){let B=z.operationId;if(!Y(B))return Q("invalid_message","taskResult.operationId must be a non-empty string");let D=z.status;if(!E(D))return Q("invalid_message","taskResult.status must be completed, failed, or cancelled");return k[D](B,z)}var m=new Set(["register","heartbeat","taskResult"]),R=new Set(["registerAck","registerError","protocolError","task","cancel","shutdown"]);function p(z){if(z===$)return{ok:!0,message:z};let B=b(z)?z:void 0;return Q("unsupported_protocol_version",`Unsupported RemoteWorker protocol version: ${String(z)}`,B)}var n=[["workerId",!0,Y,"register.workerId must be a non-empty string"],["activities",!0,j,"register.activities must be an array of non-empty strings"],["concurrency",!1,b,"register.concurrency must be a finite number"],["queue",!1,Y,"register.queue must be a non-empty string"],["deploymentName",!1,Y,"register.deploymentName must be a non-empty string when present"],["buildId",!1,Y,"register.buildId must be a non-empty string when present"],["runtimeVersion",!1,Y,"register.runtimeVersion must be a non-empty string when present"],["gitSha",!1,Y,"register.gitSha must be a non-empty string when present"],["startedAt",!1,b,"register.startedAt must be a finite number when present"],["capabilities",!1,q,"register.capabilities must be a JSON object when present"]];function i(z){let B=p(z.protocolVersion);if(!B.ok)return B;let D=J("invalid_registration",z,n);if(!D.ok)return D.error;return{ok:!0,message:{type:"register",protocolVersion:B.message,...D.values}}}function v(z){let B=z.workerId;if(!Y(B))return Q("invalid_message","heartbeat.workerId must be a non-empty string");return{ok:!0,message:{type:"heartbeat",workerId:B}}}var d=[["operationId",!0,Y,"task.operationId must be a non-empty string"],["activityName",!0,Y,"task.activityName must be a non-empty string"],["input",!0,U,"task.input must be valid JSON"],["attempt",!1,b,"task.attempt must be a finite number"],["headers",!1,w,"task.headers must be a string map"],["attemptToken",!1,Y,"task.attemptToken must be a non-empty string"]];function u(z){let B=J("invalid_message",z,d);if(!B.ok)return B.error;return{ok:!0,message:{type:"task",...B.values}}}function s(z){let B=z.operationId;if(!Y(B))return Q("invalid_message","cancel.operationId must be a non-empty string");return{ok:!0,message:{type:"cancel",operationId:B}}}function c(){return{ok:!0,message:{type:"shutdown"}}}function t(z){let B=z.protocolVersion;if(B!==$)return Q("invalid_message",`registerAck.protocolVersion must be ${String($)}`);let{workerId:D,queue:X,activities:Z,concurrency:x}=z;if(!Y(D))return Q("invalid_message","registerAck.workerId must be a non-empty string");if(!Y(X))return Q("invalid_message","registerAck.queue must be a non-empty string");if(!j(Z))return Q("invalid_message","registerAck.activities must be a string array");if(typeof x!=="number"||!Number.isFinite(x))return Q("invalid_message","registerAck.concurrency must be a finite number");return{ok:!0,message:{type:"registerAck",protocolVersion:B,workerId:D,queue:X,activities:Z,concurrency:x}}}function l(z){let{code:B,message:D,supportedProtocolVersions:X,requestedProtocolVersion:Z}=z;if(B!=="invalid_registration"&&B!=="unsupported_protocol_version")return Q("invalid_message","registerError.code is not recognized");if(typeof D!=="string")return Q("invalid_message","registerError.message must be a string");if(!Array.isArray(X)||!X.every((H)=>H===$))return Q("invalid_message","registerError.supportedProtocolVersions is invalid");if(Z!==void 0&&!b(Z))return Q("invalid_message","registerError.requestedProtocolVersion must be a finite number");return{ok:!0,message:{type:"registerError",code:B,message:D,supportedProtocolVersions:X,...Z!==void 0?{requestedProtocolVersion:Z}:{}}}}function a(z){let{code:B,message:D}=z;if(B!=="invalid_json"&&B!=="invalid_message"&&B!=="unknown_message_type"&&B!=="registration_required")return Q("invalid_message","protocolError.code is not recognized");if(typeof D!=="string")return Q("invalid_message","protocolError.message must be a string");return{ok:!0,message:{type:"protocolError",code:B,message:D}}}function Gz(z){if(!G(z))return Q("invalid_message","Worker protocol message must be a JSON object");let B=z.type;if(typeof B!=="string")return Q("invalid_message","Worker protocol message.type must be a string");if(!m.has(B))return Q("unknown_message_type",`Unknown worker message type: ${B}`);switch(B){case"register":return i(z);case"heartbeat":return v(z);case"taskResult":return W(z);default:return Q("unknown_message_type",`Unknown worker message type: ${B}`)}}function bz(z){if(!G(z))return Q("invalid_message","Server protocol message must be a JSON object");let B=z.type;if(typeof B!=="string")return Q("invalid_message","Server protocol message.type must be a string");if(!R.has(B))return Q("unknown_message_type",`Unknown server message type: ${B}`);switch(B){case"registerAck":return t(z);case"registerError":return l(z);case"protocolError":return a(z);case"task":return u(z);case"cancel":return s(z);case"shutdown":return c();default:return Q("unknown_message_type",`Unknown server message type: ${B}`)}}export{Gz as parseWorkerToServerMessage,bz as parseServerToWorkerMessage,U as isRemoteWorkerJsonValue,_ as REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS,$ as REMOTE_WORKER_PROTOCOL_VERSION,T as REMOTE_WORKER_PROTOCOL_JSON_SCHEMA,P as REMOTE_WORKER_MIN_PROTOCOL_VERSION,K as REMOTE_WORKER_MESSAGE_SCHEMAS,g as REMOTE_WORKER_MAX_PROTOCOL_VERSION};

package/dist/worker/registry/fair-share.d.ts

@@ -57,3 +57,32 @@ export declare function scoreWorker(snapshot: WorkerScoreSnapshot): WorkerScore;
  * ```
  */
 export declare function compareScores(a: WorkerScore, b: WorkerScore): number;
+/**
+ * Per-worker, per-key in-flight counters for fair-share routing. Keeping this
+ * state in one object — rather than an inline `Map<string, Map<string, number>>`
+ * in the registry — guarantees increments, releases, and per-worker purges all
+ * agree on the same idempotency rules, so the counts never drift from the
+ * in-flight task set that drives them.
+ *
+ * @example
+ * ```ts
+ * import { FairShareCounters } from './fair-share.ts';
+ * const counters = new FairShareCounters();
+ * counters.increment('w1', 'tenant-a');
+ * console.log(counters.load('w1', 'tenant-a')); // 1
+ * ```
+ */
+export declare class FairShareCounters {
+    #private;
+    /** Current in-flight count for `workerId` on `key` (0 when untracked). */
+    load(workerId: string, key: string): number;
+    /** Increment the in-flight count for `workerId` on `key`. */
+    increment(workerId: string, key: string): void;
+    /**
+     * Decrement the in-flight count for `workerId` on `key`, pruning empty inner
+     * and outer maps so an idle worker leaves no residue. Floors at 0.
+     */
+    release(workerId: string, key: string): void;
+    /** Drop all counters for a worker that has disconnected. */
+    purge(workerId: string): void;
+}

package/dist/worker/registry/fair-share.js

@@ -13,3 +13,33 @@ export function compareScores(a, b) {
     return a.inFlight - b.inFlight;
   return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }
+
+export class FairShareCounters {
+  #counts = new Map;
+  load(workerId, key) {
+    return this.#counts.get(workerId)?.get(key) ?? 0;
+  }
+  increment(workerId, key) {
+    let workerCounts = this.#counts.get(workerId);
+    if (workerCounts === void 0) {
+      workerCounts = new Map;
+      this.#counts.set(workerId, workerCounts);
+    }
+    workerCounts.set(key, (workerCounts.get(key) ?? 0) + 1);
+  }
+  release(workerId, key) {
+    const workerCounts = this.#counts.get(workerId);
+    if (workerCounts === void 0)
+      return;
+    const next = Math.max(0, (workerCounts.get(key) ?? 0) - 1);
+    if (next === 0) {
+      workerCounts.delete(key);
+      if (workerCounts.size === 0)
+        this.#counts.delete(workerId);
+    } else
+      workerCounts.set(key, next);
+  }
+  purge(workerId) {
+    this.#counts.delete(workerId);
+  }
+}

package/dist/worker/registry/routing.d.ts

@@ -1,3 +1,4 @@
+import { type FairShareCounters } from './fair-share.ts';
 import type { WorkerInfo } from './types.ts';
 /**
  * Return `true` when `worker` is eligible for the given `activityName` and
@@ -15,3 +16,20 @@ export declare function matchesWorkerCapabilities(worker: WorkerInfo, activityNa
  * `eligible` must be non-empty — the caller is responsible for this precondition.
  */
 export declare function pickLeastLoaded(eligible: WorkerInfo[]): WorkerInfo;
+/**
+ * Round-robin selection with a per-(queue, activity) cursor so two activities
+ * sharing a queue advance independently. Mutates `cursor` in place, advancing
+ * the entry for this (queue, activity) pair.
+ *
+ * `eligible` must be non-empty — the caller is responsible for this precondition.
+ */
+export declare function pickRoundRobin(eligible: WorkerInfo[], cursor: Map<string, number>, queue: string | undefined, activityName: string): WorkerInfo;
+/**
+ * Fair-share selection: the worker carrying the fewest in-flight tasks for
+ * `fairShareKey` wins, ties broken by overall in-flight count then stable id
+ * order. The score snapshot is built synchronously so the ranking is consistent
+ * across the full candidate set.
+ *
+ * `eligible` must be non-empty — the caller is responsible for this precondition.
+ */
+export declare function pickFairShare(eligible: WorkerInfo[], counters: FairShareCounters, fairShareKey: string): WorkerInfo;

package/dist/worker/registry/routing.js

@@ -1,3 +1,4 @@
+import { compareScores, scoreWorker } from "./fair-share.js";
 export function matchesWorkerCapabilities(worker, activityName, queue) {
   if (queue !== void 0 && worker.queue !== queue)
     return !1;
@@ -14,3 +15,16 @@ export function pickLeastLoaded(eligible) {
   }
   return best;
 }
+export function pickRoundRobin(eligible, cursor, queue, activityName) {
+  const key = `${queue ?? "__default__"}::${activityName}`, position = cursor.get(key) ?? 0, pick = eligible[position % eligible.length];
+  cursor.set(key, position + 1);
+  return pick;
+}
+export function pickFairShare(eligible, counters, fairShareKey) {
+  const winner = eligible.map((worker) => scoreWorker({
+    id: worker.id,
+    inFlight: worker.inFlight,
+    keyLoad: counters.load(worker.id, fairShareKey)
+  })).reduce((best, candidate) => compareScores(candidate, best) < 0 ? candidate : best);
+  return eligible.find((worker) => worker.id === winner.id);
+}

package/dist/worker/registry/types.d.ts

@@ -116,6 +116,13 @@ export interface InFlightTask {
     visibilityTimeout: number;
     /** Optional fair-share partition key the task was assigned under. */
     fairShareKey?: string;
+    /**
+     * Unique, unguessable token for this dispatch attempt. The WebSocket completion
+     * handler compares the worker's echoed token against this in-memory value (after
+     * the workerId ownership guard) to reject a stale completion from an earlier
+     * attempt reassigned to the same worker.
+     */
+    attemptToken?: string;
 }
 export interface WorkerRegistryOptions {
     /** Routing policy used by {@link WorkerRegistry.findWorker}. Default: `'least-loaded'`. */

package/dist/worker/registry.d.ts

@@ -45,7 +45,7 @@ export declare class WorkerRegistry {
      */
     findWorker(activityName: string, options?: RoutingOptions): WorkerInfo | undefined;
     /** Track a task assignment with a visibility timeout deadline. */
-    assignTask(workerId: string, operationId: string, visibilityTimeout: number, fairShareKey?: string): void;
+    assignTask(workerId: string, operationId: string, visibilityTimeout: number, fairShareKey?: string, attemptToken?: string): void;
     /** Return tasks whose deadline has passed and remove them from tracking. */
     checkExpiredTasks(now: number): InFlightTask[];
     /**
@@ -57,6 +57,21 @@ export declare class WorkerRegistry {
     getWorkerTasks(workerId: string): InFlightTask[];
     /** True when `operationId` is in flight on `workerId` — used at the trust boundary to reject stale completions after takeover. */
     isAssignedToWorker(operationId: string, workerId: string): boolean;
+    /**
+     * True when `operationId` is in flight on `workerId` for the specific dispatch
+     * attempt identified by `attemptToken`. Layered after {@link isAssignedToWorker}
+     * to reject a stale completion from an EARLIER attempt that was reassigned to the
+     * same worker — the only case the workerId guard alone cannot catch.
+     *
+     * The token check is purely additive, so a worker that predates the field is
+     * never refused (no protocol version bump): it fires only when the tracked
+     * task has a stored token AND the completion echoes one AND they differ. A
+     * token-less task matches any echo, and an absent echo falls back to the
+     * workerId-only guard that already passed. The defended case — a stale earlier
+     * attempt — always echoes the OLD token it was dispatched with (present, wrong),
+     * so it is still rejected.
+     */
+    isAssignedToAttempt(operationId: string, workerId: string, attemptToken: string | undefined): boolean;
     /** Check whether an operation is currently assigned to a worker. */
     isAssigned(operationId: string): boolean;
     /** Look up an in-flight task by operationId in O(1). */