@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/types/workflow-snapshot.d.ts

@@ -0,0 +1,29 @@
+import type { WorkflowStatus } from './identity.ts';
+/**
+ * A point-in-time view of a workflow's progress, returned by
+ * {@link WorkflowHandle.snapshot}. Combines the persisted status with the
+ * current checkpoint step (the run's cursor), so a caller — typically after
+ * `engine.recoverAll()` — can rebuild its own progress adapter for a recovered
+ * run and re-register it on a live surface, without awaiting the run's final
+ * result.
+ *
+ * `step` is the run's current checkpoint step: the number of generator turns it
+ * has advanced. For a run live in this engine it reflects the latest in-memory
+ * checkpoint (which may be one step ahead of the last durable commit); for a
+ * run inspected or recovered in a fresh process it reflects the durably
+ * persisted checkpoint. It is `0` for a run that has its initial checkpoint but
+ * has not yet advanced, and increases as the run makes progress.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowSnapshot } from '@lostgradient/weft';
+ *
+ * function describe(snapshot: WorkflowSnapshot): string {
+ *   return `${snapshot.status} @ step ${snapshot.step}`;
+ * }
+ * ```
+ */
+export interface WorkflowSnapshot {
+    status: WorkflowStatus;
+    step: number;
+}

package/dist/core/types.d.ts

@@ -1,3 +1,4 @@
+export * from './types/activity-verification.ts';
 export * from './types/activity.ts';
 export * from './types/archive-adapter.ts';
 export * from './types/bulk.ts';
@@ -7,6 +8,8 @@ export * from './types/definition-schema-to-json.ts';
 export * from './types/definition-schema.ts';
 export * from './types/history-policy.ts';
 export * from './types/identity.ts';
+export * from './types/launch-metadata.ts';
+export * from './types/list-options.ts';
 export * from './types/message-handles.ts';
 export * from './types/options.ts';
 export * from './types/payload-size-policy.ts';
@@ -15,12 +18,16 @@ export * from './types/reviews.ts';
 export * from './types/schedules.ts';
 export * from './types/search-attributes.ts';
 export * from './types/serializer.ts';
+export * from './types/services-resolution.ts';
 export * from './types/standard-schema-validate.ts';
 export * from './types/state.ts';
 export * from './types/workflow-builder-helpers.ts';
 export * from './types/workflow-builder-runtime.ts';
 export * from './types/workflow-builder.ts';
+export * from './types/workflow-concurrency.ts';
 export * from './types/workflow-context.ts';
 export * from './types/workflow-function.ts';
+export * from './types/workflow-log.ts';
 export * from './types/workflow-registries.ts';
 export * from './types/workflow-registry.ts';
+export * from './types/workflow-snapshot.ts';

package/dist/core/types.js

@@ -1,3 +1,4 @@
+export * from "./types/activity-verification.js";
 export * from "./types/activity.js";
 export * from "./types/archive-adapter.js";
 export * from "./types/bulk.js";
@@ -7,6 +8,8 @@ export * from "./types/definition-schema-to-json.js";
 export * from "./types/definition-schema.js";
 export * from "./types/history-policy.js";
 export * from "./types/identity.js";
+export * from "./types/launch-metadata.js";
+export * from "./types/list-options.js";
 export * from "./types/message-handles.js";
 export * from "./types/options.js";
 export * from "./types/payload-size-policy.js";
@@ -15,12 +18,16 @@ export * from "./types/reviews.js";
 export * from "./types/schedules.js";
 export * from "./types/search-attributes.js";
 export * from "./types/serializer.js";
+export * from "./types/services-resolution.js";
 export * from "./types/standard-schema-validate.js";
 export * from "./types/state.js";
 export * from "./types/workflow-builder-helpers.js";
 export * from "./types/workflow-builder-runtime.js";
 export * from "./types/workflow-builder.js";
+export * from "./types/workflow-concurrency.js";
 export * from "./types/workflow-context.js";
 export * from "./types/workflow-function.js";
+export * from "./types/workflow-log.js";
 export * from "./types/workflow-registries.js";
 export * from "./types/workflow-registry.js";
+export * from "./types/workflow-snapshot.js";

package/dist/core/versioning.d.ts

