@lostgradient/weft 0.2.1 → 0.4.0

package/dist/worker/registry.js

@@ -1,5 +1,10 @@
-import { compareScores, scoreWorker } from "./registry/fair-share.js";
-import { matchesWorkerCapabilities, pickLeastLoaded } from "./registry/routing.js";
+import { FairShareCounters } from "./registry/fair-share.js";
+import {
+  matchesWorkerCapabilities,
+  pickFairShare,
+  pickLeastLoaded,
+  pickRoundRobin
+} from "./registry/routing.js";
 import {
   deploymentHealth,
   projectDeploymentSummaries,
@@ -19,7 +24,7 @@ export class WorkerRegistry {
     this.#deploymentDrainStates = new Map;
     this.#policy = options?.policy ?? "least-loaded";
     this.#roundRobinCursor = new Map;
-    this.#fairShareCounts = new Map;
+    this.#fairShareCounts = new FairShareCounters;
   }
   get policy() {
     return this.#policy;
@@ -51,7 +56,7 @@ export class WorkerRegistry {
     if (info === void 0)
       return;
     this.#workers.delete(workerId);
-    this.#fairShareCounts.delete(workerId);
+    this.#fairShareCounts.purge(workerId);
     for (const [operationId, task] of this.#inFlightTasks)
       if (task.workerId === workerId)
         this.#inFlightTasks.delete(operationId);
@@ -99,39 +104,23 @@ export class WorkerRegistry {
   }
   #selectByPolicy(eligible, queue, activityName, fairShareKey) {
     if (this.#policy === "round-robin")
-      return this.#pickRoundRobin(eligible, queue, activityName);
+      return pickRoundRobin(eligible, this.#roundRobinCursor, queue, activityName);
     if (this.#policy === "fair-share" && fairShareKey !== void 0)
-      return this.#pickFairShare(eligible, fairShareKey);
+      return pickFairShare(eligible, this.#fairShareCounts, fairShareKey);
     return pickLeastLoaded(eligible);
   }
-  #pickRoundRobin(eligible, queue, activityName) {
-    const key = `${queue ?? "__default__"}::${activityName}`, cursor = this.#roundRobinCursor.get(key) ?? 0, pick = eligible[cursor % eligible.length];
-    this.#roundRobinCursor.set(key, cursor + 1);
-    return pick;
-  }
-  #pickFairShare(eligible, fairShareKey) {
-    const winner = eligible.map((worker) => scoreWorker({
-      id: worker.id,
-      inFlight: worker.inFlight,
-      keyLoad: this.#fairShareCounts.get(worker.id)?.get(fairShareKey) ?? 0
-    })).reduce((best, candidate) => compareScores(candidate, best) < 0 ? candidate : best);
-    return this.#workers.get(winner.id);
-  }
-  assignTask(workerId, operationId, visibilityTimeout, fairShareKey) {
+  assignTask(workerId, operationId, visibilityTimeout, fairShareKey, attemptToken) {
     const deadline = Date.now() + visibilityTimeout, task = {
       operationId,
       workerId,
       deadline,
       visibilityTimeout
     };
+    if (attemptToken !== void 0)
+      task.attemptToken = attemptToken;
     if (fairShareKey !== void 0) {
       task.fairShareKey = fairShareKey;
-      let workerCounts = this.#fairShareCounts.get(workerId);
-      if (workerCounts === void 0) {
-        workerCounts = new Map;
-        this.#fairShareCounts.set(workerId, workerCounts);
-      }
-      workerCounts.set(fairShareKey, (workerCounts.get(fairShareKey) ?? 0) + 1);
+      this.#fairShareCounts.increment(workerId, fairShareKey);
     }
     this.#inFlightTasks.set(operationId, task);
     this.taskAssigned(workerId);
@@ -164,6 +153,14 @@ export class WorkerRegistry {
   isAssignedToWorker(operationId, workerId) {
     return this.#inFlightTasks.get(operationId)?.workerId === workerId;
   }
+  isAssignedToAttempt(operationId, workerId, attemptToken) {
+    const task = this.#inFlightTasks.get(operationId);
+    if (task === void 0 || task.workerId !== workerId)
+      return !1;
+    if (task.attemptToken === void 0 || attemptToken === void 0)
+      return !0;
+    return task.attemptToken === attemptToken;
+  }
   isAssigned(operationId) {
     return this.#inFlightTasks.has(operationId);
   }
@@ -285,16 +282,7 @@ export class WorkerRegistry {
   #releaseFairShare(task) {
     if (task.fairShareKey === void 0)
       return;
-    const workerCounts = this.#fairShareCounts.get(task.workerId);
-    if (workerCounts === void 0)
-      return;
-    const current = workerCounts.get(task.fairShareKey) ?? 0, next = Math.max(0, current - 1);
-    if (next === 0) {
-      workerCounts.delete(task.fairShareKey);
-      if (workerCounts.size === 0)
-        this.#fairShareCounts.delete(task.workerId);
-    } else
-      workerCounts.set(task.fairShareKey, next);
+    this.#fairShareCounts.release(task.workerId, task.fairShareKey);
   }
 }
 function createDrainRecord(options) {

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.2.1",
+  "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",
@@ -107,6 +111,12 @@
       "import": "./dist/storage/turso.js",
       "default": "./dist/storage/turso.js"
     },
+    "./storage/neon": {
+      "types": "./dist/storage/neon.d.ts",
+      "bun": "./dist/storage/neon.js",
+      "import": "./dist/storage/neon.js",
+      "default": "./dist/storage/neon.js"
+    },
     "./storage/indexeddb": {
       "types": "./dist/storage/indexeddb.d.ts",
       "import": "./dist/storage/indexeddb.js",
@@ -202,18 +212,19 @@
     "lint": "oxlint --type-aware --tsconfig ./tsconfig.json --report-unused-disable-directives-severity=error && bun run scripts/check-lint-disables.ts && bun run scripts/check-import-cycles.ts && bun run scripts/check-internal-imports.ts && bun run scripts/check-engine-internals-field-access.ts && bun run scripts/check-definition-vocabulary.ts && bun run scripts/check-catalog-completeness.ts && bun run scripts/check-catalog-drift.ts && bun run scripts/check-type-ergonomics.ts",
     "lint:fix": "oxlint --fix --type-aware --tsconfig ./tsconfig.json",
     "markdown-doctests:inventory": "bun run scripts/extract-markdown-doctests.ts inventory",
-    "prepack": "bun run build && bun run verify:exports && bun run verify:portability && bun run verify:markdown-doctests && bun run verify:jsdoc && bun run verify:jsdoc:doctests && bun run verify:jsdoc:declarations && bun run check:package-contents && bun run validate:package-consumers",
+    "prepack": "bun run scripts/run-gates.ts prepack",
     "pr:title": "bun run scripts/pr-title.ts",
     "prepare": "husky",
     "prepublishOnly": "bun run validate",
     "start": "bun run src/index.ts",
-    "test": "bun test --timeout 15000 --path-ignore-patterns='src/benchmarks/**' --path-ignore-patterns='examples/checkout/**' --path-ignore-patterns='src/service-worker/service-worker-browser.test.ts' --path-ignore-patterns='src/storage/indexeddb-browser.test.ts' --path-ignore-patterns='src/storage/web-extension-browser.test.ts' && bun test src/benchmarks --timeout 15000 --parallel=1",
+    "test": "bun test --timeout 15000 --path-ignore-patterns='src/benchmarks/**' --path-ignore-patterns='examples/checkout/**' --path-ignore-patterns='src/service-worker/service-worker-browser.test.ts' --path-ignore-patterns='src/storage/indexeddb-browser.test.ts' --path-ignore-patterns='src/storage/web-extension-browser.test.ts'",
+    "test:benchmarks": "bun test src/benchmarks --timeout 15000 --parallel=1",
     "test:browser-smoke": "WEFT_BROWSER_SMOKE=1 bun test --timeout 20000 src/service-worker/service-worker-browser.test.ts src/storage/indexeddb-browser.test.ts src/storage/web-extension-browser.test.ts",
     "test:coverage": "bun run scripts/check-coverage.ts",
     "typecheck": "tsc --noEmit",
     "typecheck:package-root": "bun run build && tsc --noEmit -p tsconfig.package-test-d.json",
     "typecheck:tests": "tsc --noEmit -p tsconfig.test-d.json && bun run typecheck:package-root",
-    "validate": "bun run lint && bun run typecheck && bun run typecheck:tests && bun run verify:documentation && bun run verify:no-test-sleeps && bun run verify:public-api-jsdoc && bun run test",
+    "validate": "bun run scripts/run-gates.ts validate",
     "validate:package-consumers": "bun run scripts/validate-package-consumers.ts",
     "verify:documentation": "bun run scripts/verify-documentation.ts",
     "verify:exports": "bun run scripts/verify-tree-shaking.ts",
@@ -248,7 +259,9 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.5.1",
     "@libsql/client": "^0.17.2",
+    "@neondatabase/serverless": "^1.1.0",
     "@types/bun": "^1.3.13",
     "better-sqlite3": "^12.8.0",
     "chalk": "^5.6.2",
@@ -267,6 +280,7 @@
   },
   "peerDependencies": {
     "@libsql/client": "^0.17.2",
+    "@neondatabase/serverless": "^1.1.0",
     "@opentelemetry/api": "^1.0.0",
     "better-sqlite3": "^12.8.0",
     "lmdb": "^3.5.2"
@@ -275,6 +289,9 @@
     "@libsql/client": {
       "optional": true
     },
+    "@neondatabase/serverless": {
+      "optional": true
+    },
     "@opentelemetry/api": {
       "optional": true
     },