@lostgradient/weft 0.18.0 → 0.20.0

package/dist/worker/registry.js

@@ -1,4 +1,16 @@
+import {
+  DeploymentConsistencyGuard
+} from "./registry/deployment-consistency.js";
+import {
+  createDrainRecord,
+  isWorkerDraining,
+  workerHealth
+} from "./registry/drain.js";
 import { FairShareCounters } from "./registry/fair-share.js";
+import {
+  appendRegistrationRejection,
+  recentRegistrationRejections
+} from "./registry/rejections.js";
 import {
   matchesWorkerCapabilities,
   pickFairShare,
@@ -18,6 +30,8 @@ export class WorkerRegistry {
   #policy;
   #roundRobinCursor;
   #fairShareCounts;
+  #deploymentConsistency;
+  #rejections;
   constructor(options) {
     this.#workers = new Map;
     this.#inFlightTasks = new Map;
@@ -25,10 +39,18 @@ export class WorkerRegistry {
     this.#policy = options?.policy ?? "least-loaded";
     this.#roundRobinCursor = new Map;
     this.#fairShareCounts = new FairShareCounters;
+    this.#deploymentConsistency = new DeploymentConsistencyGuard;
+    this.#rejections = [];
   }
   get policy() {
     return this.#policy;
   }
+  checkDeploymentConsistency(deploymentName, buildId, artifactDigest) {
+    return this.#deploymentConsistency.check(deploymentName, buildId, artifactDigest);
+  }
+  recordDeploymentConsistency(deploymentName, buildId, artifactDigest) {
+    this.#deploymentConsistency.record(deploymentName, buildId, artifactDigest);
+  }
   register(info) {
     const now = Date.now();
     let inFlight = 0;
@@ -43,7 +65,8 @@ export class WorkerRegistry {
       ...info.deploymentName !== void 0 ? { deploymentName: info.deploymentName } : {},
       ...info.buildId !== void 0 ? { buildId: info.buildId } : {},
       ...info.runtimeVersion !== void 0 ? { runtimeVersion: info.runtimeVersion } : {},
-      ...info.gitSha !== void 0 ? { gitSha: info.gitSha } : {},
+      manifest: info.manifest,
+      acceptedManifestDigest: info.acceptedManifestDigest,
       startedAt: info.startedAt ?? now,
       capabilities: { ...info.capabilities },
       inFlight,
@@ -98,7 +121,7 @@ export class WorkerRegistry {
       return !1;
     if (!matchesWorkerCapabilities(worker, activityName, queue))
       return !1;
-    if (this.#isWorkerDraining(worker))
+    if (isWorkerDraining(worker, this.#deploymentDrainStates))
       return !1;
     return !0;
   }
@@ -124,6 +147,15 @@ export class WorkerRegistry {
     this.#inFlightTasks.set(operationId, task);
     this.taskAssigned(workerId);
   }
+  releaseReservation(operationId) {
+    const task = this.#inFlightTasks.get(operationId);
+    if (task === void 0)
+      return;
+    this.#inFlightTasks.delete(operationId);
+    this.taskCompleted(task.workerId);
+    this.#releaseFairShare(task);
+    return task;
+  }
   checkExpiredTasks(now) {
     const expired = [];
     for (const task of this.#inFlightTasks.values())
@@ -179,6 +211,12 @@ export class WorkerRegistry {
   getAll() {
     return [...this.#workers.values()];
   }
+  recordRejection(entry) {
+    appendRegistrationRejection(this.#rejections, entry);
+  }
+  getRecentRejections(limit) {
+    return recentRegistrationRejections(this.#rejections, limit);
+  }
   markWorkerDraining(workerId, options) {
     const worker = this.#workers.get(workerId);
     if (worker === void 0)
@@ -194,7 +232,7 @@ export class WorkerRegistry {
       workerId,
       affectedWorkers: 1,
       inFlight: worker.inFlight,
-      health: this.#workerHealth(worker)
+      health: workerHealth(worker, this.#deploymentDrainStates)
     };
   }
   clearWorkerDrain(workerId) {
@@ -208,7 +246,7 @@ export class WorkerRegistry {
       workerId,
       affectedWorkers: 1,
       inFlight: worker.inFlight,
-      health: this.#workerHealth(worker)
+      health: workerHealth(worker, this.#deploymentDrainStates)
     };
   }
   markDeploymentDraining(deploymentName, options) {
@@ -234,11 +272,10 @@ export class WorkerRegistry {
       lastHeartbeat: worker.lastHeartbeat,
       startedAt: worker.startedAt,
       capabilities: worker.capabilities,
-      health: this.#workerHealth(worker),
+      health: workerHealth(worker, this.#deploymentDrainStates),
       deploymentName: worker.deploymentName,
       buildId: worker.buildId,
-      runtimeVersion: worker.runtimeVersion,
-      gitSha: worker.gitSha
+      runtimeVersion: worker.runtimeVersion
     }));
   }
   getDeploymentSummaries(_now) {
@@ -249,7 +286,7 @@ export class WorkerRegistry {
     return this.#workers.size;
   }
   #deploymentDrainResult(deploymentName) {
-    const workers = [...this.#workers.values()].filter((worker) => worker.deploymentName === deploymentName), inFlight = workers.reduce((total, worker) => total + worker.inFlight, 0), healthValues = workers.map((worker) => this.#workerHealth(worker));
+    const workers = [...this.#workers.values()].filter((worker) => worker.deploymentName === deploymentName), inFlight = workers.reduce((total, worker) => total + worker.inFlight, 0), healthValues = workers.map((worker) => workerHealth(worker, this.#deploymentDrainStates));
     return {
       target: "deployment",
       deploymentName,
@@ -258,33 +295,9 @@ export class WorkerRegistry {
       health: deploymentHealth(healthValues, this.#deploymentDrainStates.has(deploymentName))
     };
   }
-  #isWorkerDraining(worker) {
-    return this.#drainRecordForWorker(worker) !== void 0;
-  }
-  #workerHealth(worker) {
-    if (!this.#isWorkerDraining(worker))
-      return "active";
-    return worker.inFlight > 0 ? "draining" : "drained";
-  }
-  #drainRecordForWorker(worker) {
-    if (worker.drainStartedAt !== void 0)
-      return {
-        startedAt: worker.drainStartedAt,
-        ...worker.drainReason !== void 0 ? { reason: worker.drainReason } : {}
-      };
-    if (worker.deploymentName === void 0)
-      return;
-    return this.#deploymentDrainStates.get(worker.deploymentName);
-  }
   #releaseFairShare(task) {
     if (task.fairShareKey === void 0)
       return;
     this.#fairShareCounts.release(task.workerId, task.fairShareKey);
   }
 }
-function createDrainRecord(options) {
-  return {
-    startedAt: options?.updatedAt ?? Date.now(),
-    ...options?.reason !== void 0 ? { reason: options.reason } : {}
-  };
-}

package/dist/workers/workflow-worker-entry.d.ts

@@ -9,16 +9,21 @@
  */
 import type { WorkerWorkflowContext } from './workflow-runner.ts';
 /**
- * Factory that resolves a workflow type name to its handler. Handlers receive
- * a worker-side {@link WorkerWorkflowContext} as the first argument so they
- * can read `ctx.workflowId` exactly like inline-mode handlers do.
+ * A workflow handler. Receives a worker-side {@link WorkerWorkflowContext} as
+ * the first argument so it can read `ctx.workflowId` exactly like inline-mode
+ * handlers do.
  */
-export type WorkflowHandlerFactory = (type: string) => ((ctx: WorkerWorkflowContext, input: unknown) => AsyncGenerator) | undefined;
+export type WorkflowHandler = (ctx: WorkerWorkflowContext, input: unknown) => AsyncGenerator;
 /**
  * Initialize the worker message loop. Call this from within a Web Worker
  * to wire up the message protocol.
  *
- * @param getWorkflowHandler - Factory that resolves a workflow type name to
- *   its async generator function. Typically backed by a registration map.
+ * Sends a {@link WorkerRealmReadyMessage} first (WFT-28), built from exactly the
+ * workflow type names in `workflows` — the host validates it against its own
+ * expected manifest before this realm can receive its first `run` turn.
+ *
+ * @param workflows - Map of workflow type name to its async generator
+ *   function. This is also the realm's complete workflow-type advertisement:
+ *   the same names the ready manifest reports.
  */
-export declare function initializeWorkerMessageLoop(getWorkflowHandler: WorkflowHandlerFactory): void;
+export declare function initializeWorkerMessageLoop(workflows: Readonly<Record<string, WorkflowHandler>>): void;

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

@@ -3,6 +3,7 @@ import {
   createBoundedWorkerFailureMessage,
   WORKER_PROTOCOL_VERSION
 } from "../core/worker-protocol.js";
+import { buildInternalRealmManifest } from "../worker/manifest/internal-realm.js";
 import {
   cleanupWorkflowRunnerState,
   createWorkflowRunnerContext,
@@ -14,8 +15,14 @@ const workerPostMessage = self.postMessage.bind(self), workerClose = "close" in
   assertWorkerProtocolMessageWithinLimit(message, maxProtocolMessageBytes);
   workerPostMessage(message);
 };
-export function initializeWorkerMessageLoop(getWorkflowHandler) {
-  const runnerContext = createWorkflowRunnerContext();
+export function initializeWorkerMessageLoop(workflows) {
+  const runnerContext = createWorkflowRunnerContext(), getWorkflowHandler = (type) => workflows[type], readyMessage = {
+    type: "ready",
+    protocolVersion: WORKER_PROTOCOL_VERSION,
+    realmGeneration: crypto.randomUUID(),
+    manifest: buildInternalRealmManifest(Object.keys(workflows))
+  };
+  workerPostMessage(readyMessage);
   self.addEventListener("message", async (event) => {
     const message = event.data;
     switch (message.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lostgradient/weft",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "A Bun-native durable execution engine with pluggable key-value storage.",
   "keywords": [
     "bun",
@@ -283,8 +283,8 @@
     "husky": "^9.1.7",
     "lint-staged": "^16.4.0",
     "lmdb": "^3.5.2",
-    "oxlint": "^1.56.0",
-    "oxlint-tsgolint": "^0.17.0",
+    "oxlint": "^1.79.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "pg": "^8.11.0",
     "playwright": "^1.60.0",
     "prettier": "^3.8.1",

package/dist/server/task-resolved-record.d.ts

@@ -1,12 +0,0 @@
-import type { InflightRecord, ResolvedRecord, TaskResolutionReason } from './task-state.ts';
-export declare function buildResolvedRecord(parameters: {
-    operationId: string;
-    status: 'completed' | 'failed';
-    resolvedAt: number;
-    normalizedRecord: InflightRecord | null;
-    resolutionReason: TaskResolutionReason;
-    value?: unknown;
-    error?: string | undefined;
-    queueLatencyMs?: number | undefined;
-    executionLatencyMs?: number | undefined;
-}): ResolvedRecord;

package/dist/server/task-resolved-record.js

@@ -1,35 +0,0 @@
-export function buildResolvedRecord(parameters) {
-  const resolvedRecord = {
-    operationId: parameters.operationId,
-    status: parameters.status,
-    resolvedAt: parameters.resolvedAt
-  };
-  if (parameters.value !== void 0)
-    resolvedRecord.value = parameters.value;
-  if (parameters.error !== void 0)
-    resolvedRecord.error = parameters.error;
-  const { normalizedRecord } = parameters;
-  if (normalizedRecord === null)
-    return resolvedRecord;
-  return {
-    ...resolvedRecord,
-    activityName: normalizedRecord.activityName,
-    queue: normalizedRecord.queue,
-    workerId: normalizedRecord.workerId,
-    attempt: normalizedRecord.attempt,
-    visibilityTimeout: normalizedRecord.visibilityTimeout,
-    ...normalizedRecord.workflowId === void 0 ? {} : { workflowId: normalizedRecord.workflowId },
-    firstQueuedAt: normalizedRecord.firstQueuedAt,
-    lastQueuedAt: normalizedRecord.lastQueuedAt,
-    lastDispatchedAt: normalizedRecord.lastDispatchedAt,
-    startedAt: normalizedRecord.startedAt,
-    completedAt: parameters.resolvedAt,
-    lastHeartbeatAt: normalizedRecord.lastHeartbeatAt,
-    retryCount: normalizedRecord.retryCount,
-    requeueCount: normalizedRecord.requeueCount,
-    lastRequeueReason: normalizedRecord.lastRequeueReason,
-    resolutionReason: parameters.resolutionReason,
-    queueLatencyMs: parameters.queueLatencyMs,
-    executionLatencyMs: parameters.executionLatencyMs
-  };
-}