@@ -1,62 +1,32 @@
 /**
- * Workflow version comparison and checkpoint migration.
+ * Workflow version comparison and checkpoint diagnostics.
  *
  * Provides utilities for detecting version mismatches between stored
- * and registered workflow definitions, running checkpoint migrations,
- * and building atomic batch operations for version updates.
+ * and registered workflow definitions.
  *
  * @module versioning
  */
-import type { BatchOperation } from '../storage/interface.ts';
 import { WeftError } from './weft-error.ts';
 import type { WorkflowVersionDiff } from './workflow-version-tuple.ts';
 /** Default version string assigned when no version is specified. */
 export declare const DEFAULT_WORKFLOW_VERSION = "0.0.0";
-export type VersionCompatibility = 'compatible' | 'needs-migration' | 'incompatible';
+export type VersionCompatibility = 'compatible' | 'incompatible';
 /**
  * Compare a stored workflow version with the currently registered version.
  *
  * - `"compatible"` — versions match; no action needed.
- * - `"needs-migration"` — versions differ and a migration function is available.
- * - `"incompatible"` — versions differ and no migration is available; the engine
- *   will throw a {@link VersionMismatchError} instead of resuming silently.
+ * - `"incompatible"` — versions differ; the engine will throw a
+ *   {@link VersionMismatchError} instead of resuming silently.
  *
  * @example
  * ```ts
  * import { checkVersionCompatibility } from '@lostgradient/weft';
  *
- * console.log(checkVersionCompatibility('1.0.0', '1.0.0', false)); // 'compatible'
- * console.log(checkVersionCompatibility('1.0.0', '2.0.0', true));  // 'needs-migration'
- * console.log(checkVersionCompatibility('1.0.0', '2.0.0', false)); // 'incompatible'
+ * console.log(checkVersionCompatibility('1.0.0', '1.0.0')); // 'compatible'
+ * console.log(checkVersionCompatibility('1.0.0', '2.0.0')); // 'incompatible'
  * ```
  */
