@lostgradient/weft 0.3.0 → 0.4.0

package/dist/version.d.ts

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

package/dist/version.js

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

package/dist/worker/protocol.js

@@ -1,2 +1,2 @@
 // @bun
-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};
+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);var e=(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},zz=(z,B,D)=>{let X=(U)=>B=D?new SuppressedError(U,B,"An error was suppressed during disposal"):(D=!0,U),Y=(U)=>{while(U=z.pop())try{var L=U[1]&&U[1].call(U[2]);if(U[0])return Promise.resolve(L).then(Y,(G)=>(X(G),Y()))}catch(G){X(G)}if(D)throw B};return Y()};function b(z){return z!==null&&typeof z==="object"&&!Array.isArray(z)}function $(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($);if(!b(z))return!1;return Object.values(z).every($)}function Z(z){return typeof z==="string"&&z.length>0}function J(z){return Array.isArray(z)&&z.every(Z)}function w(z){if(!b(z))return!1;return Object.values(z).every((B)=>typeof B==="string")}function q(z){if(!b(z))return!1;return Object.values(z).every($)}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[Y,U,L,G]of D){let j=B[Y];if(j===void 0){if(U)return{ok:!1,error:Q(z,G)};continue}if(!L(j))return{ok:!1,error:Q(z,G)};X[Y]=j}return{ok:!0,values:X}}var x=2,P=2,g=2,_=[2];var K={$ref:"#/$defs/jsonValue"},A={type:"object",additionalProperties:K},y={type:"object",additionalProperties:{type:"string"}},F={const:x},N={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:K,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:K,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(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:A,messages:N}};function C(z){let B=z.attemptToken;if(B===void 0)return{ok:!0,message:{}};if(!Z(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(!$(D))return Q("invalid_message","completed taskResult.value must be valid JSON");let X=C(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=C(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 Y=C(B);if(!Y.ok)return Y;return{ok:!0,message:{type:"taskResult",operationId:z,status:"cancelled",error:D,...X===!0?{cancelled:X}:{},...Y.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(!Z(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===x)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 n=[["workerId",!0,Z,"register.workerId must be a non-empty string"],["activities",!0,J,"register.activities must be an array of non-empty strings"],["concurrency",!1,H,"register.concurrency must be a finite number"],["queue",!1,Z,"register.queue must be a non-empty string"],["deploymentName",!1,Z,"register.deploymentName must be a non-empty string when present"],["buildId",!1,Z,"register.buildId must be a non-empty string when present"],["runtimeVersion",!1,Z,"register.runtimeVersion must be a non-empty string when present"],["gitSha",!1,Z,"register.gitSha must be a non-empty string when present"],["startedAt",!1,H,"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=f("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(!Z(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,Z,"task.operationId must be a non-empty string"],["activityName",!0,Z,"task.activityName must be a non-empty string"],["input",!0,$,"task.input must be valid JSON"],["attempt",!1,H,"task.attempt must be a finite number"],["headers",!1,w,"task.headers must be a string map"],["attemptToken",!1,Z,"task.attemptToken must be a non-empty string"]];function u(z){let B=f("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(!Z(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!==x)return Q("invalid_message",`registerAck.protocolVersion must be ${String(x)}`);let{workerId:D,queue:X,activities:Y,concurrency:U}=z;if(!Z(D))return Q("invalid_message","registerAck.workerId must be a non-empty string");if(!Z(X))return Q("invalid_message","registerAck.queue must be a non-empty string");if(!J(Y))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:Y,concurrency:U}}}function l(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((L)=>L===x))return Q("invalid_message","registerError.supportedProtocolVersions is invalid");if(Y!==void 0&&!H(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 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 Hz(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(!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 Lz(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(!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{Hz as parseWorkerToServerMessage,Lz as parseServerToWorkerMessage,$ as isRemoteWorkerJsonValue,_ as REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS,x as REMOTE_WORKER_PROTOCOL_VERSION,T as REMOTE_WORKER_PROTOCOL_JSON_SCHEMA,P as REMOTE_WORKER_MIN_PROTOCOL_VERSION,N as REMOTE_WORKER_MESSAGE_SCHEMAS,g as REMOTE_WORKER_MAX_PROTOCOL_VERSION};

package/dist/workers/worker-replay-state.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The worker-side replay state: the per-run record of cached step outcomes the worker
+ * runner rebuilds from a checkpoint, plus the helpers that create it and fold a resumed
+ * operation outcome back into it. Extracted from `workflow-runner.ts` so that module
+ * stays under the line cap; the runner imports these back and owns the generator-driving
+ * flow that consumes them.
+ *
+ * @module workers/worker-replay-state
+ */
+import type { Checkpoint, OperationOutcome, WorkerReplayOperationFailure } from '../core/types.ts';
+import type { WorkerReplayOperationSignature } from '../core/worker-protocol.ts';
+/** Per-run worker replay state, rebuilt from a checkpoint on every run/recovery. */
+export interface WorkerReplayState {
+    checkpoint: Checkpoint;
+    accumulatedResults: Map<number, unknown>;
+    signatures: Map<number, WorkerReplayOperationSignature>;
+    failedOutcomes: Map<number, WorkerReplayOperationFailure>;
+    nextStepIndex: number;
+    pendingStepIndex: number | null;
+    maxProtocolMessageBytes: number | undefined;
+}
+export declare function createReplayState(message: {
+    workflowId: string;
+    checkpoint?: ArrayBuffer;
+    maxProtocolMessageBytes?: number;
+}): WorkerReplayState;
+/**
+ * Fold a resumed operation outcome into the replay state at the pending step: cache a
+ * success in `accumulatedResults`, a failure in `failedOutcomes` (mutually exclusive),
+ * and advance `nextStepIndex` past it. A no-op when there is no pending step or outcome.
+ */
+export declare function recordOperationOutcome(replayState: WorkerReplayState, outcome: OperationOutcome | undefined): void;

package/dist/workers/worker-replay-state.js

@@ -0,0 +1,35 @@
+import { createCheckpoint, deserializeCheckpoint } from "../core/checkpoint.js";
+import {
+  hydrateCheckpointReplayStateFromPayload,
+  readCheckpointReplayPayload
+} from "../core/engine/checkpoint-replay.js";
+function deserializeWorkerCheckpoint(checkpointBytes) {
+  const checkpoint = deserializeCheckpoint(new Uint8Array(checkpointBytes));
+  return hydrateCheckpointReplayStateFromPayload(checkpoint, readCheckpointReplayPayload(checkpoint));
+}
+export function createReplayState(message) {
+  const checkpoint = message.checkpoint && message.checkpoint.byteLength > 0 ? deserializeWorkerCheckpoint(message.checkpoint) : createCheckpoint(message.workflowId, "worker");
+  return {
+    checkpoint,
+    accumulatedResults: new Map(checkpoint.accumulatedResults),
+    signatures: new Map(checkpoint.workerReplaySignatures ?? []),
+    failedOutcomes: new Map(checkpoint.workerReplayFailures ?? []),
+    nextStepIndex: 0,
+    pendingStepIndex: null,
+    maxProtocolMessageBytes: message.maxProtocolMessageBytes
+  };
+}
+export function recordOperationOutcome(replayState, outcome) {
+  const pendingStepIndex = replayState.pendingStepIndex;
+  if (pendingStepIndex === null || !outcome)
+    return;
+  if (outcome.status === "failed") {
+    replayState.failedOutcomes.set(pendingStepIndex, outcome);
+    replayState.accumulatedResults.delete(pendingStepIndex);
+  } else {
+    replayState.accumulatedResults.set(pendingStepIndex, outcome.value);
+    replayState.failedOutcomes.delete(pendingStepIndex);
+  }
+  replayState.nextStepIndex = pendingStepIndex + 1;
+  replayState.pendingStepIndex = null;
+}

package/dist/workers/worker-state-namespace.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The worker-side `ctx.state` namespace. Built locally from a `run` message — worker
+ * mode supports `execution`/`workflow` atomic state but rejects `session` state, which
+ * needs the engine host. Extracted from `workflow-runner.ts` so that module stays under
+ * the line cap.
+ *
+ * @module workers/worker-state-namespace
+ */
+import type { WorkflowStateNamespace } from '../core/types.ts';
+/** The `run`-message fields the state namespace needs to scope atomic state. */
+export interface WorkerStateNamespaceScope {
+    workflowId: string;
+    workflowType: string;
+    executionStateOwnerId?: string;
+}
+/**
+ * Build the worker-side {@link WorkflowStateNamespace}. `execution` and `workflow`
+ * scopes are supported; `session` throws because session state is an engine-host
+ * capability the worker process cannot reach.
+ */
+export declare function createWorkerStateNamespace(message: WorkerStateNamespaceScope): WorkflowStateNamespace;

package/dist/workers/worker-state-namespace.js

@@ -0,0 +1,13 @@
+import { WorkflowAtomicStateHandle } from "../core/context/state-namespace.js";
+export function createWorkerStateNamespace(message) {
+  return {
+    session: (_key) => {
+      throw Error(`Workflow type "${message.workflowType}" called ctx.state.session(), which is not supported in worker execution mode. Use workflowExecutionMode: 'inline' for checkpoint-local session state, or use ctx.state.workflow() or ctx.state.execution() instead.`);
+    },
+    execution: (key, options) => new WorkflowAtomicStateHandle({
+      type: "execution",
+      ownerWorkflowId: message.executionStateOwnerId ?? message.workflowId
+    }, key, options),
+    workflow: (key, options) => new WorkflowAtomicStateHandle({ type: "workflow", workflowType: message.workflowType }, key, options)
+  };
+}

package/dist/workers/workflow-runner.d.ts

@@ -1,13 +1,17 @@
-import type { Checkpoint, OperationOutcome, WorkerOutboundMessage, WorkerReplayOperationFailure, WorkflowContext, WorkflowStateNamespace } from '../core/types.ts';
-import { type WorkerReplayOperationSignature } from '../core/worker-protocol.ts';
+import type { ContextOperationRequest } from '../core/context.ts';
+import { type WorkerLoggerReplayState } from '../core/context/workflow-logger.ts';
+import type { OperationOutcome, WorkerOutboundMessage, WorkflowContext, WorkflowLogger, WorkflowLogRecord, WorkflowStateNamespace } from '../core/types.ts';
+import { type WorkerReplayState } from './worker-replay-state.ts';
 /**
  * Subset of {@link WorkflowContext} that the worker-side runner can build
  * locally from the `run` message. Engine-side fields (`executionTimeRemaining`
  * in particular) are stub values because the worker has no clock authority —
  * any user code reading them will see static numbers, not live deadlines.
  */
-export type WorkerWorkflowContext = Pick<WorkflowContext, 'workflowId' | 'signal' | 'startedAt'> & {
+export type WorkerWorkflowContext = Pick<WorkflowContext, 'workflowId' | 'workflowType' | 'signal' | 'startedAt'> & {
     readonly state: WorkflowStateNamespace;
+    readonly log: WorkflowLogger;
+    getVersion(changeId: string, minSupported: number, maxSupported: number): Generator<ContextOperationRequest, number, unknown>;
 };
 interface RunMessageShape {
     workflowId: string;
@@ -21,23 +25,23 @@ interface RunMessageShape {
  * Construct the worker-side `ctx` argument that gets passed as the first
  * positional parameter to a registered workflow handler. Engine-side fields
  * not represented in the `run` message are intentionally omitted — only the
- * `Pick`-ed subset above is populated.
+ * `Pick`-ed subset above is populated. `forwardLog`, when provided by the worker
+ * entry (host has an `onLog` sink), routes `ctx.log` records to the host (#529).
  */
-export declare function createWorkerWorkflowContext(message: RunMessageShape, controller: AbortController): WorkerWorkflowContext;
+export declare function createWorkerWorkflowContext(message: RunMessageShape, controller: AbortController, getReplayState: () => WorkerLoggerReplayState | undefined, forwardLog?: (record: WorkflowLogRecord) => void, getVersionReplayState?: () => WorkerReplayState | undefined): WorkerWorkflowContext;
+/**
+ * Posts a forwarded `ctx.log` message to the host, size-checking against the current
+ * `maxProtocolMessageBytes`. Throwing on oversize is intentional — the shared logger
+ * factory catches it and falls the record back to the worker console (#529).
+ */
+export type WorkerLogPoster = (message: Extract<WorkerOutboundMessage, {
+    type: 'log';
+}>, maxProtocolMessageBytes: number | undefined) => void;
 export interface WorkflowRunnerContext {
     generators: Map<string, AsyncGenerator>;
     abortControllers: Map<string, AbortController>;
     replayStates: Map<string, WorkerReplayState>;
 }
-interface WorkerReplayState {
-    checkpoint: Checkpoint;
-    accumulatedResults: Map<number, unknown>;
-    signatures: Map<number, WorkerReplayOperationSignature>;
-    failedOutcomes: Map<number, WorkerReplayOperationFailure>;
-    nextStepIndex: number;
-    pendingStepIndex: number | null;
-    maxProtocolMessageBytes: number | undefined;
-}
 export declare function createWorkflowRunnerContext(): WorkflowRunnerContext;
 export declare function handleRunMessage(context: WorkflowRunnerContext, message: {
     workflowId: string;
@@ -48,7 +52,7 @@ export declare function handleRunMessage(context: WorkflowRunnerContext, message
     executionStateOwnerId?: string;
     deadline?: number;
     headers?: [string, string][];
-}, getWorkflowHandler: (type: string) => ((ctx: WorkerWorkflowContext, input: unknown) => AsyncGenerator) | undefined): Promise<WorkerOutboundMessage>;
+}, getWorkflowHandler: (type: string) => ((ctx: WorkerWorkflowContext, input: unknown) => AsyncGenerator) | undefined, postLog?: WorkerLogPoster): Promise<WorkerOutboundMessage>;
 export declare function handleResumeMessage(context: WorkflowRunnerContext, message: {
     workflowId: string;
     result: unknown;

package/dist/workers/workflow-runner.js

@@ -1,36 +1,75 @@
+import { copyBytesToArrayBuffer } from "../core/byte-arrays.js";
+import { advanceCheckpoint, serializeCheckpoint } from "../core/checkpoint.js";
+import { resolveWorkflowVersionPatch } from "../core/context/version-patching.js";
 import {
-  advanceCheckpoint,
-  createCheckpoint,
-  deserializeCheckpoint,
-  serializeCheckpoint
-} from "../core/checkpoint.js";
-import { WorkflowAtomicStateHandle } from "../core/context/state-namespace.js";
+  createWorkerWorkflowLogger
+} from "../core/context/workflow-logger.js";
+import {
+  attachTransientCheckpointReplayPayload,
+  pruneCheckpointReplayState
+} from "../core/engine/checkpoint-replay.js";
 import {
   classifyErrorAsFailureCategory,
   errorFromFailedOperationOutcome
 } from "../core/failure-categories.js";
 import {
   createWorkerReplayOperationSignature,
+  WORKER_PROTOCOL_VERSION,
   workerReplayOperationSignaturesEqual
 } from "../core/worker-protocol.js";
-export function createWorkerWorkflowContext(message, controller) {
+import {
+  createReplayState,
+  recordOperationOutcome
+} from "./worker-replay-state.js";
+import { createWorkerStateNamespace } from "./worker-state-namespace.js";
+export function createWorkerWorkflowContext(message, controller, getReplayState, forwardLog, getVersionReplayState = () => {
+  return;
+}) {
   return {
     workflowId: message.workflowId,
+    workflowType: message.workflowType,
     signal: controller.signal,
     startedAt: Date.now(),
-    state: createWorkerStateNamespace(message)
+    state: createWorkerStateNamespace(message),
+    log: createWorkerWorkflowLogger(message.workflowId, message.workflowType, getReplayState, forwardLog),
+    getVersion: (changeId, minSupported, maxSupported) => workerGetVersion(message.workflowId, getVersionReplayState, changeId, minSupported, maxSupported)
   };
 }
-function createWorkerStateNamespace(message) {
-  return {
-    session: (_key) => {
-      throw Error("ctx.state.session() is not supported in worker execution mode. Construct the engine without `workerExecution` to use session state.");
-    },
-    execution: (key, options) => new WorkflowAtomicStateHandle({
-      type: "execution",
-      ownerWorkflowId: message.executionStateOwnerId ?? message.workflowId
-    }, key, options),
-    workflow: (key, options) => new WorkflowAtomicStateHandle({ type: "workflow", workflowType: message.workflowType }, key, options)
+function* workerGetVersion(workflowId, getReplayState, changeId, minSupported, maxSupported) {
+  const replayState = getReplayState();
+  if (!replayState)
+    throw Error(`No active replay state for workflow: ${workflowId}`);
+  const stepIndex = replayState.nextStepIndex, resolution = resolveWorkflowVersionPatch(replayState.checkpoint.locals, changeId, minSupported, maxSupported);
+  replayState.checkpoint = {
+    ...replayState.checkpoint,
+    locals: resolution.checkpointLocals
+  };
+  const operation = {
+    type: "get-version",
+    operationId: crypto.randomUUID(),
+    changeId,
+    minSupported,
+    maxSupported,
+    version: resolution.version
+  };
+  if (!resolution.newlyPinned && !replayState.signatures.has(stepIndex)) {
+    replayState.nextStepIndex = stepIndex + 1;
+    return resolution.version;
+  }
+  const result = yield operation;
+  replayState.accumulatedResults.delete(stepIndex);
+  return result;
+}
+function buildLogForwarder(workflowId, maxProtocolMessageBytes, postLog) {
+  if (postLog === void 0)
+    return;
+  return (record) => {
+    postLog({
+      type: "log",
+      protocolVersion: WORKER_PROTOCOL_VERSION,
+      workflowId,
+      record
+    }, maxProtocolMessageBytes);
   };
 }
 export function createWorkflowRunnerContext() {
@@ -40,7 +79,7 @@ export function createWorkflowRunnerContext() {
     replayStates: new Map
   };
 }
-export async function handleRunMessage(context, message, getWorkflowHandler) {
+export async function handleRunMessage(context, message, getWorkflowHandler, postLog) {
   const handler = getWorkflowHandler(message.workflowType);
   if (!handler)
     return {
@@ -52,9 +91,8 @@ export async function handleRunMessage(context, message, getWorkflowHandler) {
   const controller = new AbortController;
   context.abortControllers.set(message.workflowId, controller);
   try {
-    const workerContext = createWorkerWorkflowContext(message, controller), generator = handler(workerContext, message.input);
     context.replayStates.set(message.workflowId, createReplayState(message));
-    const step = await generator.next();
+    const workerContext = createWorkerWorkflowContext(message, controller, () => context.replayStates.get(message.workflowId), buildLogForwarder(message.workflowId, message.maxProtocolMessageBytes, postLog), () => context.replayStates.get(message.workflowId)), generator = handler(workerContext, message.input), step = await generator.next();
     return await processGeneratorStep(context, message.workflowId, generator, step);
   } catch (error) {
     cleanupWorkflowRunnerState(context, message.workflowId);
@@ -168,46 +206,21 @@ async function processGeneratorStep(context, workflowId, generator, step) {
           failureCategory: "system"
         };
       }
+      replayState.checkpoint = pruneWorkerCheckpoint(replayState, replayState.checkpoint, stepIndex);
     } else {
       replayState.signatures.set(stepIndex, signature);
-      replayState.checkpoint = advanceWorkerCheckpoint(replayState);
+      replayState.checkpoint = advanceWorkerCheckpoint(replayState, stepIndex);
     }
     replayState.pendingStepIndex = stepIndex;
     context.generators.set(workflowId, generator);
     return {
       type: "checkpoint",
       workflowId,
-      checkpoint: toArrayBuffer(serializeCheckpoint(replayState.checkpoint)),
+      checkpoint: copyBytesToArrayBuffer(serializeCheckpoint(replayState.checkpoint)),
       operationRequest
     };
   }
 }
-function createReplayState(message) {
-  const checkpoint = message.checkpoint && message.checkpoint.byteLength > 0 ? deserializeCheckpoint(new Uint8Array(message.checkpoint)) : createCheckpoint(message.workflowId, "worker");
-  return {
-    checkpoint,
-    accumulatedResults: new Map(checkpoint.accumulatedResults),
-    signatures: new Map(checkpoint.workerReplaySignatures ?? []),
-    failedOutcomes: new Map(checkpoint.workerReplayFailures ?? []),
-    nextStepIndex: 0,
-    pendingStepIndex: null,
-    maxProtocolMessageBytes: message.maxProtocolMessageBytes
-  };
-}
-function recordOperationOutcome(replayState, outcome) {
-  const pendingStepIndex = replayState.pendingStepIndex;
-  if (pendingStepIndex === null || !outcome)
-    return;
-  if (outcome.status === "failed") {
-    replayState.failedOutcomes.set(pendingStepIndex, outcome);
-    replayState.accumulatedResults.delete(pendingStepIndex);
-  } else {
-    replayState.accumulatedResults.set(pendingStepIndex, outcome.value);
-    replayState.failedOutcomes.delete(pendingStepIndex);
-  }
-  replayState.nextStepIndex = pendingStepIndex + 1;
-  replayState.pendingStepIndex = null;
-}
 function hasCachedWorkerOutcome(replayState, stepIndex) {
   return replayState.accumulatedResults.has(stepIndex) || replayState.failedOutcomes.has(stepIndex);
 }
@@ -217,21 +230,20 @@ async function replayGeneratorStep(generator, replayState, stepIndex) {
     return await generator.throw(errorFromFailedOperationOutcome(failedOutcome));
   return await generator.next(replayState.accumulatedResults.get(stepIndex));
 }
-function advanceWorkerCheckpoint(replayState) {
+function advanceWorkerCheckpoint(replayState, pendingOperationStep) {
   const advanced = advanceCheckpoint(replayState.checkpoint, replayState.checkpoint.locals, {
     accumulatedResults: [...replayState.accumulatedResults]
-  }), workerReplayFailures = [...replayState.failedOutcomes], advancedCheckpoint = { ...advanced };
-  delete advancedCheckpoint.workerReplayFailures;
-  return {
-    ...advancedCheckpoint,
+  });
+  return pruneWorkerCheckpoint(replayState, advanced, pendingOperationStep);
+}
+function pruneWorkerCheckpoint(replayState, checkpoint, pendingOperationStep) {
+  const workerReplayFailures = [...replayState.failedOutcomes], { workerReplayFailures: _oldWorkerReplayFailures, ...checkpointWithoutFailures } = checkpoint, workerCheckpoint = {
+    ...checkpointWithoutFailures,
+    accumulatedResults: [...replayState.accumulatedResults],
     workerReplaySignatures: [...replayState.signatures],
     ...workerReplayFailures.length === 0 ? {} : { workerReplayFailures }
-  };
-}
-function toArrayBuffer(bytes) {
-  const copy = new Uint8Array(bytes.byteLength);
-  copy.set(bytes);
-  return copy.buffer;
+  }, pruned = pruneCheckpointReplayState(workerCheckpoint, pendingOperationStep);
+  return attachTransientCheckpointReplayPayload(pruned.checkpoint, pruned.replayPayload);
 }
 export function cleanupWorkflowRunnerState(context, workflowId) {
   context.generators.delete(workflowId);

package/dist/workers/workflow-worker-entry.js

@@ -10,14 +10,17 @@ import {
   handleResumeMessage,
   handleRunMessage
 } from "./workflow-runner.js";
-const workerPostMessage = self.postMessage.bind(self), workerClose = "close" in self && typeof self.close === "function" ? self.close.bind(self) : void 0;
+const workerPostMessage = self.postMessage.bind(self), workerClose = "close" in self && typeof self.close === "function" ? self.close.bind(self) : void 0, postLogMessage = (message, maxProtocolMessageBytes) => {
+  assertWorkerProtocolMessageWithinLimit(message, maxProtocolMessageBytes);
+  workerPostMessage(message);
+};
 export function initializeWorkerMessageLoop(getWorkflowHandler) {
   const runnerContext = createWorkflowRunnerContext();
   self.addEventListener("message", async (event) => {
     const message = event.data;
     switch (message.type) {
       case "run": {
-        const response = await handleRunMessage(runnerContext, message, getWorkflowHandler);
+        const response = await handleRunMessage(runnerContext, message, getWorkflowHandler, message.hostHasLogSink ? postLogMessage : void 0);
         postOutboundMessage(runnerContext, response, message);
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lostgradient/weft",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A Bun-native durable execution engine with pluggable key-value storage.",
   "keywords": [
     "bun",
@@ -80,6 +80,10 @@
       "import": "./dist/storage/text-value-import.js",
       "default": "./dist/storage/text-value-import.js"
     },
+    "./storage/testing": {
+      "types": "./dist/storage/testing.d.ts",
+      "bun": "./dist/storage/testing.js"
+    },
     "./storage/sqlite": {
       "types": "./dist/storage/sqlite.d.ts",
       "bun": "./dist/storage/bun-sql.js",