@lostgradient/weft 0.11.0 → 0.13.0

package/dist/server/handler/index.d.ts

@@ -9,14 +9,23 @@
  *
  * @module server/handler
  */
-import type { Engine } from '../../core/engine.ts';
+import type { RegistryAgnosticEngine } from '../../core/engine.ts';
 import { type HandlerOptions } from './route-dispatch.ts';
 export { authContextToPrincipal } from './auth-context-principal.ts';
 export { isOperationFaultLike, type HandlerOptions } from './route-dispatch.ts';
 export { extractRouteParameters, getRequiredRouteParameter } from './route-matching.ts';
+export { createEngineEventFeedBackend } from '../engine-event-feed-backend.ts';
+export { createFleetEventFeed, type FleetEventEnvelope, type FleetEventFeed, } from '../fleet-event-feed.ts';
+export { createWorkflowEventFeed, type Cursor, type EventEnvelope, type WorkflowEventFeed, type WorkflowEventFeedBackend, } from '../workflow-event-feed.ts';
 /**
  * Pure HTTP request handler. Maps Request to Response.
  *
+ * `engine` is typed as {@link RegistryAgnosticEngine} (see its JSDoc) rather
+ * than the plain default `Engine`, so both `new Engine({ storage })` and
+ * `Engine.create({ workflows })` type-check here directly. This module's
+ * dispatch chain only calls registry-erased `Engine` methods, so the value is
+ * registry-erased back to the plain `Engine` once, internally.
+ *
  * @example
  * ```ts
  * import { workflow, Engine, MemoryStorage, handleRequest } from '@lostgradient/weft';
@@ -29,4 +38,4 @@ export { extractRouteParameters, getRequiredRouteParameter } from './route-match
  * console.log(response.status); // 200
  * ```
  */
-export declare function handleRequest(request: Request, engine: Engine, options?: HandlerOptions): Promise<Response>;
+export declare function handleRequest(request: Request, engine: RegistryAgnosticEngine, options?: HandlerOptions): Promise<Response>;

package/dist/server/handler/index.js

@@ -12,6 +12,13 @@ import { matchDirectRoute } from "./route-matching.js";
 export { authContextToPrincipal } from "./auth-context-principal.js";
 export { isOperationFaultLike } from "./route-dispatch.js";
 export { extractRouteParameters, getRequiredRouteParameter } from "./route-matching.js";