-export declare function checkVersionCompatibility(storedVersion: string, registeredVersion: string, hasMigration: boolean): VersionCompatibility;
-/**
- * Run a migration function on checkpoint data, transforming it from one
- * version to another.
- *
- * The caller is responsible for serializing the result back to bytes if needed.
- *
- * @example
- * ```ts
- * import { migrateCheckpoint } from '@lostgradient/weft';
- *
- * const oldData = { step: 0, locals: { counter: 1 }, version: '1.0.0' };
- * const migrated = migrateCheckpoint(oldData, '1.0.0', '2.0.0', (data) => {
- *   const d = data as typeof oldData;
- *   return { ...d, locals: { ...d.locals, newField: 'default' } };
- * });
- * void migrated;
- * ```
- */
-export declare function migrateCheckpoint(checkpointData: unknown, fromVersion: string, _toVersion: string, migrate: (checkpoint: unknown, fromVersion: string) => unknown): unknown;
-/**
- * Build batch operations that atomically update the checkpoint and workflow
- * state after a successful migration.
- *
- * The returned operations are suitable for passing to `Storage.batch()`.
- */
-export declare function buildVersionUpdateOperations(workflowId: string, newCheckpointBytes: Uint8Array, _newVersion: string, workflowStateBytes: Uint8Array): BatchOperation[];
+export declare function checkVersionCompatibility(storedVersion: string, registeredVersion: string): VersionCompatibility;
 /** Description of a single field-level difference between checkpoint shapes. */
 export type FieldDiff = {
     field: string;
@@ -115,7 +85,7 @@ export type ShapeDiffOptions = {
 };
 /**
  * Thrown when a workflow's stored version does not match its registered
- * version and no migration path is available or the migration failed.
+ * version.
  *
  * When shape information is provided, the error message includes a
  * field-level diff describing exactly which fields changed.

package/dist/core/versioning.js

@@ -1,20 +1,10 @@
-import { KEYS } from "../storage/interface.js";
 import { WeftError } from "./weft-error.js";
 import { formatWorkflowVersionDiff } from "./workflow-version-tuple.js";
 export const DEFAULT_WORKFLOW_VERSION = "0.0.0";
-export function checkVersionCompatibility(storedVersion, registeredVersion, hasMigration) {
+export function checkVersionCompatibility(storedVersion, registeredVersion) {
   if (storedVersion === registeredVersion)
     return "compatible";
-  return hasMigration ? "needs-migration" : "incompatible";
-}
-export function migrateCheckpoint(checkpointData, fromVersion, _toVersion, migrate) {
-  return migrate(checkpointData, fromVersion);
-}
-export function buildVersionUpdateOperations(workflowId, newCheckpointBytes, _newVersion, workflowStateBytes) {
-  return [
-    { type: "put", key: KEYS.checkpoint(workflowId), value: newCheckpointBytes },
-    { type: "put", key: KEYS.workflow(workflowId), value: workflowStateBytes }
-  ];
+  return "incompatible";
 }
 export function diffCheckpointShapes(oldShape, newShape) {
   const diffs = [], allKeys = new Set([...Object.keys(oldShape), ...Object.keys(newShape)]);

package/dist/core/weft-error.d.ts

@@ -9,6 +9,9 @@
  * when an error may have crossed a realm or duplicate-module boundary, where
  * `instanceof` is unreliable.
  *
+ * See `documentation/reference/api-errors.md` for the source-complete error
+ * code table and usage guidance for the exported guards.
+ *
  * @example
  * ```ts
  * import { isWeftErrorLike, type WeftErrorCode } from '@lostgradient/weft';
@@ -22,7 +25,7 @@
  * }
  * ```
  */
-export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'WorkflowNotFoundError' | 'WorkflowNotRegisteredError' | 'ActivityResolutionError' | 'PersistedDataIncompatibleError' | 'WorkflowTimeoutError' | 'HttpClientError' | 'WorkerProtocolIncompatibleError' | 'UpdateTimeoutError' | 'UpdateValidationError' | 'WorkflowTerminalError' | 'WorkflowBuilderError' | 'VersionMismatchError' | 'EffectReplayConflictError' | 'ReviewTimeoutError' | 'AtomicStateConflictError' | 'StandardSchemaValidationError' | 'ActivityReconciliationCapabilityError' | 'ActivityReconciliationConflictError' | 'ActivityReconciliationIndeterminateError' | 'AsyncActivityTokenNotFoundError' | 'PayloadSizeExceededError';
+export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'WorkflowNotFoundError' | 'WorkflowNotRegisteredError' | 'WorkflowConcurrencyLimitExceededError' | 'WorkflowSuspendNotSupportedError' | 'ActivityResolutionError' | 'BranchTopologyChangedError' | 'PersistedDataIncompatibleError' | 'WorkflowTimeoutError' | 'HttpClientError' | 'WorkerProtocolIncompatibleError' | 'UpdateTimeoutError' | 'UpdateValidationError' | 'WorkflowTerminalError' | 'WorkflowBuilderError' | 'VersionMismatchError' | 'EffectReplayConflictError' | 'ReviewTimeoutError' | 'AtomicStateConflictError' | 'StandardSchemaValidationError' | 'ActivityReconciliationCapabilityError' | 'ActivityReconciliationConflictError' | 'ActivityReconciliationIndeterminateError' | 'AsyncActivityTokenNotFoundError' | 'ActivityScheduleToCloseTimeoutError' | 'ActivityPerAttemptTimeoutError' | 'PayloadSizeExceededError' | 'StartOrSignalConflictError' | 'IdempotencyKeyPurgedError';
 /**
  * Generic abstract base for all Weft library errors. The `TCode` parameter
  * makes each subclass's `code` its own literal type; the exported base surface
@@ -55,6 +58,9 @@ export declare abstract class WeftError<TCode extends string = string> extends E
  * object structurally. {@link isWeftErrorCode} narrows a bare `code` *string*,
  * not a caught `unknown`.
  *
+ * See `documentation/reference/api-errors.md#error-helpers` for guard selection
+ * examples across same-realm and cross-boundary errors.
+ *
  * @example
  * ```ts
  * import { isWeftError } from '@lostgradient/weft';
@@ -71,6 +77,9 @@ export declare function isWeftError(value: unknown): value is WeftError;
  * a caught `unknown` (the common `catch` case), reach for {@link isWeftErrorLike},
  * which checks the whole error object structurally.
  *
+ * See `documentation/reference/api-errors.md#error-helpers` for guard selection
+ * examples across same-realm and cross-boundary errors.
+ *
  * @example
  * ```ts
  * import { isWeftErrorCode } from '@lostgradient/weft';
@@ -96,6 +105,9 @@ export declare function isWeftErrorCode(value: unknown): value is WeftErrorCode;
  * To match a *specific* code, narrow with this guard then compare `error.code`
  * — TypeScript narrows it to the matched literal in the branch.
  *
+ * See `documentation/reference/api-errors.md#error-helpers` for guard selection
+ * examples across same-realm and cross-boundary errors.
+ *
  * @example
  * ```ts
  * import { isWeftErrorLike } from '@lostgradient/weft';
@@ -112,3 +124,34 @@ export declare function isWeftErrorLike(value: unknown): value is {
     code: WeftErrorCode;
     message: string;
 };
+/**
+ * Transport-uniform error classification: `true` when `error` represents the
+ * given public {@link WeftErrorCode}, whether it was thrown in process or
+ * arrived over HTTP. This is the canonical way to branch on a specific Weft
+ * error without caring which transport produced it — the predicate the
+ * `WeftClient` "constructor change, not an API change" promise rests on.
+ *
+ * It matches two shapes with one rule:
+ * - An in-process typed error (or any {@link isWeftErrorLike} value) whose
+ *   `code` equals `code` — what `LocalClient` throws.
+ * - An `HttpClientError` carrying `weftCode === code` — what `HttpClient`
+ *   throws when the REST fault rehydrated the originating public code. The
+ *   check is structural (`'weftCode' in error`) rather than `instanceof
+ *   HttpClientError`, both to stay reliable across realm/duplicate-module
+ *   boundaries and to keep this guard in the core layer without importing the
+ *   client.
+ *
+ * @example
+ * ```ts
+ * import { isWeftFault } from '@lostgradient/weft';
+ *
+ * // The same branch holds over LocalClient and HttpClient: a missing workflow
+ * // is a no-op success ("nothing to tell"), not a failure to re-raise.
+ * function rethrowUnlessMissing(error: unknown): void {
+ *   if (!isWeftFault(error, 'WorkflowNotFoundError')) {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+export declare function isWeftFault(error: unknown, code: WeftErrorCode): boolean;

package/dist/core/weft-error.js

@@ -15,7 +15,10 @@ const publicWeftErrorCodeMap = {
   EngineDisposedError: !0,
   WorkflowNotFoundError: !0,
   WorkflowNotRegisteredError: !0,
+  WorkflowConcurrencyLimitExceededError: !0,
+  WorkflowSuspendNotSupportedError: !0,
   ActivityResolutionError: !0,
+  BranchTopologyChangedError: !0,
   PersistedDataIncompatibleError: !0,
   WorkflowTimeoutError: !0,
   HttpClientError: !0,
@@ -33,7 +36,11 @@ const publicWeftErrorCodeMap = {
   ActivityReconciliationConflictError: !0,
   ActivityReconciliationIndeterminateError: !0,
   AsyncActivityTokenNotFoundError: !0,
-  PayloadSizeExceededError: !0
+  ActivityScheduleToCloseTimeoutError: !0,
+  ActivityPerAttemptTimeoutError: !0,
+  PayloadSizeExceededError: !0,
+  StartOrSignalConflictError: !0,
+  IdempotencyKeyPurgedError: !0
 }, PUBLIC_WEFT_ERROR_CODES = new Set(Object.keys(publicWeftErrorCodeMap));
 export function isWeftError(value) {
   return value instanceof WeftError;
@@ -50,3 +57,14 @@ export function isWeftErrorLike(value) {
     return !1;
   }
 }
+export function isWeftFault(error, code) {
+  if (isWeftErrorLike(error) && error.code === code)
+    return !0;
+  if (typeof error !== "object" || error === null)
+    return !1;
+  try {
+    return "weftCode" in error && error.weftCode === code;
+  } catch {
+    return !1;
+  }
+}

package/dist/core/worker-execution-strategy-options.d.ts

@@ -1,7 +1,33 @@
+import type { WorkflowLogRecord } from './types/workflow-log.ts';
 export interface WorkerExecutionStrategyOptions {
     broadcastEvents?: boolean;
     workflowTurnTimeoutMs?: number;
     maxProtocolMessageBytes?: number;
     requireProtocolVersion?: boolean;
     discardOnCancel?: boolean;
+    /**
+     * The engine host's `EngineOptions.onLog` sink (#529). When present, the strategy
+     * tells each worker (`hostHasLogSink: true` on `run`/`resume`) to forward `ctx.log`
+     * records back as `log` protocol messages, which are delivered here instead of the
+     * worker console. When absent, workers log to their own console (the default).
+     */
+    onLog?: (record: WorkflowLogRecord) => void;
+    /**
+     * Monotonic-enough wall clock (ms) for the forwarded-log abuse counter's flood
+     * window (#545). Injected so tests advance time deterministically; defaults to
+     * `Date.now` when omitted (the non-worker-construction path / direct tests).
+     */
+    getNow?: () => number;
+    /**
+     * Internal test seams for the forwarded-log abuse counter (#545). Not a public
+     * engine option — the abuse thresholds are deliberately fixed and generous so honest
+     * high-log workflows are never discarded. These exist only so unit tests can inject
+     * small thresholds (and a controllable window) to exercise the discard paths without
+     * sending thousands of messages; each falls back to its worker-protocol default.
+     */
+    forwardedLogFloodWindowMs?: number;
+    /** See {@link WorkerExecutionStrategyOptions.forwardedLogFloodWindowMs} — internal test seam (#545). */
+    forwardedLogFloodThreshold?: number;
+    /** See {@link WorkerExecutionStrategyOptions.forwardedLogFloodWindowMs} — internal test seam (#545). */
+    forwardedLogStrikeThreshold?: number;
 }

