@lostgradient/weft 0.18.0 → 0.19.0

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

@@ -10,12 +10,16 @@
 /**
  * Current RemoteWorker wire protocol version.
  *
- * **Version 2** (Phase 4 of the workflow-builder refactor) bumps the semantics
- * of the `activities: string[]` field in the register message. Each entry is
- * now a qualified `${workflowType}.${activityName}` name rather than a bare
- * activity name, so the server can dispatch the correct workflow's activity
- * implementation when the same activity key is used by multiple workflows. The
- * wire shape did not change; only the meaning of the strings.
+ * **Version 3** (Canonical Worker Manifest, WFT-27) replaces the register
+ * message's parallel top-level identity fields (`activities`, `queue`,
+ * `deploymentName`, `buildId`, `runtimeVersion`, `gitSha`, `capabilities`)
+ * with a single `manifest: WorkerManifest` field, and the ack echoes
+ * `acceptedManifestDigest` plus `serverCapabilities` instead of echoing
+ * `activities` back. Both directions of the handshake reshape — a strictly
+ * larger change than version 2's same-shape/different-semantics bump — so
+ * this is a clean break rather than a negotiated one: a v2 peer gets the
+ * canonical `WorkerProtocolIncompatibleError`, not a confusing
+ * `invalid_registration`.
  *
  * @example
  * ```ts
@@ -24,7 +28,7 @@
  * const registration = { type: 'register', protocolVersion: REMOTE_WORKER_PROTOCOL_VERSION };
  * ```
  */
-export declare const REMOTE_WORKER_PROTOCOL_VERSION = 2;
+export declare const REMOTE_WORKER_PROTOCOL_VERSION = 3;
 /**
  * Lowest RemoteWorker protocol version accepted by this package.
  *
@@ -32,10 +36,10 @@ export declare const REMOTE_WORKER_PROTOCOL_VERSION = 2;
  * ```ts
  * import { REMOTE_WORKER_MIN_PROTOCOL_VERSION } from '@lostgradient/weft/worker-protocol';
  *
- * const supportsCurrentVersion = REMOTE_WORKER_MIN_PROTOCOL_VERSION === 2;
+ * const supportsCurrentVersion = REMOTE_WORKER_MIN_PROTOCOL_VERSION === 3;
  * ```
  */
-export declare const REMOTE_WORKER_MIN_PROTOCOL_VERSION = 2;
+export declare const REMOTE_WORKER_MIN_PROTOCOL_VERSION = 3;
 /**
  * Highest RemoteWorker protocol version accepted by this package.
  *
@@ -43,10 +47,10 @@ export declare const REMOTE_WORKER_MIN_PROTOCOL_VERSION = 2;
  * ```ts
  * import { REMOTE_WORKER_MAX_PROTOCOL_VERSION } from '@lostgradient/weft/worker-protocol';
  *
- * const canUseRequestedVersion = 2 <= REMOTE_WORKER_MAX_PROTOCOL_VERSION;
+ * const canUseRequestedVersion = 3 <= REMOTE_WORKER_MAX_PROTOCOL_VERSION;
  * ```
  */
-export declare const REMOTE_WORKER_MAX_PROTOCOL_VERSION = 2;
+export declare const REMOTE_WORKER_MAX_PROTOCOL_VERSION = 3;
 /**
  * Explicit supported RemoteWorker protocol versions.
  *
@@ -54,10 +58,10 @@ export declare const REMOTE_WORKER_MAX_PROTOCOL_VERSION = 2;
  * ```ts
  * import { REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS } from '@lostgradient/weft/worker-protocol';
  *
- * const supported = REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS.includes(2);
+ * const supported = REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS.includes(3);
  * ```
  */
-export declare const REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS: readonly [2];
+export declare const REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS: readonly [3];
 /**
  * RemoteWorker protocol version accepted by this package.
  *
@@ -65,7 +69,7 @@ export declare const REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS: readonly [2];
  * ```ts
  * import type { RemoteWorkerProtocolVersion } from '@lostgradient/weft/worker-protocol';
  *
- * const version: RemoteWorkerProtocolVersion = 2;
+ * const version: RemoteWorkerProtocolVersion = 3;
  * ```
  */
 export type RemoteWorkerProtocolVersion = (typeof REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS)[number];

package/dist/worker/protocol-version.js

@@ -1 +1 @@
-export const REMOTE_WORKER_PROTOCOL_VERSION = 2, REMOTE_WORKER_MIN_PROTOCOL_VERSION = 2, REMOTE_WORKER_MAX_PROTOCOL_VERSION = 2, REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS = [REMOTE_WORKER_PROTOCOL_VERSION];
+export const REMOTE_WORKER_PROTOCOL_VERSION = 3, REMOTE_WORKER_MIN_PROTOCOL_VERSION = 3, REMOTE_WORKER_MAX_PROTOCOL_VERSION = 3, REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS = [REMOTE_WORKER_PROTOCOL_VERSION];

package/dist/worker/protocol.js

@@ -1,2 +1,2 @@
 // @bun
