@lostgradient/weft 0.18.0 → 0.19.0

package/dist/worker/options.d.ts

@@ -1,4 +1,5 @@
 import type { ActivityInterceptor } from '../core/interceptor.ts';
+import type { WorkerManifest } from './manifest/index.ts';
 import { type RegisterMessage, type RemoteWorkerCapabilities } from './protocol.ts';
 import type { RemoteWorkerWorkflowDefinition } from './workflow-activity-binding.ts';
 /**
@@ -9,6 +10,10 @@ import type { RemoteWorkerWorkflowDefinition } from './workflow-activity-binding
  * `${workflowType}.${activityName}` table that the protocol expects and
  * validates that each outer key matches the inner `workflow.name`. This is the
  * API the engine-side builder produces, and it is required.
+ *
+ * `deploymentName` and `buildId` are required — defaulting them risks a false
+ * deployment-conflict collision between two unrelated apps that both skip the
+ * option and happen to declare different workflows.
  */
 export interface RemoteWorkerOptions {
     serverUrl: string;
@@ -22,10 +27,35 @@ export interface RemoteWorkerOptions {
     concurrency?: number;
     queue?: string;
     disconnectTimeoutMs?: number;
-    deploymentName?: string;
-    buildId?: string;
+    /** Logical service this worker instance belongs to. */
+    deploymentName: string;
+    /** Operator-visible release this worker instance is running. */
+    buildId: string;
+    /**
+     * Trusted digest of the executable artifact this instance loaded. When
+     * omitted, a placeholder digest is derived from the declared workflow and
+     * activity names — tagged `declared-shape:...` so it is never mistaken for
+     * a real content digest. Real build tooling should supply this. Ignored
+     * when `manifest` is supplied, which carries its own `deployment.artifactDigest`.
+     */
+    artifactDigest?: string;
+    /**
+     * A complete, real manifest built ahead of time — typically by
+     * `buildWorkerManifestFromRegistry` (WFT-29) from the engine's canonical
+     * workflow registry. When supplied, it is advertised verbatim at
+     * registration instead of the `declared-shape:` placeholder this module
+     * otherwise derives from `workflows`, and every other manifest-shaping
+     * option (`deploymentName`, `buildId`, `artifactDigest`, `runtimeVersion`,
+     * `capabilities`) is ignored.
+     *
+     * The constructor requires `manifest.workflows` to declare exactly the
+     * same set of workflow types as `workflows` — a manifest advertising
+     * contracts this instance's dispatch table cannot execute (or omitting
+     * ones it can) is rejected at construction rather than at registration.
+     */
+    manifest?: WorkerManifest;
+    /** Runtime version string. Defaults to `detectRuntimeVersion()`. */
     runtimeVersion?: string;
-    gitSha?: string;
     startedAt?: number;
     capabilities?: RemoteWorkerCapabilities;
     /**
@@ -58,9 +88,26 @@ export type PendingRegistration = {
     reject: (error: Error) => void;
 };
 /**
- * Build the `register` frame from the worker's resolved options and advertised
- * activity names. Optional identity/capability fields are omitted entirely when
- * undefined so the wire frame stays minimal. `workerId`, `concurrency`, and
- * `queue` are resolved to defaults by the constructor before this runs.
+ * Copy a caller-supplied `workflows` map so later mutation of the caller's
+ * own object cannot desync the manifest a future `connect()` advertises from
+ * the activity dispatch table the constructor already built from the same
+ * shape. `buildRegisterMessage` re-derives the manifest from `options.workflows`
+ * on every `connect()`; without this copy that field stays a live reference
+ * to the caller's object for the instance's whole lifetime.
+ */
+export declare function snapshotWorkflows(workflows: Record<string, RemoteWorkerWorkflowDefinition>): Record<string, RemoteWorkerWorkflowDefinition>;
+/**
+ * Assert that a caller-supplied real manifest (`options.manifest`) declares
+ * exactly the workflow types the SDK's own `workflows` dispatch table
+ * declares — no more, no fewer. Called once, at construction, so a mismatch
+ * between build-tool output and the live dispatch table fails fast rather
+ * than surfacing later as a confusing registration rejection or a routed
+ * task this instance cannot actually execute.
+ */
+export declare function assertManifestMatchesWorkflows(manifest: WorkerManifest, workflows: Record<string, RemoteWorkerWorkflowDefinition>): void;
+/**
+ * Build the `register` frame from the worker's resolved options. `workerId`
+ * and `concurrency` are resolved to defaults by the constructor before this
+ * runs; `manifest` carries every identity claim protocol v3 validates.
  */
-export declare function buildRegisterMessage(workerId: string, activities: readonly string[], options: RemoteWorkerOptions): RegisterMessage;
+export declare function buildRegisterMessage(workerId: string, options: RemoteWorkerOptions): RegisterMessage;

package/dist/worker/options.js

@@ -1,19 +1,75 @@
+import { DEFAULT_WORKFLOW_VERSION } from "../core/versioning.js";
+import { detectRuntime, detectRuntimeVersion } from "../runtime/portable.js";
+import { VERSION } from "../version.js";
+import { declaredShapeDigest } from "./manifest/declared-shape-digest.js";
+import { WORKER_MANIFEST_VERSION } from "./manifest/index.js";
 import {
   REMOTE_WORKER_PROTOCOL_VERSION
 } from "./protocol.js";
-export function buildRegisterMessage(workerId, activities, options) {
+export function snapshotWorkflows(workflows) {
+  const snapshot = {};
+  for (const [workflowType, workflow] of Object.entries(workflows))
+    snapshot[workflowType] = { name: workflow.name, activities: { ...workflow.activities } };
+  return snapshot;
+}
+function buildWorkflowContract(workflowType, workflow) {
+  const activityNames = Object.keys(workflow.activities).toSorted(), workflowShapeDigest = declaredShapeDigest(`${workflowType}:${activityNames.join(",")}`), activities = {};
+  for (const activityName of activityNames) {
+    const activityShapeDigest = declaredShapeDigest(`${workflowType}.${activityName}`);
+    activities[activityName] = {
+      contractHash: activityShapeDigest,
+      implementationRevision: activityShapeDigest
+    };
+  }
+  return {
+    workflowVersion: DEFAULT_WORKFLOW_VERSION,
+    workflowRevision: workflowShapeDigest,
+    contractHash: workflowShapeDigest,
+    activities
+  };
+}
+function deriveArtifactDigest(workflows) {
+  const qualifiedNames = Object.entries(workflows).flatMap(([workflowType, workflow]) => Object.keys(workflow.activities).map((activityName) => `${workflowType}.${activityName}`)).toSorted();
+  return declaredShapeDigest(qualifiedNames.join(","));
+}
+export function assertManifestMatchesWorkflows(manifest, workflows) {
+  const manifestTypes = new Set(Object.keys(manifest.workflows)), declaredTypes = new Set(Object.keys(workflows)), missingFromManifest = [...declaredTypes].filter((type) => !manifestTypes.has(type)).toSorted(), extraInManifest = [...manifestTypes].filter((type) => !declaredTypes.has(type)).toSorted();
+  if (missingFromManifest.length === 0 && extraInManifest.length === 0)
+    return;
+  const parts = [];
+  if (missingFromManifest.length > 0)
+    parts.push(`missing from manifest: ${missingFromManifest.join(", ")}`);
+  if (extraInManifest.length > 0)
+    parts.push(`not in workflows: ${extraInManifest.join(", ")}`);
+  throw Error(`RemoteWorkerOptions.manifest.workflows must declare exactly the workflow types in \`workflows\` (${parts.join("; ")}).`);
+}
+function buildManifest(options) {
+  if (options.manifest !== void 0)
+    return options.manifest;
+  const workflows = {};
+  for (const [workflowType, workflow] of Object.entries(options.workflows))
+    workflows[workflowType] = buildWorkflowContract(workflowType, workflow);
+  return {
+    manifestVersion: WORKER_MANIFEST_VERSION,
+    protocolVersion: REMOTE_WORKER_PROTOCOL_VERSION,
+    sdkVersion: VERSION,
+    runtime: { name: detectRuntime(), version: options.runtimeVersion ?? detectRuntimeVersion() },
+    deployment: {
+      name: options.deploymentName,
+      buildId: options.buildId,
+      artifactDigest: options.artifactDigest ?? deriveArtifactDigest(options.workflows)
+    },
+    workflows,
+    capabilities: options.capabilities ?? {}
+  };
+}
+export function buildRegisterMessage(workerId, options) {
   return {
     type: "register",
     protocolVersion: REMOTE_WORKER_PROTOCOL_VERSION,
     workerId,
-    activities: [...activities],
+    manifest: buildManifest(options),
     ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {},
-    ...options.queue !== void 0 ? { queue: options.queue } : {},
-    ...options.deploymentName !== void 0 ? { deploymentName: options.deploymentName } : {},
-    ...options.buildId !== void 0 ? { buildId: options.buildId } : {},
-    ...options.runtimeVersion !== void 0 ? { runtimeVersion: options.runtimeVersion } : {},
-    ...options.gitSha !== void 0 ? { gitSha: options.gitSha } : {},
-    ...options.startedAt !== void 0 ? { startedAt: options.startedAt } : {},
-    ...options.capabilities !== void 0 ? { capabilities: options.capabilities } : {}
+    ...options.startedAt !== void 0 ? { startedAt: options.startedAt } : {}
   };
 }

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

@@ -9,7 +9,7 @@
  *
  * @module worker/protocol-internals
  */
-import type { ProtocolErrorMessage, RegisterErrorMessage, RemoteWorkerCapabilities, RemoteWorkerJsonValue } from './protocol-messages.ts';
+import type { ProtocolErrorMessage, RegisterErrorMessage, RemoteWorkerJsonValue } from './protocol-messages.ts';
 /**
  * Protocol parse failure with a machine-readable code.
  *
@@ -63,7 +63,6 @@ export declare function isRemoteWorkerJsonValue(value: unknown): value is Remote
 export declare function isNonEmptyString(value: unknown): value is string;
 export declare function isStringArray(value: unknown): value is string[];
 export declare function isStringRecord(value: unknown): value is Record<string, string>;
-export declare function isRemoteWorkerCapabilities(value: unknown): value is RemoteWorkerCapabilities;
 export declare function isFiniteNumber(value: unknown): value is number;
 export declare function protocolFailure(code: RemoteWorkerProtocolFailure['code'], message: string, requestedProtocolVersion?: number): RemoteWorkerProtocolParseResult<never>;
 export type FieldSpec = readonly [

package/dist/worker/protocol-internals.js

@@ -21,11 +21,6 @@ export function isStringRecord(value) {
     return !1;
   return Object.values(value).every((entry) => typeof entry === "string");
 }
-export function isRemoteWorkerCapabilities(value) {
-  if (!isRecord(value))
-    return !1;
-  return Object.values(value).every(isRemoteWorkerJsonValue);
-}
 export function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }

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

@@ -37,8 +37,14 @@ export type RemoteWorkerCapabilities = Readonly<Record<string, RemoteWorkerJsonV
 /**
  * Worker registration message sent immediately after opening a worker stream.
  *
- * Each entry of `activities` is a qualified `${workflowType}.${activityName}`
- * name; bare activity names were retired in protocol v2.
+ * Protocol v3 replaced the parallel top-level identity fields
+ * (`activities`, `queue`, `deploymentName`, `buildId`, `runtimeVersion`,
+ * `gitSha`, `capabilities`) with a single `manifest`. The server derives
+ * routing activities from `manifest.workflows`, reads the queue from the
+ * worker-stream URL rather than a field a worker could disagree with, and
+ * validates every other identity claim through `parseWorkerManifest()`.
+ * `manifest` is `unknown` here deliberately — this module only proves wire
+ * shape; deep manifest validation happens where the manifest is accepted.
  *
  * @example
  * ```ts
@@ -46,9 +52,9 @@ export type RemoteWorkerCapabilities = Readonly<Record<string, RemoteWorkerJsonV
  *
  * const message: RegisterMessage = {
  *   type: 'register',
- *   protocolVersion: 2,
+ *   protocolVersion: 3,
  *   workerId: 'worker-1',
- *   activities: ['welcome.sendEmail'],
+ *   manifest: { manifestVersion: 1 },
  * };
  * ```
  */
@@ -56,15 +62,9 @@ export type RegisterMessage = {
     readonly type: 'register';
     readonly protocolVersion: RemoteWorkerProtocolVersion;
     readonly workerId: string;
-    readonly activities: readonly string[];
+    readonly manifest: unknown;
     readonly concurrency?: number;
-    readonly queue?: string;
-    readonly deploymentName?: string;
-    readonly buildId?: string;
-    readonly runtimeVersion?: string;
-    readonly gitSha?: string;
     readonly startedAt?: number;
-    readonly capabilities?: RemoteWorkerCapabilities;
 };
 /**
  * Worker heartbeat message.
@@ -157,17 +157,24 @@ export type CancelledTaskResultMessage = {
 /**
  * Registration acknowledgement sent after a worker is accepted.
  *
+ * `acceptedManifestDigest` is the digest of the canonical manifest the server
+ * actually stored — a worker can confirm the server saw the manifest it
+ * intended to send. `serverCapabilities` replaces echoing `activities` back
+ * (the worker already knows what it sent); it is a bounded list of
+ * server-side capability names, currently always empty.
+ *
  * @example
  * ```ts
  * import type { RegisterAckMessage } from '@lostgradient/weft/worker-protocol';
  *
  * const message: RegisterAckMessage = {
  *   type: 'registerAck',
- *   protocolVersion: 2,
+ *   protocolVersion: 3,
  *   workerId: 'worker-1',
  *   queue: 'default',
- *   activities: ['welcome.sendEmail'],
  *   concurrency: 10,
+ *   acceptedManifestDigest: 'sha256:41d0e2',
+ *   serverCapabilities: [],
  * };
  * ```
  */
@@ -176,12 +183,21 @@ export type RegisterAckMessage = {
     readonly protocolVersion: RemoteWorkerProtocolVersion;
     readonly workerId: string;
     readonly queue: string;
-    readonly activities: readonly string[];
     readonly concurrency: number;
+    readonly acceptedManifestDigest: string;
+    readonly serverCapabilities: readonly string[];
 };
 /**
  * Registration rejection sent before closing an unsupported worker stream.
  *
+ * `deployment_conflict` means the manifest's `(deploymentName, buildId)` pair
+ * was already registered with a different `artifactDigest`.
+ * `registration_rejected` means a configured `WorkerAdmissionPolicy` refused
+ * the worker. `supportedProtocolVersions` describes the *other* peer's
+ * supported versions — for a worker parsing a rejection from a server
+ * running a different release, that is deliberately not narrowed to
+ * `RemoteWorkerProtocolVersion`.
+ *
  * @example
  * ```ts
  * import type { RegisterErrorMessage } from '@lostgradient/weft/worker-protocol';
@@ -190,16 +206,16 @@ export type RegisterAckMessage = {
  *   type: 'registerError',
  *   code: 'unsupported_protocol_version',
  *   message: 'Unsupported RemoteWorker protocol version: 1',
- *   supportedProtocolVersions: [2],
+ *   supportedProtocolVersions: [3],
  *   requestedProtocolVersion: 1,
  * };
  * ```
  */
 export type RegisterErrorMessage = {
     readonly type: 'registerError';
-    readonly code: 'invalid_registration' | 'unsupported_protocol_version';
+    readonly code: 'invalid_registration' | 'unsupported_protocol_version' | 'deployment_conflict' | 'registration_rejected';
     readonly message: string;
-    readonly supportedProtocolVersions: readonly RemoteWorkerProtocolVersion[];
+    readonly supportedProtocolVersions: readonly number[];
     readonly requestedProtocolVersion?: number;
 };
 /**

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

@@ -26,7 +26,7 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
     readonly register: {
         readonly type: "object";
         readonly additionalProperties: false;
-        readonly required: readonly ["type", "protocolVersion", "workerId", "activities"];
+        readonly required: readonly ["type", "protocolVersion", "workerId", "manifest"];
         readonly properties: {
             readonly type: {
                 readonly const: "register";
@@ -36,42 +36,17 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                 readonly type: "string";
                 readonly minLength: 1;
             };
-            readonly activities: {
-                readonly type: "array";
-                readonly items: {
-                    readonly type: "string";
-                    readonly minLength: 1;
-                };
+            readonly manifest: {
+                readonly type: "object";
             };
             readonly concurrency: {
                 readonly type: "number";
                 readonly minimum: 1;
                 readonly maximum: 1000;
             };
-            readonly queue: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly deploymentName: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly buildId: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly runtimeVersion: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly gitSha: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
             readonly startedAt: {
                 readonly type: "number";
             };
-            readonly capabilities: JsonSchemaObject;
         };
     };
     readonly heartbeat: {
@@ -220,7 +195,7 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
     readonly registerAck: {
         readonly type: "object";
         readonly additionalProperties: false;
-        readonly required: readonly ["type", "protocolVersion", "workerId", "queue", "activities", "concurrency"];
+        readonly required: readonly ["type", "protocolVersion", "workerId", "queue", "concurrency", "acceptedManifestDigest", "serverCapabilities"];
         readonly properties: {
             readonly type: {
                 readonly const: "registerAck";
@@ -234,18 +209,22 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                 readonly type: "string";
                 readonly minLength: 1;
             };
-            readonly activities: {
+            readonly concurrency: {
+                readonly type: "number";
+                readonly minimum: 1;
+                readonly maximum: 1000;
+            };
+            readonly acceptedManifestDigest: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly serverCapabilities: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
             };
-            readonly concurrency: {
-                readonly type: "number";
-                readonly minimum: 1;
-                readonly maximum: 1000;
-            };
         };
     };
     readonly registerError: {
@@ -257,14 +236,16 @@ export declare const REMOTE_WORKER_MESSAGE_SCHEMAS: {
                 readonly const: "registerError";
             };
             readonly code: {
-                readonly enum: readonly ["invalid_registration", "unsupported_protocol_version"];
+                readonly enum: readonly ["invalid_registration", "unsupported_protocol_version", "deployment_conflict", "registration_rejected"];
             };
             readonly message: {
                 readonly type: "string";
             };
             readonly supportedProtocolVersions: {
                 readonly type: "array";
-                readonly items: JsonSchemaObject;
+                readonly items: {
+                    readonly type: "number";
+                };
             };
             readonly requestedProtocolVersion: {
                 readonly type: "number";
@@ -332,7 +313,7 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
             readonly register: {
                 readonly type: "object";
                 readonly additionalProperties: false;
-                readonly required: readonly ["type", "protocolVersion", "workerId", "activities"];
+                readonly required: readonly ["type", "protocolVersion", "workerId", "manifest"];
                 readonly properties: {
                     readonly type: {
                         readonly const: "register";
@@ -342,42 +323,17 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly activities: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
+                    readonly manifest: {
+                        readonly type: "object";
                     };
                     readonly concurrency: {
                         readonly type: "number";
                         readonly minimum: 1;
                         readonly maximum: 1000;
                     };
-                    readonly queue: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly deploymentName: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly buildId: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly runtimeVersion: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly gitSha: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
                     readonly startedAt: {
                         readonly type: "number";
                     };
-                    readonly capabilities: JsonSchemaObject;
                 };
             };
             readonly heartbeat: {
@@ -526,7 +482,7 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
             readonly registerAck: {
                 readonly type: "object";
                 readonly additionalProperties: false;
-                readonly required: readonly ["type", "protocolVersion", "workerId", "queue", "activities", "concurrency"];
+                readonly required: readonly ["type", "protocolVersion", "workerId", "queue", "concurrency", "acceptedManifestDigest", "serverCapabilities"];
                 readonly properties: {
                     readonly type: {
                         readonly const: "registerAck";
@@ -540,18 +496,22 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly activities: {
+                    readonly concurrency: {
+                        readonly type: "number";
+                        readonly minimum: 1;
+                        readonly maximum: 1000;
+                    };
+                    readonly acceptedManifestDigest: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly serverCapabilities: {
                         readonly type: "array";
                         readonly items: {
                             readonly type: "string";
                             readonly minLength: 1;
                         };
                     };
-                    readonly concurrency: {
-                        readonly type: "number";
-                        readonly minimum: 1;
-                        readonly maximum: 1000;
-                    };
                 };
             };
             readonly registerError: {
@@ -563,14 +523,16 @@ export declare const REMOTE_WORKER_PROTOCOL_JSON_SCHEMA: {
                         readonly const: "registerError";
                     };
                     readonly code: {
-                        readonly enum: readonly ["invalid_registration", "unsupported_protocol_version"];
+                        readonly enum: readonly ["invalid_registration", "unsupported_protocol_version", "deployment_conflict", "registration_rejected"];
                     };
                     readonly message: {
                         readonly type: "string";
                     };
                     readonly supportedProtocolVersions: {
                         readonly type: "array";
-                        readonly items: JsonSchemaObject;
+                        readonly items: {
+                            readonly type: "number";
+                        };
                     };
                     readonly requestedProtocolVersion: {
                         readonly type: "number";

package/dist/worker/protocol-schemas.js

@@ -14,23 +14,14 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
   register: {
     type: "object",
     additionalProperties: !1,
-    required: ["type", "protocolVersion", "workerId", "activities"],
+    required: ["type", "protocolVersion", "workerId", "manifest"],
     properties: {
       type: { const: "register" },
       protocolVersion: protocolVersionSchema,
       workerId: { type: "string", minLength: 1 },
-      activities: {
-        type: "array",
-        items: { type: "string", minLength: 1 }
-      },
+      manifest: { type: "object" },
       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: jsonObjectSchema
+      startedAt: { type: "number" }
     }
   },
   heartbeat: {
@@ -118,17 +109,26 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
   registerAck: {
     type: "object",
     additionalProperties: !1,
-    required: ["type", "protocolVersion", "workerId", "queue", "activities", "concurrency"],
+    required: [
+      "type",
+      "protocolVersion",
+      "workerId",
+      "queue",
+      "concurrency",
+      "acceptedManifestDigest",
+      "serverCapabilities"
+    ],
     properties: {
       type: { const: "registerAck" },
       protocolVersion: protocolVersionSchema,
       workerId: { type: "string", minLength: 1 },
       queue: { type: "string", minLength: 1 },
-      activities: {
+      concurrency: { type: "number", minimum: 1, maximum: 1000 },
+      acceptedManifestDigest: { type: "string", minLength: 1 },
+      serverCapabilities: {
         type: "array",
         items: { type: "string", minLength: 1 }
-      },
-      concurrency: { type: "number", minimum: 1, maximum: 1000 }
+      }
     }
   },
   registerError: {
@@ -137,11 +137,18 @@ export const REMOTE_WORKER_MESSAGE_SCHEMAS = {
     required: ["type", "code", "message", "supportedProtocolVersions"],
     properties: {
       type: { const: "registerError" },
-      code: { enum: ["invalid_registration", "unsupported_protocol_version"] },
+      code: {
+        enum: [
+          "invalid_registration",
+          "unsupported_protocol_version",
+          "deployment_conflict",
+          "registration_rejected"
+        ]
+      },
       message: { type: "string" },
       supportedProtocolVersions: {
         type: "array",
-        items: protocolVersionSchema
+        items: { type: "number" }
       },
       requestedProtocolVersion: { type: "number" }
     }