package/dist/core/worker-execution-strategy.js

@@ -1,14 +1,20 @@
 import { WorkerCheckpointResumeState } from "./worker-checkpoint-resume-state.js";
-import {
-  WorkerExecutionDispatcher
-} from "./worker-execution-dispatcher.js";
+import { WorkerExecutionDispatcher } from "./worker-execution-dispatcher.js";
 import { WorkerExecutionOwnership } from "./worker-execution-ownership.js";
+import {
+  buildResumeMessage,
+  buildRunMessage
+} from "./worker-inbound-message.js";
 import { WorkerListenerRegistry } from "./worker-listener-registry.js";
+import {
+  forwardedLogGateFromStrategyOptions
+} from "./worker-log-abuse-counter.js";
 import {
   emitWorkerMessageToEngine,
   isParkableWaitSignalCheckpoint
 } from "./worker-message-helpers.js";
 import { WorkerProtocolGuard } from "./worker-protocol-guard.js";
+import { isWorkerLogMessage } from "./worker-protocol-log.js";
 import { WORKER_PROTOCOL_VERSION } from "./worker-protocol.js";
 import { WorkerTurnWatchdog } from "./worker-turn-watchdog.js";
 
@@ -23,6 +29,7 @@ export class WorkerExecutionStrategy {
   #maxProtocolMessageBytes;
   #requireProtocolVersion;
   #discardOnCancel;
+  #forwardedLogGate;
   #turnWatchdog;
   #protocolGuard;
   #dispatcher;
@@ -30,14 +37,22 @@ export class WorkerExecutionStrategy {
   #disposed;
   #nextTurnId;
   constructor(pool, options) {
+    const {
+      workflowTurnTimeoutMs,
+      maxProtocolMessageBytes,
+      requireProtocolVersion = !1,
+      discardOnCancel = !1,
+      broadcastEvents = !1
+    } = options ?? {};
     this.#pool = pool;
     this.#ownership = new WorkerExecutionOwnership;
     this.#workerListeners = new WorkerListenerRegistry;
     this.#checkpointResumeState = new WorkerCheckpointResumeState;
-    this.#workflowTurnTimeoutMs = options?.workflowTurnTimeoutMs;
-    this.#maxProtocolMessageBytes = options?.maxProtocolMessageBytes;
-    this.#requireProtocolVersion = options?.requireProtocolVersion ?? !1;
-    this.#discardOnCancel = options?.discardOnCancel ?? !1;
+    this.#workflowTurnTimeoutMs = workflowTurnTimeoutMs;
+    this.#maxProtocolMessageBytes = maxProtocolMessageBytes;
+    this.#requireProtocolVersion = requireProtocolVersion;
+    this.#discardOnCancel = discardOnCancel;
+    this.#forwardedLogGate = forwardedLogGateFromStrategyOptions(options, maxProtocolMessageBytes);
     this.#turnWatchdog = new WorkerTurnWatchdog(this.#workflowTurnTimeoutMs, (turn) => {
       this.#handleTurnTimeout(turn);
     });
@@ -72,7 +87,7 @@ export class WorkerExecutionStrategy {
     this.#broadcastListener = null;
     this.#disposed = !1;
     this.#nextTurnId = 1;
-    if (options?.broadcastEvents)
+    if (broadcastEvents)
       try {
         this.#broadcastChannel = new BroadcastChannel("weft:events");
         this.#broadcastListener = (event) => {
@@ -87,22 +102,7 @@ export class WorkerExecutionStrategy {
   startWorkflow(parameters) {
     this.#ownership.resetWorkflow(parameters.workflowId);
     this.#checkpointResumeState.resetWorkflow(parameters.workflowId);
-    const message = {
-      type: "run",
-      protocolVersion: WORKER_PROTOCOL_VERSION,
-      turnId: this.#nextTurnId++,
-      workflowId: parameters.workflowId,
-      workflowType: parameters.workflowType,
-      checkpoint: parameters.checkpoint,
-      input: parameters.input,
-      executionStateOwnerId: parameters.executionStateOwnerId ?? parameters.workflowId
-    };
-    if (this.#maxProtocolMessageBytes !== void 0)
-      message.maxProtocolMessageBytes = this.#maxProtocolMessageBytes;
-    if (parameters.deadline !== void 0)
-      message.deadline = parameters.deadline;
-    if (parameters.headers)
-      message.headers = parameters.headers;
+    const message = buildRunMessage(parameters, this.#inboundMessageContext());
     if (!this.#assertHostToWorkerMessageWithinLimit(parameters.workflowId, message))
       return;
     this.#dispatcher.acquireAndSend(parameters.workflowId, message);
@@ -111,12 +111,14 @@ export class WorkerExecutionStrategy {
     const worker = this.#ownership.getActiveWorker(parameters.workflowId);
     if (worker) {
       this.#checkpointResumeState.recordResume(parameters.workflowId);
-      this.#dispatcher.postResumeMessage(worker, parameters, this.#createResumeMessage(parameters));
+      const resumeMessage = buildResumeMessage(parameters, this.#inboundMessageContext());
+      this.#dispatcher.postResumeMessage(worker, parameters, resumeMessage);
       return;
     }
     const parkedWorker = this.#ownership.getParkedWorker(parameters.workflowId);
     if (parkedWorker) {
-      this.#dispatcher.resumeParkedWorkflow(parameters, parkedWorker, this.#createResumeMessage(parameters));
+      const resumeMessage = buildResumeMessage(parameters, this.#inboundMessageContext());
+      this.#dispatcher.resumeParkedWorkflow(parameters, parkedWorker, resumeMessage);
       return;
     }
     if (this.#ownership.consumeCancelled(parameters.workflowId))
@@ -128,18 +130,12 @@ export class WorkerExecutionStrategy {
         error: `No worker assigned for workflow: ${parameters.workflowId}`
       });
   }
-  #createResumeMessage(parameters) {
-    const message = {
-      type: "resume",
-      protocolVersion: WORKER_PROTOCOL_VERSION,
+  #inboundMessageContext() {
+    return {
       turnId: this.#nextTurnId++,
-      workflowId: parameters.workflowId,
-      checkpoint: parameters.checkpoint,
-      operationResult: parameters.operationResult
+      maxProtocolMessageBytes: this.#maxProtocolMessageBytes,
+      hasLogSink: this.#forwardedLogGate.hasSink
     };
-    if (this.#maxProtocolMessageBytes !== void 0)
-      message.maxProtocolMessageBytes = this.#maxProtocolMessageBytes;
-    return message;
   }
   cancelWorkflow(workflowId) {
     const worker = this.#ownership.getActiveWorker(workflowId);
@@ -205,6 +201,12 @@ export class WorkerExecutionStrategy {
     this.#messageHandler = null;
   }
   async#handleWorkerMessage(worker, message) {
+    if (isWorkerLogMessage(message)) {
+      const owns = (id) => this.#ownership.getTargetWorker(id) === worker, abuseDiscard = this.#forwardedLogGate.handle(worker, message, owns);
+      if (abuseDiscard)
+        this.#discardWorkerAndFailWorkflows(worker, abuseDiscard);
+      return;
+    }
     if (!this.#acceptWorkerMessage(worker, message))
       return;
     this.#turnWatchdog.clear(worker);
@@ -322,6 +324,7 @@ export class WorkerExecutionStrategy {
     const workflowIds = this.#ownership.workflowIdsForWorker(worker);
     if (workflowIds.length === 0) {
       this.#turnWatchdog.clear(worker);
+      this.#forwardedLogGate.forget(worker);
       return;
     }
     for (const workflowId of workflowIds) {
@@ -338,6 +341,7 @@ export class WorkerExecutionStrategy {
       });
     }
     this.#turnWatchdog.clear(worker);
+    this.#forwardedLogGate.forget(worker);
     this.#workerListeners.detach(worker);
     this.#pool.discard(worker);
   }

package/dist/core/worker-inbound-message.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Builders for the `run`/`resume` {@link WorkerInboundMessage} envelopes the
+ * {@link import('./worker-execution-strategy.ts').WorkerExecutionStrategy} sends to a
+ * worker. Extracted as free functions so the strategy stays under the line cap and the
+ * envelope-construction rules (protocol version, turn id, size cap, host-log-sink
+ * stamping) live in one place. The strategy keeps ownership of the turn-id counter and
+ * the assert-and-send; these functions only assemble the message.
+ *
+ * @module core/worker-inbound-message
+ */
+import type { OperationOutcome, WorkerInboundMessage } from './types.ts';
+/** The turn-protocol context every inbound message carries, owned by the strategy. */
+export interface WorkerInboundMessageContext {
+    turnId: number;
+    maxProtocolMessageBytes: number | undefined;
+    /** Whether the engine host installed an `onLog` sink; stamps `hostHasLogSink` (#529). */
+    hasLogSink: boolean;
+}
+/** Build a `run` inbound message from start parameters and the turn context. */
+export declare function buildRunMessage(parameters: {
+    workflowId: string;
+    workflowType: string;
+    input: unknown;
+    checkpoint: ArrayBuffer;
+    executionStateOwnerId?: string;
+    deadline?: number;
+    headers?: [string, string][];
+}, context: WorkerInboundMessageContext): WorkerInboundMessage & {
+    type: 'run';
+};
+/** Build a `resume` inbound message from resume parameters and the turn context. */
+export declare function buildResumeMessage(parameters: {
+    workflowId: string;
+    checkpoint: ArrayBuffer;
+    operationResult: OperationOutcome;
+}, context: WorkerInboundMessageContext): WorkerInboundMessage & {
+    type: 'resume';
+};

package/dist/core/worker-inbound-message.js

@@ -0,0 +1,37 @@
+import { WORKER_PROTOCOL_VERSION } from "./worker-protocol.js";
+export function buildRunMessage(parameters, context) {
+  const message = {
+    type: "run",
+    protocolVersion: WORKER_PROTOCOL_VERSION,
+    turnId: context.turnId,
+    workflowId: parameters.workflowId,
+    workflowType: parameters.workflowType,
+    checkpoint: parameters.checkpoint,
+    input: parameters.input,
+    executionStateOwnerId: parameters.executionStateOwnerId ?? parameters.workflowId
+  };
+  if (context.maxProtocolMessageBytes !== void 0)
+    message.maxProtocolMessageBytes = context.maxProtocolMessageBytes;
+  if (parameters.deadline !== void 0)
+    message.deadline = parameters.deadline;
+  if (parameters.headers)
+    message.headers = parameters.headers;
+  if (context.hasLogSink)
+    message.hostHasLogSink = !0;
+  return message;
+}
+export function buildResumeMessage(parameters, context) {
+  const message = {
+    type: "resume",
+    protocolVersion: WORKER_PROTOCOL_VERSION,
+    turnId: context.turnId,
+    workflowId: parameters.workflowId,
+    checkpoint: parameters.checkpoint,
+    operationResult: parameters.operationResult
+  };
+  if (context.maxProtocolMessageBytes !== void 0)
+    message.maxProtocolMessageBytes = context.maxProtocolMessageBytes;
+  if (context.hasLogSink)
+    message.hostHasLogSink = !0;
+  return message;
+}