-var c=import.meta.require,l=(z,B,D)=>{if(B!=null){if(typeof B!=="object"&&typeof B!=="function")throw TypeError('Object expected to be assigned to "using" declaration');let X;if(D)X=B[Symbol.asyncDispose];if(X===void 0)X=B[Symbol.dispose];if(typeof X!=="function")throw TypeError("Object not disposable");z.push([D,X,B])}else if(D)z.push([D]);return B},a=(z,B,D)=>{let X=(U)=>B=D?new SuppressedError(U,B,"An error was suppressed during disposal"):(D=!0,U),Z=(U)=>{while(U=z.pop())try{var j=U[1]&&U[1].call(U[2]);if(U[0])return Promise.resolve(j).then(Z,(G)=>(X(G),Z()))}catch(G){X(G)}if(D)throw B};return Z()};function b(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(!b(z))return!1;return Object.values(z).every(x)}function Y(z){return typeof z==="string"&&z.length>0}function L(z){return Array.isArray(z)&&z.every(Y)}function q(z){if(!b(z))return!1;return Object.values(z).every((B)=>typeof B==="string")}function A(z){if(!b(z))return!1;return Object.values(z).every(x)}function H(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 f(z,B,D){let X={};for(let[Z,U,j,G]of D){let J=B[Z];if(J===void 0){if(U)return{ok:!1,error:Q(z,G)};continue}if(!j(J))return{ok:!1,error:Q(z,G)};X[Z]=J}return{ok:!0,values:X}}var $=2,W=2,M=2,I=[2];var w={$ref:"#/$defs/jsonValue"},C={type:"object",additionalProperties:w},g={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:C}},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","attemptToken"],properties:{type:{const:"taskResult"},operationId:{type:"string",minLength:1},status:{const:"completed"},value:w,attemptToken:{type:"string",minLength:1}}},{type:"object",additionalProperties:!1,required:["type","operationId","status","error","attemptToken"],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","attemptToken"],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","attemptToken"],properties:{type:{const:"task"},operationId:{type:"string",minLength:1},activityName:{type:"string",minLength:1},input:w,attempt:{type:"number",minimum:1},headers:g,workflowExecutionToken:{type:"string",minLength:1},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"}}}},P={$schema:"https://json-schema.org/draft/2020-12/schema",$id:`https://weft.dev/schemas/remote-worker-protocol.v${String($)}.json`,title:`Weft RemoteWorker Protocol v${String($)}`,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:C,messages:K}};function N(z){let B=z.attemptToken;if(!Y(B))return Q("invalid_message","taskResult.attemptToken must be a non-empty string");return{ok:!0,message:{attemptToken:B}}}function y(z,B){let D=B.value;if(!x(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 T(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 _(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 V={completed:y,failed:T,cancelled:_};function k(z){return z==="completed"||z==="failed"||z==="cancelled"}function h(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(!k(D))return Q("invalid_message","taskResult.status must be completed, failed, or cancelled");return V[D](B,z)}var S=new Set(["register","heartbeat","taskResult"]),O=new Set(["registerAck","registerError","protocolError","task","cancel","shutdown"]);function E(z){if(z===$)return{ok:!0,message:z};let B=H(z)?z:void 0;return Q("unsupported_protocol_version",`Unsupported RemoteWorker protocol version: ${String(z)}`,B)}var m=[["workerId",!0,Y,"register.workerId must be a non-empty string"],["activities",!0,L,"register.activities must be an array of non-empty strings"],["concurrency",!1,H,"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,H,"register.startedAt must be a finite number when present"],["capabilities",!1,A,"register.capabilities must be a JSON object when present"]];function R(z){let B=E(z.protocolVersion);if(!B.ok)return B;let D=f("invalid_registration",z,m);if(!D.ok)return D.error;return{ok:!0,message:{type:"register",protocolVersion:B.message,...D.values}}}function p(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 n=[["operationId",!0,Y,"task.operationId must be a non-empty string"],["activityName",!0,Y,"task.activityName must be a non-empty string"],["input",!0,x,"task.input must be valid JSON"],["attempt",!1,H,"task.attempt must be a finite number"],["headers",!1,q,"task.headers must be a string map"],["workflowExecutionToken",!1,Y,"task.workflowExecutionToken must be a non-empty string"],["attemptToken",!0,Y,"task.attemptToken must be a non-empty string"]];function i(z){let B=f("invalid_message",z,n);if(!B.ok)return B.error;return{ok:!0,message:{type:"task",...B.values}}}function v(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 d(){return{ok:!0,message:{type:"shutdown"}}}function u(z){let B=z.protocolVersion;if(B!==$)return Q("invalid_message",`registerAck.protocolVersion must be ${String($)}`);let{workerId:D,queue:X,activities:Z,concurrency:U}=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(!L(Z))return Q("invalid_message","registerAck.activities must be a string array");if(typeof U!=="number"||!Number.isFinite(U))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:U}}}function s(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((j)=>j===$))return Q("invalid_message","registerError.supportedProtocolVersions is invalid");if(Z!==void 0&&!H(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 t(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 $z(z){if(!b(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(!S.has(B))return Q("unknown_message_type",`Unknown worker message type: ${B}`);switch(B){case"register":return R(z);case"heartbeat":return p(z);case"taskResult":return h(z);default:return Q("unknown_message_type",`Unknown worker message type: ${B}`)}}function xz(z){if(!b(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(!O.has(B))return Q("unknown_message_type",`Unknown server message type: ${B}`);switch(B){case"registerAck":return u(z);case"registerError":return s(z);case"protocolError":return t(z);case"task":return i(z);case"cancel":return v(z);case"shutdown":return d();default:return Q("unknown_message_type",`Unknown server message type: ${B}`)}}export{$z as parseWorkerToServerMessage,xz as parseServerToWorkerMessage,x as isRemoteWorkerJsonValue,I as REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS,$ as REMOTE_WORKER_PROTOCOL_VERSION,P as REMOTE_WORKER_PROTOCOL_JSON_SCHEMA,W as REMOTE_WORKER_MIN_PROTOCOL_VERSION,K as REMOTE_WORKER_MESSAGE_SCHEMAS,M as REMOTE_WORKER_MAX_PROTOCOL_VERSION};
+var t=import.meta.require,l=(z,B,Q)=>{if(B!=null){if(typeof B!=="object"&&typeof B!=="function")throw TypeError('Object expected to be assigned to "using" declaration');let Y;if(Q)Y=B[Symbol.asyncDispose];if(Y===void 0)Y=B[Symbol.dispose];if(typeof Y!=="function")throw TypeError("Object not disposable");z.push([Q,Y,B])}else if(Q)z.push([Q]);return B},a=(z,B,Q)=>{let Y=($)=>B=Q?new SuppressedError($,B,"An error was suppressed during disposal"):(Q=!0,$),Z=($)=>{while($=z.pop())try{var x=$[1]&&$[1].call($[2]);if($[0])return Promise.resolve(x).then(Z,(b)=>(Y(b),Z()))}catch(b){Y(b)}if(Q)throw B};return Z()};function j(z){return z!==null&&typeof z==="object"&&!Array.isArray(z)}function H(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(H);if(!j(z))return!1;return Object.values(z).every(H)}function U(z){return typeof z==="string"&&z.length>0}function K(z){return Array.isArray(z)&&z.every(U)}function N(z){if(!j(z))return!1;return Object.values(z).every((B)=>typeof B==="string")}function G(z){return typeof z==="number"&&Number.isFinite(z)}function X(z,B,Q){return{ok:!1,error:{code:z,message:B,...Q!==void 0?{requestedProtocolVersion:Q}:{}}}}function L(z,B,Q){let Y={};for(let[Z,$,x,b]of Q){let J=B[Z];if(J===void 0){if($)return{ok:!1,error:X(z,b)};continue}if(!x(J))return{ok:!1,error:X(z,b)};Y[Z]=J}return{ok:!0,values:Y}}var D=3,h=3,C=3,W=[3];var F={$ref:"#/$defs/jsonValue"},I={type:"object",additionalProperties:F},M={type:"object",additionalProperties:{type:"string"}},q={const:D},f={register:{type:"object",additionalProperties:!1,required:["type","protocolVersion","workerId","manifest"],properties:{type:{const:"register"},protocolVersion:q,workerId:{type:"string",minLength:1},manifest:{type:"object"},concurrency:{type:"number",minimum:1,maximum:1000},startedAt:{type:"number"}}},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","attemptToken"],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","attemptToken"],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","attemptToken"],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","attemptToken"],properties:{type:{const:"task"},operationId:{type:"string",minLength:1},activityName:{type:"string",minLength:1},input:F,attempt:{type:"number",minimum:1},headers:M,workflowExecutionToken:{type:"string",minLength:1},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","concurrency","acceptedManifestDigest","serverCapabilities"],properties:{type:{const:"registerAck"},protocolVersion:q,workerId:{type:"string",minLength:1},queue:{type:"string",minLength:1},concurrency:{type:"number",minimum:1,maximum:1000},acceptedManifestDigest:{type:"string",minLength:1},serverCapabilities:{type:"array",items:{type:"string",minLength:1}}}},registerError:{type:"object",additionalProperties:!1,required:["type","code","message","supportedProtocolVersions"],properties:{type:{const:"registerError"},code:{enum:["invalid_registration","unsupported_protocol_version","deployment_conflict","registration_rejected"]},message:{type:"string"},supportedProtocolVersions:{type:"array",items:{type:"number"}},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.v${String(D)}.json`,title:`Weft RemoteWorker Protocol v${String(D)}`,oneOf:Object.keys(f).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:I,messages:f}};function w(z){let B=z.attemptToken;if(!U(B))return X("invalid_message","taskResult.attemptToken must be a non-empty string");return{ok:!0,message:{attemptToken:B}}}function g(z,B){let Q=B.value;if(!H(Q))return X("invalid_message","completed taskResult.value must be valid JSON");let Y=w(B);if(!Y.ok)return Y;return{ok:!0,message:{type:"taskResult",operationId:z,status:"completed",value:Q,...Y.message}}}function y(z,B){let Q=B.error;if(typeof Q!=="string")return X("invalid_message","failed taskResult.error must be a string");let Y=w(B);if(!Y.ok)return Y;return{ok:!0,message:{type:"taskResult",operationId:z,status:"failed",error:Q,...Y.message}}}function T(z,B){let Q=B.error;if(typeof Q!=="string")return X("invalid_message","cancelled taskResult.error must be a string");let Y=B.cancelled;if(Y!==void 0&&Y!==!0)return X("invalid_message","taskResult.cancelled must be true when present");let Z=w(B);if(!Z.ok)return Z;return{ok:!0,message:{type:"taskResult",operationId:z,status:"cancelled",error:Q,...Y===!0?{cancelled:Y}:{},...Z.message}}}var _={completed:g,failed:y,cancelled:T};function V(z){return z==="completed"||z==="failed"||z==="cancelled"}function A(z){let B=z.operationId;if(!U(B))return X("invalid_message","taskResult.operationId must be a non-empty string");let Q=z.status;if(!V(Q))return X("invalid_message","taskResult.status must be completed, failed, or cancelled");return _[Q](B,z)}var k=new Set(["register","heartbeat","taskResult"]),S=new Set(["registerAck","registerError","protocolError","task","cancel","shutdown"]);function m(z){if(z===D)return{ok:!0,message:z};let B=G(z)?z:void 0;return X("unsupported_protocol_version",`Unsupported RemoteWorker protocol version: ${String(z)}`,B)}var O=[["workerId",!0,U,"register.workerId must be a non-empty string"],["manifest",!0,j,"register.manifest must be a JSON object"],["concurrency",!1,G,"register.concurrency must be a finite number"],["startedAt",!1,G,"register.startedAt must be a finite number when present"]];function E(z){let B=m(z.protocolVersion);if(!B.ok)return B;let Q=L("invalid_registration",z,O);if(!Q.ok)return Q.error;return{ok:!0,message:{type:"register",protocolVersion:B.message,...Q.values}}}function R(z){let B=z.workerId;if(!U(B))return X("invalid_message","heartbeat.workerId must be a non-empty string");return{ok:!0,message:{type:"heartbeat",workerId:B}}}var p=[["operationId",!0,U,"task.operationId must be a non-empty string"],["activityName",!0,U,"task.activityName must be a non-empty string"],["input",!0,H,"task.input must be valid JSON"],["attempt",!1,G,"task.attempt must be a finite number"],["headers",!1,N,"task.headers must be a string map"],["workflowExecutionToken",!1,U,"task.workflowExecutionToken must be a non-empty string"],["attemptToken",!0,U,"task.attemptToken must be a non-empty string"]];function n(z){let B=L("invalid_message",z,p);if(!B.ok)return B.error;return{ok:!0,message:{type:"task",...B.values}}}function i(z){let B=z.operationId;if(!U(B))return X("invalid_message","cancel.operationId must be a non-empty string");return{ok:!0,message:{type:"cancel",operationId:B}}}function v(){return{ok:!0,message:{type:"shutdown"}}}function d(z){let B=z.protocolVersion;if(B!==D)return X("invalid_message",`registerAck.protocolVersion must be ${String(D)}`);let{workerId:Q,queue:Y,concurrency:Z,acceptedManifestDigest:$,serverCapabilities:x}=z;if(!U(Q))return X("invalid_message","registerAck.workerId must be a non-empty string");if(!U(Y))return X("invalid_message","registerAck.queue must be a non-empty string");if(typeof Z!=="number"||!Number.isFinite(Z))return X("invalid_message","registerAck.concurrency must be a finite number");if(!U($))return X("invalid_message","registerAck.acceptedManifestDigest must be a non-empty string");if(!K(x))return X("invalid_message","registerAck.serverCapabilities must be an array of non-empty strings");return{ok:!0,message:{type:"registerAck",protocolVersion:B,workerId:Q,queue:Y,concurrency:Z,acceptedManifestDigest:$,serverCapabilities:x}}}function u(z){return z==="invalid_registration"||z==="unsupported_protocol_version"||z==="deployment_conflict"||z==="registration_rejected"}function s(z){let{code:B,message:Q,supportedProtocolVersions:Y,requestedProtocolVersion:Z}=z;if(!u(B))return X("invalid_message","registerError.code is not recognized");if(typeof Q!=="string")return X("invalid_message","registerError.message must be a string");if(!Array.isArray(Y)||!Y.every((x)=>G(x)))return X("invalid_message","registerError.supportedProtocolVersions is invalid");if(Z!==void 0&&!G(Z))return X("invalid_message","registerError.requestedProtocolVersion must be a finite number");return{ok:!0,message:{type:"registerError",code:B,message:Q,supportedProtocolVersions:Y,...Z!==void 0?{requestedProtocolVersion:Z}:{}}}}function c(z){let{code:B,message:Q}=z;if(B!=="invalid_json"&&B!=="invalid_message"&&B!=="unknown_message_type"&&B!=="registration_required")return X("invalid_message","protocolError.code is not recognized");if(typeof Q!=="string")return X("invalid_message","protocolError.message must be a string");return{ok:!0,message:{type:"protocolError",code:B,message:Q}}}function xz(z){if(!j(z))return X("invalid_message","Worker protocol message must be a JSON object");let B=z.type;if(typeof B!=="string")return X("invalid_message","Worker protocol message.type must be a string");if(!k.has(B))return X("unknown_message_type",`Unknown worker message type: ${B}`);switch(B){case"register":return E(z);case"heartbeat":return R(z);case"taskResult":return A(z);default:return X("unknown_message_type",`Unknown worker message type: ${B}`)}}function Dz(z){if(!j(z))return X("invalid_message","Server protocol message must be a JSON object");let B=z.type;if(typeof B!=="string")return X("invalid_message","Server protocol message.type must be a string");if(!S.has(B))return X("unknown_message_type",`Unknown server message type: ${B}`);switch(B){case"registerAck":return d(z);case"registerError":return s(z);case"protocolError":return c(z);case"task":return n(z);case"cancel":return i(z);case"shutdown":return v();default:return X("unknown_message_type",`Unknown server message type: ${B}`)}}export{xz as parseWorkerToServerMessage,Dz as parseServerToWorkerMessage,H as isRemoteWorkerJsonValue,W as REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS,D as REMOTE_WORKER_PROTOCOL_VERSION,P as REMOTE_WORKER_PROTOCOL_JSON_SCHEMA,h as REMOTE_WORKER_MIN_PROTOCOL_VERSION,f as REMOTE_WORKER_MESSAGE_SCHEMAS,C as REMOTE_WORKER_MAX_PROTOCOL_VERSION};

package/dist/worker/registry/deployment-consistency.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Process-local enforcement that one `(deploymentName, buildId)` pair never
+ * registers two different artifact digests.
+ *
+ * A build ID is meant to identify one immutable build output. If two workers
+ * present the same deployment name and build ID with different artifact
+ * digests, at least one of them is lying about what it is running — either a
+ * build ID was reused across a redeploy with different bytes, or a worker is
+ * misconfigured. Either way, silently accepting both would let routing send
+ * work to a worker running code the operator did not intend for that build
+ * identity.
+ *
+ * This is process-local and non-durable: restart-durable enforcement needs
+ * revision-aware routing, which is not yet built. The guard also does not
+ * evict entries when a worker disconnects — surviving disconnects is the
+ * point. A redeploy that reuses a build ID with different bytes must still
+ * conflict even if every worker from the first deploy has since dropped off,
+ * because the record of what that build ID means must outlive any single
+ * connection.
+ *
+ * @module worker/registry/deployment-consistency
+ */
+/** Outcome of {@link DeploymentConsistencyGuard.checkAndRecord}. */
+export type DeploymentConsistencyResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly existingArtifactDigest: string;
+};
+/**
+ * Tracks the artifact digest first seen for each `(deploymentName, buildId)`
+ * pair for the lifetime of this process.
+ *
+ * Keyed by nested maps rather than a joined string: `deploymentName` and
+ * `buildId` are validated only as non-empty, byte-bounded strings, with no
+ * character-set restriction, so a separator-joined key could collide across
+ * two distinct pairs (e.g. `("ab", "c")` and `("a", "bc")` would
+ * both join to `"abc"`). Nested maps compare each component
+ * independently and cannot collide this way.
+ *
+ * @example
+ * ```ts
+ * import { DeploymentConsistencyGuard } from '@lostgradient/weft/server';
+ *
+ * const guard = new DeploymentConsistencyGuard();
+ * console.log(guard.checkAndRecord('billing', 'b3', 'sha256:aa').ok); // true
+ * console.log(guard.checkAndRecord('billing', 'b3', 'sha256:aa').ok); // true (same digest)
+ * console.log(guard.checkAndRecord('billing', 'b3', 'sha256:bb').ok); // false (conflict)
+ * ```
+ */
+export declare class DeploymentConsistencyGuard {
+    #private;
+    constructor();
+    /**
+     * Read-only: does `artifactDigest` conflict with any digest already
+     * recorded for `(deploymentName, buildId)`? Never records. Callers with a
+     * rejection gate between checking and committing (an admission policy, a
+     * hijack guard) must call this before that gate and call {@link record}
+     * only once every later gate has also passed, so a worker this function's
+     * caller ultimately declines cannot permanently poison a deployment/build
+     * slot with an untrusted digest.
+     */
+    check(deploymentName: string, buildId: string, artifactDigest: string): DeploymentConsistencyResult;
+    /**
+     * Record `artifactDigest` as the digest of record for `(deploymentName,
+     * buildId)` if this is the first sighting; a no-op otherwise. Callers must
+     * already have confirmed via {@link check} that this does not conflict.
+     */
+    record(deploymentName: string, buildId: string, artifactDigest: string): void;
+    /**
+     * Check whether `artifactDigest` is consistent with any digest already
+     * recorded for `(deploymentName, buildId)`, recording it as the digest of
+     * record when this is the first sighting. Convenience combining
+     * {@link check} and {@link record} for callers with no rejection gate
+     * between checking and committing.
+     */
+    checkAndRecord(deploymentName: string, buildId: string, artifactDigest: string): DeploymentConsistencyResult;
+}

package/dist/worker/registry/deployment-consistency.js

@@ -0,0 +1,27 @@
+export class DeploymentConsistencyGuard {
+  #artifactDigestByBuildIdByDeployment;
+  constructor() {
+    this.#artifactDigestByBuildIdByDeployment = new Map;
+  }
+  check(deploymentName, buildId, artifactDigest) {
+    const existingArtifactDigest = this.#artifactDigestByBuildIdByDeployment.get(deploymentName)?.get(buildId);
+    if (existingArtifactDigest === void 0 || existingArtifactDigest === artifactDigest)
+      return { ok: !0 };
+    return { ok: !1, existingArtifactDigest };
+  }
+  record(deploymentName, buildId, artifactDigest) {
+    let byBuildId = this.#artifactDigestByBuildIdByDeployment.get(deploymentName);
+    if (byBuildId === void 0) {
+      byBuildId = new Map;
+      this.#artifactDigestByBuildIdByDeployment.set(deploymentName, byBuildId);
+    }
+    if (!byBuildId.has(buildId))
+      byBuildId.set(buildId, artifactDigest);
+  }
+  checkAndRecord(deploymentName, buildId, artifactDigest) {
+    const result = this.check(deploymentName, buildId, artifactDigest);
+    if (result.ok)
+      this.record(deploymentName, buildId, artifactDigest);
+    return result;
+  }
+}

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

@@ -0,0 +1,14 @@
+import type { WorkerDrainOptions, WorkerHealth, WorkerInfo } from './types.ts';
+/** A drain marker: when it started and an optional operator-supplied reason. */
+export type DrainRecord = {
+    reason?: string;
+    startedAt: number;
+};
+export declare function createDrainRecord(options?: WorkerDrainOptions): DrainRecord;
+/**
+ * The drain record covering `worker`: its own explicit marker if set,
+ * otherwise its deployment's marker (when the worker declares a deployment).
+ */
+export declare function drainRecordForWorker(worker: WorkerInfo, deploymentDrainStates: ReadonlyMap<string, DrainRecord>): DrainRecord | undefined;
+export declare function isWorkerDraining(worker: WorkerInfo, deploymentDrainStates: ReadonlyMap<string, DrainRecord>): boolean;
+export declare function workerHealth(worker: WorkerInfo, deploymentDrainStates: ReadonlyMap<string, DrainRecord>): WorkerHealth;

package/dist/worker/registry/drain.js

@@ -0,0 +1,24 @@
+export function createDrainRecord(options) {
+  return {
+    startedAt: options?.updatedAt ?? Date.now(),
+    ...options?.reason !== void 0 ? { reason: options.reason } : {}
+  };
+}
+export function drainRecordForWorker(worker, deploymentDrainStates) {
+  if (worker.drainStartedAt !== void 0)
+    return {
+      startedAt: worker.drainStartedAt,
+      ...worker.drainReason !== void 0 ? { reason: worker.drainReason } : {}
+    };
+  if (worker.deploymentName === void 0)
+    return;
+  return deploymentDrainStates.get(worker.deploymentName);
+}
+export function isWorkerDraining(worker, deploymentDrainStates) {
+  return drainRecordForWorker(worker, deploymentDrainStates) !== void 0;
+}
+export function workerHealth(worker, deploymentDrainStates) {
+  if (!isWorkerDraining(worker, deploymentDrainStates))
+    return "active";
+  return worker.inFlight > 0 ? "draining" : "drained";
+}

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

@@ -0,0 +1,31 @@
+import type { RegisterErrorMessage } from '../protocol.ts';
+/** Number of most-recent rejection entries retained before the oldest is evicted. */
+export declare const MAX_REGISTRATION_REJECTION_ENTRIES = 200;
+/**
+ * One declined `register` attempt.
+ *
+ * Deliberately bounded content: the rejection `code` (the same taxonomy
+ * `registerError` sends on the wire), the attempted `workerId` when the frame
+ * carried one, and whichever deployment/queue identity had already been
+ * parsed by the time the gate that rejected it ran. No free-text message and
+ * no manifest content — this is an auditable event log, not a diagnostic
+ * dump. `workerId` is optional because the earliest rejection gate — a
+ * malformed or wire-shape-invalid frame — can fail before any `workerId`
+ * is known to be valid.
+ */
+export type RegistrationRejectionEntry = Readonly<{
+    code: RegisterErrorMessage['code'];
+    workerId?: string | undefined;
+    rejectedAt: number;
+    queue?: string | undefined;
+    deploymentName?: string | undefined;
+    buildId?: string | undefined;
+}>;
+/**
+ * Append `entry` to `log`, evicting the oldest entry once the log exceeds
+ * {@link MAX_REGISTRATION_REJECTION_ENTRIES}. Mutates `log` in place and
+ * returns it, matching the registry's existing in-place array conventions.
+ */
+export declare function appendRegistrationRejection(log: RegistrationRejectionEntry[], entry: RegistrationRejectionEntry): RegistrationRejectionEntry[];
+/** Return the `limit` most recent entries, newest first. */
+export declare function recentRegistrationRejections(log: readonly RegistrationRejectionEntry[], limit: number): RegistrationRejectionEntry[];

package/dist/worker/registry/rejections.js

@@ -0,0 +1,10 @@
+export const MAX_REGISTRATION_REJECTION_ENTRIES = 200;
+export function appendRegistrationRejection(log, entry) {
+  log.push(entry);
+  if (log.length > MAX_REGISTRATION_REJECTION_ENTRIES)
+    log.splice(0, log.length - MAX_REGISTRATION_REJECTION_ENTRIES);
+  return log;
+}
+export function recentRegistrationRejections(log, limit) {
+  return log.slice(Math.max(0, log.length - limit)).toReversed();
+}

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

@@ -19,7 +19,6 @@ export type WorkerSnapshot = {
     deploymentName?: string | undefined;
     buildId?: string | undefined;
     runtimeVersion?: string | undefined;
-    gitSha?: string | undefined;
 };
 /**
  * Project a single worker snapshot into a {@link WorkerSummary}.
@@ -42,7 +41,6 @@ export type WorkerDeploymentSummary = {
     deploymentName: string | null;
     buildId: string | null;
     runtimeVersion: string | null;
-    gitSha: string | null;
     health: WorkerHealth;
     workers: number;
     activeWorkers: number;
@@ -55,7 +53,6 @@ type WorkerDeploymentIdentity = {
     deploymentName?: string | null | undefined;
     buildId?: string | null | undefined;
     runtimeVersion?: string | null | undefined;
-    gitSha?: string | null | undefined;
 };
 /** Stable composite key for grouping workers by deployment identity. */
 export declare function deploymentIdentityKey(identity: WorkerDeploymentIdentity): string;

package/dist/worker/registry/summary.js

@@ -15,8 +15,7 @@ export function projectWorkerSummary(snapshot, now) {
     health: snapshot.health,
     ...snapshot.deploymentName !== void 0 ? { deploymentName: snapshot.deploymentName } : {},
     ...snapshot.buildId !== void 0 ? { buildId: snapshot.buildId } : {},
-    ...snapshot.runtimeVersion !== void 0 ? { runtimeVersion: snapshot.runtimeVersion } : {},
-    ...snapshot.gitSha !== void 0 ? { gitSha: snapshot.gitSha } : {}
+    ...snapshot.runtimeVersion !== void 0 ? { runtimeVersion: snapshot.runtimeVersion } : {}
   };
 }
 export function projectWorkerSummaries(snapshots, now) {
@@ -26,8 +25,7 @@ export function deploymentIdentityKey(identity) {
   return [
     identity.deploymentName ?? "",
     identity.buildId ?? "",
-    identity.runtimeVersion ?? "",
-    identity.gitSha ?? ""
+    identity.runtimeVersion ?? ""
   ].join("\x1F");
 }
 export function countWorkerHealth(healthValues) {
@@ -55,7 +53,6 @@ export function projectDeploymentSummary(workers, drainActive) {
     deploymentName: first?.deploymentName ?? null,
     buildId: first?.buildId ?? null,
     runtimeVersion: first?.runtimeVersion ?? null,
-    gitSha: first?.gitSha ?? null,
     health: deploymentHealth(healthValues, drainActive),
     workers: workers.length,
     activeWorkers: healthCounts.active,

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

@@ -1,3 +1,4 @@
+import type { WorkerManifest } from '../manifest/types.ts';
 import type { RemoteWorkerCapabilities } from '../protocol.ts';
 /** Lifecycle health state of a connected worker. */
 export type WorkerHealth = 'active' | 'draining' | 'drained';
@@ -5,6 +6,11 @@ export type WorkerHealth = 'active' | 'draining' | 'drained';
  * Full internal state record for a connected worker, held by the registry.
  * `drainReason` and `drainStartedAt` are present only when a worker-level
  * drain marker has been set.
+ *
+ * `manifest` and `acceptedManifestDigest` are internal — not part of
+ * {@link WorkerSummary} or any REST/JSON-RPC surface. Exposing bounded
+ * worker/deployment detail from the accepted manifest is a diagnostics
+ * concern, not a registration concern.
  */
 export interface WorkerInfo {
     id: string;
@@ -19,7 +25,8 @@ export interface WorkerInfo {
     deploymentName?: string;
     buildId?: string;
     runtimeVersion?: string;
-    gitSha?: string;
+    manifest: WorkerManifest;
+    acceptedManifestDigest: string;
     drainReason?: string;
     drainStartedAt?: number;
 }
@@ -32,7 +39,8 @@ export type WorkerRegistrationInfo = {
     deploymentName?: string;
     buildId?: string;
     runtimeVersion?: string;
-    gitSha?: string;
+    manifest: WorkerManifest;
+    acceptedManifestDigest: string;
     startedAt?: number;
     capabilities?: RemoteWorkerCapabilities;
 };
@@ -60,7 +68,6 @@ export type WorkerSummary = {
     deploymentName?: string | undefined;
     buildId?: string | undefined;
     runtimeVersion?: string | undefined;
-    gitSha?: string | undefined;
 };
 export type WorkerDrainMutationResult = {
     target: 'worker';

package/dist/worker/registry.d.ts

@@ -1,5 +1,8 @@
+import { type DeploymentConsistencyResult } from './registry/deployment-consistency.ts';
+import { type RegistrationRejectionEntry } from './registry/rejections.ts';
 import { type WorkerDeploymentSummary } from './registry/summary.ts';
 import type { InFlightTask, RoutingOptions, RoutingPolicy, WorkerDrainMutationResult, WorkerDrainOptions, WorkerInfo, WorkerRegistrationInfo, WorkerRegistryOptions, WorkerSummary } from './registry/types.ts';
+export type { RegistrationRejectionEntry } from './registry/rejections.ts';
 export type { WorkerDeploymentSummary } from './registry/summary.ts';
 export type { InFlightTask, RoutingOptions, RoutingPolicy, WorkerDrainMutationResult, WorkerDrainOptions, WorkerHealth, WorkerInfo, WorkerRegistrationInfo, WorkerRegistryOptions, WorkerSummary, } from './registry/types.ts';
 /**
@@ -12,9 +15,27 @@ export type { InFlightTask, RoutingOptions, RoutingPolicy, WorkerDrainMutationRe
  *
  * @example
  * ```ts
- * import { WorkerRegistry } from '@lostgradient/weft';
+ * import { WorkerRegistry, type WorkerManifest } from '@lostgradient/weft';
+ *
+ * const manifest: WorkerManifest = {
+ *   manifestVersion: 1,
+ *   protocolVersion: 3,
+ *   sdkVersion: '0.18.0',
+ *   runtime: { name: 'bun', version: '1.3.14' },
+ *   deployment: { name: 'billing', buildId: 'b3', artifactDigest: 'sha256:41d0' },
+ *   workflows: {},
+ *   capabilities: {},
+ * };
+ *
  * const registry = new WorkerRegistry({ policy: 'least-loaded' });
- * registry.register({ id: 'worker-1', queue: 'default', activities: ['sendEmail'], concurrency: 10 });
+ * registry.register({
+ *   id: 'worker-1',
+ *   queue: 'default',
+ *   activities: ['sendEmail'],
+ *   concurrency: 10,
+ *   manifest,
+ *   acceptedManifestDigest: 'sha256:deadbeef',
+ * });
  * const best = registry.findWorker('sendEmail', { queue: 'default' });
  * ```
  */
@@ -23,6 +44,16 @@ export declare class WorkerRegistry {
     constructor(options?: WorkerRegistryOptions);
     /** The routing policy this registry was configured with. */
     get policy(): RoutingPolicy;
+    /**
+     * Read-only check of a manifest's `(deploymentName, buildId,
+     * artifactDigest)` against digests previously seen for that deployment and
+     * build. Callers with a later rejection gate must call
+     * {@link recordDeploymentConsistency} only once every such gate has
+     * passed, so a declined worker cannot poison a deployment/build slot.
+     */
+    checkDeploymentConsistency(deploymentName: string, buildId: string, artifactDigest: string): DeploymentConsistencyResult;
+    /** Record `artifactDigest` for `(deploymentName, buildId)` once every rejection gate has passed. */
+    recordDeploymentConsistency(deploymentName: string, buildId: string, artifactDigest: string): void;
     /** Register a worker. */
     register(info: WorkerRegistrationInfo): void;
     /** Unregister a worker. Purges fair-share counters and in-flight task entries for this worker. */
@@ -46,6 +77,16 @@ 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 | undefined, attemptToken: string): void;
+    /**
+     * Undo exactly `assignTask`'s effects — capacity increment, fair-share
+     * count, and the in-flight entry — when the durable claim that was
+     * supposed to follow the reservation never committed. Distinct from
+     * {@link completeTask} even though the body is identical: this path means
+     * "the reservation was never realized," not "the task finished," and
+     * keeping the names apart stops a reader from mistaking an aborted claim
+     * for a normal completion at the call site.
+     */
+    releaseReservation(operationId: string): InFlightTask | undefined;
     /** Return tasks whose deadline has passed and remove them from tracking. */
     checkExpiredTasks(now: number): InFlightTask[];
     /**
@@ -76,6 +117,10 @@ export declare class WorkerRegistry {
     getWorker(workerId: string): WorkerInfo | undefined;
     /** Get all registered workers. */
     getAll(): WorkerInfo[];
+    /** Record one declined `register` attempt, evicting the oldest once the bounded log is full. */
+    recordRejection(entry: RegistrationRejectionEntry): void;
+    /** Return the `limit` most recently recorded rejections, newest first. */
+    getRecentRejections(limit: number): RegistrationRejectionEntry[];
     /** Mark one connected worker as draining so routing excludes it from new tasks. */
     markWorkerDraining(workerId: string, options?: WorkerDrainOptions): WorkerDrainMutationResult | undefined;
     /** Clear an explicit worker drain marker. Deployment-level drains can still apply. */