+export { createEngineEventFeedBackend } from "../engine-event-feed-backend.js";
+export {
+  createFleetEventFeed
+} from "../fleet-event-feed.js";
+export {
+  createWorkflowEventFeed
+} from "../workflow-event-feed.js";
 function matchRouteBoundary(matcher) {
   try {
     return { kind: "matched", value: matcher() };
@@ -68,7 +75,7 @@ async function dispatchMatchedRoute(request, engine, options, url) {
     return directRouteLookup.response;
   if (directRouteLookup.value !== null)
     return dispatchDirectRoute(request, engine, directRouteLookup.value, options, url);
-  const restBindings = options?.restBindings ?? defaultRestBindings(), operationRegistry = options?.operationRegistry ?? defaultOperationRegistry(), bindingLookup = matchRouteBoundary(() => matchRestBinding(request.method, url.pathname, restBindings));
+  const restBindings = options?.restBindings ?? defaultRestBindings(), operationRegistry = options?.operationRegistry ?? defaultOperationRegistry(options), bindingLookup = matchRouteBoundary(() => matchRestBinding(request.method, url.pathname, restBindings));
   if (bindingLookup.kind === "malformed")
     return bindingLookup.response;
   if (bindingLookup.value !== null)

package/dist/server/handler/route-dispatch.d.ts

@@ -1,5 +1,6 @@
 import type { Engine } from '../../core/engine.ts';
 import { type PrometheusExporter } from '../../observability/metrics.ts';
+import type { WorkerRegistry } from '../../worker/registry.ts';
 import type { AuthContext } from '../authentication.ts';
 import type { DiscoveryInfo } from '../discovery-info.ts';
 import type { FleetEventFeed } from '../fleet-event-feed.ts';
@@ -9,6 +10,7 @@ import type { OperationFault } from '../operation-fault.ts';
 import type { WorkflowStreamConnectionAcquirer } from '../operations/workflow-events-sse.ts';
 import type { Principal } from '../principal.ts';
 import { type UnknownRestBinding } from '../rest-bindings.ts';
+import type { TaskQueue } from '../task-queue.ts';
 import type { WorkflowEventFeed } from '../workflow-event-feed.ts';
 import type { DirectRouteHandlerName } from './route-matching.ts';
 import { type LiveEventStreamContext } from './sse-route-dispatch.ts';
@@ -16,8 +18,9 @@ import { type LiveEventStreamContext } from './sse-route-dispatch.ts';
  * Options bag passed to `handleRequest` by the HTTP server wrapper.
  *
  * Injects the resolved authentication context, custom metrics exporters, and
- * an optional override for the operation registry and REST bindings.  Omit
- * `operationRegistry` and `restBindings` together to use the live defaults.
+ * an optional override for the operation registry and REST bindings. Omit
+ * `operationRegistry` and `restBindings` together to use the live defaults,
+ * optionally bound to the supplied worker registry and task queue.
  *
  * @example
  * ```ts
@@ -41,6 +44,10 @@ export interface HandlerOptions {
      * from the OpenTelemetry SDK (e.g. via `@opentelemetry/exporter-prometheus`).
      */
     prometheusExporter?: PrometheusExporter;
+    /** Live worker state used by worker and task-diagnostics operations. */
+    workerRegistry?: WorkerRegistry;
+    /** Live task-queue state used by queue and task-diagnostics operations. */
+    taskQueue?: TaskQueue;
     /**
      * Operation registry for pipeline dispatch. Must be supplied together
      * with `restBindings` — a caller that overrides one but not the other
@@ -133,5 +140,5 @@ export declare function dispatchViaExecuteOperation(request: Request, engine: En
  * ```
  */
 export declare function isOperationFaultLike(value: unknown): value is OperationFault;
-export declare function defaultOperationRegistry(): OperationRegistry;
+export declare function defaultOperationRegistry(options?: Pick<HandlerOptions, 'workerRegistry' | 'taskQueue'>): OperationRegistry;
 export declare function defaultRestBindings(): ReadonlyArray<UnknownRestBinding>;

package/dist/server/handler/route-dispatch.js

@@ -94,19 +94,19 @@ export const DIRECT_ROUTE_EXECUTORS = {
     return jsonResponse(generateMcpDiscovery({ origin: originResolution.origin }));
   },
   openApiDocument: async ({ options }) => jsonResponse(generateOpenApiDocument({
-    registry: options?.operationRegistry ?? defaultOperationRegistry(),
+    registry: options?.operationRegistry ?? defaultOperationRegistry(options),
     ...options?.restBindings !== void 0 ? { restBindings: options.restBindings } : {},
     ...options?.supportedAuthenticationSchemes !== void 0 ? { supportedSchemes: options.supportedAuthenticationSchemes } : {},
     ...options?.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {}
   })),
   openRpcDocument: async ({ engine, options }) => jsonResponse(generateOpenRpcDocument({
-    registry: options?.operationRegistry ?? defaultOperationRegistry(),
+    registry: options?.operationRegistry ?? defaultOperationRegistry(options),
     transports: ["http", "websocket"],
     mcpTools: listMcpTools(engine),
     ...options?.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {}
   })),
   asyncApiDocument: async ({ options }) => jsonResponse(generateAsyncApiDocument({
-    registry: options?.operationRegistry ?? defaultOperationRegistry(),
+    registry: options?.operationRegistry ?? defaultOperationRegistry(options),
     ...options?.restBindings !== void 0 ? { restBindings: options.restBindings } : {},
     ...options?.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {}
   }))
@@ -173,7 +173,22 @@ export function isOperationFaultLike(value) {
   return typeof fields.code === "string" && Object.hasOwn(FAULT_CODE_TO_HTTP_STATUS, fields.code) && typeof fields.message === "string" && typeof fields.data === "object" && fields.data !== null && !Array.isArray(fields.data);
 }
 let defaultOperationRegistryCache;
-export function defaultOperationRegistry() {
+const missingWorkerRegistryCacheKey = {}, missingTaskQueueCacheKey = {}, liveOperationRegistryCache = new WeakMap;
+export function defaultOperationRegistry(options) {
+  if (options?.workerRegistry !== void 0 || options?.taskQueue !== void 0) {
+    const workerRegistryCacheKey = options.workerRegistry ?? missingWorkerRegistryCacheKey, taskQueueCacheKey = options.taskQueue ?? missingTaskQueueCacheKey;
+    let registriesByTaskQueue = liveOperationRegistryCache.get(workerRegistryCacheKey);
+    if (registriesByTaskQueue === void 0) {
+      registriesByTaskQueue = new WeakMap;
+      liveOperationRegistryCache.set(workerRegistryCacheKey, registriesByTaskQueue);
+    }
+    let registry = registriesByTaskQueue.get(taskQueueCacheKey);
+    if (registry === void 0) {
+      registry = createLiveOperationRegistry(options);
+      registriesByTaskQueue.set(taskQueueCacheKey, registry);
+    }
+    return registry;
+  }
   if (defaultOperationRegistryCache === void 0)
     defaultOperationRegistryCache = createLiveOperationRegistry();
   return defaultOperationRegistryCache;