@lostgradient/weft 0.3.0 → 0.5.0

package/dist/server/json-rpc-transport-helpers.d.ts

@@ -13,5 +13,6 @@ export declare function handleJsonRpcHttpRequestSafely(args: {
     registry: OperationRegistry;
     engine: Engine;
     authContext: AuthContext | undefined;
+    maxBodyBytes?: number;
 }): Promise<Response>;
 export {};

package/dist/server/json-rpc-transport-helpers.js

@@ -10,7 +10,8 @@ export async function handleJsonRpcHttpRequestSafely(args) {
     return await handleJsonRpcHttpRequest(args.request, {
       registry: args.registry,
       engine: args.engine,
-      principal: authContextToPrincipal(args.authContext)
+      principal: authContextToPrincipal(args.authContext),
+      ...args.maxBodyBytes !== void 0 ? { maxBodyBytes: args.maxBodyBytes } : {}
     });
   } catch (error) {
     console.error("Unhandled error in /jsonrpc", { error });

package/dist/server/json-rpc-websocket-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { ServerWebSocket } from 'bun';
+import type { FleetEventFeed } from './fleet-event-feed.ts';
 import { type JsonRpcWebSocketSession } from './json-rpc-websocket.ts';
 import type { OperationRegistry } from './operation-catalog.ts';
 import { type Principal } from './principal.ts';
@@ -13,12 +14,19 @@ export interface WebSocketData {
     workerId?: string;
     workerRegistered?: boolean;
     workerProtocolVersion?: number;
-    lastDeliveredSequence?: number;
-    replayInProgress?: boolean;
+    streamLastDeliveredSequence?: number;
+    streamReplayInProgress?: boolean;
     pendingStreamMessages?: Array<{
         sequence: number;
         message: string;
     }>;
+    watchLastDeliveredSequence?: number;
+    watchReplayInProgress?: boolean;
+    pendingWatchMessages?: Array<{
+        sequence: number;
+        message: string;
+    }>;
+    workflowStreamConnectionAccepted?: boolean;
     principal?: Principal;
     jsonRpcSession?: JsonRpcWebSocketSession;
 }
@@ -28,6 +36,7 @@ export declare function openJsonRpcWebSocketSession(options: {
     registry: OperationRegistry;
     engine: unknown;
     feed: WorkflowEventFeed;
+    fleetFeed?: FleetEventFeed;
     activeSessions: Set<JsonRpcWebSocketSession>;
 }): void;
 export declare function closeJsonRpcWebSocketSession(options: {

package/dist/server/json-rpc-websocket-runtime.js

@@ -22,6 +22,7 @@ export function openJsonRpcWebSocketSession(options) {
       principal: options.ws.data.principal ?? anonymousPrincipal(),
       emitter: { send: (message) => options.ws.send(message) },
       feed: options.feed,
+      ...options.fleetFeed !== void 0 ? { fleetFeed: options.fleetFeed } : {},
       transport: "jsonRpcWebSocket"
     });
     options.ws.data.jsonRpcSession = session;

package/dist/server/json-rpc-websocket-subscriptions.d.ts

@@ -0,0 +1,10 @@
+export declare const SESSION_METHODS: {
+    readonly SUBSCRIBE: "weft.workflows.subscribe";
+    readonly FLEET_SUBSCRIBE: "weft.events.subscribe";
+    readonly UNSUBSCRIBE: "weft.workflows.unsubscribe";
+    readonly DELIVER: "weft.events.deliver";
+    readonly TERMINATED: "weft.events.terminated";
+};
+export declare const WORKFLOW_EVENTS_OPERATION_NAME = "weft.workflows.events";
+export declare const FLEET_EVENTS_OPERATION_NAME = "weft.events.subscribe";
+export declare function createSubscriptionErrorTerminatedFrame(subscriptionId: string, error: unknown): Record<string, unknown>;

package/dist/server/json-rpc-websocket-subscriptions.js

@@ -0,0 +1,29 @@
+import { JSON_RPC_VERSION } from "./json-rpc-protocol.js";
+import { SubscriptionElementValidationError } from "./operation-catalog.js";
+import { isOperationFault } from "./operations/operation-helpers.js";
+export const SESSION_METHODS = {
+  SUBSCRIBE: "weft.workflows.subscribe",
+  FLEET_SUBSCRIBE: "weft.events.subscribe",
+  UNSUBSCRIBE: "weft.workflows.unsubscribe",
+  DELIVER: "weft.events.deliver",
+  TERMINATED: "weft.events.terminated"
+}, WORKFLOW_EVENTS_OPERATION_NAME = "weft.workflows.events", FLEET_EVENTS_OPERATION_NAME = "weft.events.subscribe";
+const ENGINE_FAILURE_FAULT = {
+  code: "EngineFailure",
+  message: "internal error",
+  data: {}
+};
+export function createSubscriptionErrorTerminatedFrame(subscriptionId, error) {
+  if (error instanceof SubscriptionElementValidationError)
+    return createSubscriptionTerminatedFrame(subscriptionId, "validation-failed", error.fault);
+  if (isOperationFault(error))
+    return createSubscriptionTerminatedFrame(subscriptionId, "server-closed", error);
+  return createSubscriptionTerminatedFrame(subscriptionId, "server-closed", ENGINE_FAILURE_FAULT);
+}
+function createSubscriptionTerminatedFrame(subscriptionId, reason, fault) {
+  return {
+    jsonrpc: JSON_RPC_VERSION,
+    method: SESSION_METHODS.TERMINATED,
+    params: { subscriptionId, reason, fault }
+  };
+}

package/dist/server/json-rpc-websocket-types.d.ts

@@ -0,0 +1,22 @@
+import type { FleetEventFeed } from './fleet-event-feed.ts';
+import type { OperationRegistry } from './operation-catalog.ts';
+import type { Principal } from './principal.ts';
+import type { WorkflowEventFeed } from './workflow-event-feed.ts';
+export type JsonRpcWebSocketEmitter = {
+    send(message: string): void;
+};
+export type JsonRpcWebSocketSessionOptions = {
+    readonly registry: OperationRegistry;
+    readonly engine: unknown;
+    readonly principal: Principal;
+    readonly emitter: JsonRpcWebSocketEmitter;
+    readonly feed: WorkflowEventFeed;
+    readonly fleetFeed?: FleetEventFeed;
+    readonly maxSubscriptions?: number;
+    readonly maxFrameBytes?: number;
+    readonly transport?: 'jsonRpcHttp' | 'jsonRpcWebSocket' | 'jsonRpcStdio';
+};
+export type JsonRpcWebSocketSession = {
+    handleMessage(frame: string): Promise<void>;
+    close(): Promise<void>;
+};

package/dist/server/json-rpc-websocket-validation.js

@@ -8,13 +8,20 @@ export function validateSubscribeParams(params) {
   const workflowId = params?.workflowId;
   if (typeof workflowId !== "string" || workflowId.length === 0)
     return invalidParams("params.workflowId must be a non-empty string");
-  const selector = params?.selector;
-  if (selector !== "events" && selector !== "tokens")
-    return invalidParams("params.selector must be 'events' or 'tokens'");
+  const selector = validateSubscribeSelector(params?.selector);
+  if (!selector.ok)
+    return selector;
   const fromCursor = params?.fromCursor;
   if (fromCursor !== void 0 && typeof fromCursor !== "string")
     return invalidParams("params.fromCursor must be a string when present");
-  return { ok: !0, workflowId, selector, fromCursor };
+  return { ok: !0, workflowId, selector: selector.selector, fromCursor };
+}
+function validateSubscribeSelector(rawSelector) {
+  if (rawSelector === void 0)
+    return { ok: !0, selector: "events" };
+  if (rawSelector === "events" || rawSelector === "tokens")
+    return { ok: !0, selector: rawSelector };
+  return invalidParams("params.selector must be 'events' or 'tokens'");
 }
 export function validateMessageFrame(frame, maxFrameBytes) {
   if (Buffer.byteLength(frame, "utf8") > maxFrameBytes)
@@ -82,6 +89,15 @@ export function validateSessionPrimitiveFrame(frame) {
       },
       id: null
     };
+  if (Object.hasOwn(frame.parsed, "params") && frame.parsed.params !== void 0 && !isPlainObject(frame.parsed.params))
+    return {
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+        message: "params must be an object when present",
+        data: { weftCode: "InvalidParams", httpStatus: 400 }
+      },
+      id: frame.id ?? null
+    };
   return null;
 }
 function invalidParams(message) {

package/dist/server/json-rpc-websocket.d.ts

@@ -14,47 +14,6 @@
  *   - Guarantees every active subscription is torn down on `close()`
  *     (or socket disconnect at the transport layer).
  */
-import { type OperationRegistry } from './operation-catalog.ts';
-import type { Principal } from './principal.ts';
-import type { WorkflowEventFeed } from './workflow-event-feed.ts';
-/** Emitter interface: any `send(string)`-shaped object. */
-export type JsonRpcWebSocketEmitter = {
-    send(message: string): void;
-};
-export type JsonRpcWebSocketSessionOptions = {
-    readonly registry: OperationRegistry;
-    readonly engine: unknown;
-    readonly principal: Principal;
-    readonly emitter: JsonRpcWebSocketEmitter;
-    readonly feed: WorkflowEventFeed;
-    /**
-     * Maximum concurrent subscriptions per session. Default 100 — a
-     * well-behaved client should never need more. Rejected `subscribe`
-     * requests above the cap return `InvalidRequest (-32600)` so clients
-     * can distinguish resource exhaustion from other failures.
-     */
-    readonly maxSubscriptions?: number;
-    /**
-     * Maximum size of a single incoming frame in bytes. Default 1 MB.
-     * Frames exceeding the limit are rejected with a parse error before
-     * `JSON.parse` touches the payload — a runaway producer cannot force
-     * an unbounded allocation inside the adapter.
-     */
-    readonly maxFrameBytes?: number;
-    /**
-     * Transport identity for the dispatcher's transport-availability
-     * check. Defaults to `'jsonRpcWebSocket'`. The stdio session reuses
-     * this factory but must pass `'jsonRpcStdio'` so operations with
-     * `transports.jsonRpcStdio: false` are rejected on stdio and,
-     * conversely, operations that are stdio-only aren't rejected just
-     * because they haven't been enabled for WS.
-     */
-    readonly transport?: 'jsonRpcHttp' | 'jsonRpcWebSocket' | 'jsonRpcStdio';
-};
-export type JsonRpcWebSocketSession = {
-    /** Process one incoming WS frame (UTF-8 text). */
-    handleMessage(frame: string): Promise<void>;
-    /** Tear down every active subscription and release resources. */
-    close(): Promise<void>;
-};
+import type { JsonRpcWebSocketSession, JsonRpcWebSocketSessionOptions } from './json-rpc-websocket-types.ts';
+export type { JsonRpcWebSocketEmitter, JsonRpcWebSocketSession, JsonRpcWebSocketSessionOptions, } from './json-rpc-websocket-types.ts';
 export declare function createJsonRpcWebSocketSession(options: JsonRpcWebSocketSessionOptions): JsonRpcWebSocketSession;

package/dist/server/json-rpc-websocket.js

@@ -1,38 +1,21 @@
 import { faultToJsonRpcError } from "./fault-to-json-rpc.js";
 import { dispatchJsonRpc } from "./json-rpc-dispatch.js";
 import { JSON_RPC_ERROR_CODES, JSON_RPC_VERSION } from "./json-rpc-protocol.js";
+import {
+  createSubscriptionErrorTerminatedFrame,
+  FLEET_EVENTS_OPERATION_NAME,
+  SESSION_METHODS,
+  WORKFLOW_EVENTS_OPERATION_NAME
+} from "./json-rpc-websocket-subscriptions.js";
 import {
   validateMessageFrame,
   validateSessionPrimitiveFrame,
   validateSubscribeParams
 } from "./json-rpc-websocket-validation.js";
-import {
-  executeSubscription,
-  SubscriptionElementValidationError
-} from "./operation-catalog.js";
-import { workflowEventsSubscriptionOperation } from "./operations/workflow-events-subscription.js";
-const DEFAULT_MAX_SUBSCRIPTIONS = 100, DEFAULT_MAX_FRAME_BYTES = 1048576, SESSION_METHODS = {
-  SUBSCRIBE: "weft.workflows.subscribe",
-  UNSUBSCRIBE: "weft.workflows.unsubscribe",
-  DELIVER: "weft.events.deliver",
-  TERMINATED: "weft.events.terminated"
-}, WORKFLOW_EVENTS_OPERATION_NAME = "weft.workflows.events", WORKFLOW_EVENTS_SUBSCRIPTION_OPERATION = workflowEventsSubscriptionOperation;
-function withWorkflowEventsSubscriptionOperation(registry) {
-  if (registry.get(WORKFLOW_EVENTS_OPERATION_NAME) !== void 0)
-    return registry;
-  return {
-    get(name) {
-      if (name === WORKFLOW_EVENTS_OPERATION_NAME)
-        return WORKFLOW_EVENTS_SUBSCRIPTION_OPERATION;
-      return registry.get(name);
-    },
-    list() {
-      return [...registry.list(), WORKFLOW_EVENTS_SUBSCRIPTION_OPERATION];
-    }
-  };
-}
+import { executeSubscription } from "./operation-catalog.js";
+const DEFAULT_MAX_SUBSCRIPTIONS = 100, DEFAULT_MAX_FRAME_BYTES = 1048576;
 export function createJsonRpcWebSocketSession(options) {
-  const { registry, engine, principal, emitter, feed } = options, subscriptionRegistry = withWorkflowEventsSubscriptionOperation(registry), maxSubscriptions = options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS, maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES, transport = options.transport ?? "jsonRpcWebSocket", subscriptions = new Map;
+  const { registry, engine, principal, emitter, feed, fleetFeed } = options, maxSubscriptions = options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS, maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES, transport = options.transport ?? "jsonRpcWebSocket", subscriptions = new Map;
   let emitterBroken = !1, disposed = !1;
   function emit(message) {
     if (disposed || emitterBroken)
@@ -60,6 +43,26 @@ export function createJsonRpcWebSocketSession(options) {
       });
       return;
     }
+    await startSubscription(request, () => executeSubscription(WORKFLOW_EVENTS_OPERATION_NAME, {
+      workflowId: validation.workflowId,
+      selector: validation.selector,
+      ...validation.fromCursor === void 0 ? {} : { fromCursor: validation.fromCursor }
+    }, {
+      principal,
+      engine: { feed },
+      transport,
+      registry
+    }));
+  }
+  async function handleFleetSubscribe(request, params) {
+    await startSubscription(request, () => executeSubscription(FLEET_EVENTS_OPERATION_NAME, params ?? {}, {
+      principal,
+      engine: { fleetFeed },
+      transport,
+      registry
+    }));
+  }
+  async function startSubscription(request, execute) {
     if (subscriptions.size >= maxSubscriptions) {
       emitResponse(request, {
         jsonrpc: JSON_RPC_VERSION,
@@ -76,16 +79,7 @@ export function createJsonRpcWebSocketSession(options) {
       });
       return;
     }
-    const controller = new AbortController, result = await executeSubscription("weft.workflows.events", {
-      workflowId: validation.workflowId,
-      selector: validation.selector,
-      ...validation.fromCursor === void 0 ? {} : { fromCursor: validation.fromCursor }
-    }, {
-      principal,
-      engine: { feed },
-      transport,
-      registry: subscriptionRegistry
-    });
+    const controller = new AbortController, result = await execute();
     if (!result.ok) {
       const error = faultToJsonRpcError(result.fault);
       emitResponse(request, {
@@ -137,26 +131,7 @@ export function createJsonRpcWebSocketSession(options) {
         });
     } catch (error) {
       if (!signal.aborted && !shouldSuppressOutput())
-        if (error instanceof SubscriptionElementValidationError)
-          emit({
-            jsonrpc: JSON_RPC_VERSION,
-            method: SESSION_METHODS.TERMINATED,
-            params: {
-              subscriptionId,
-              reason: "validation-failed",
-              fault: error.fault
-            }
-          });
-        else
-          emit({
-            jsonrpc: JSON_RPC_VERSION,
-            method: SESSION_METHODS.TERMINATED,
-            params: {
-              subscriptionId,
-              reason: "server-closed",
-              fault: { code: "EngineFailure", message: "internal error", data: {} }
-            }
-          });
+        emit(createSubscriptionErrorTerminatedFrame(subscriptionId, error));
     } finally {
       signal.removeEventListener("abort", abortSubscription);
       await closeOnce().catch(() => {});
@@ -211,6 +186,30 @@ export function createJsonRpcWebSocketSession(options) {
       params: { subscriptionId, reason: "client-unsubscribed" }
     });
   }
+  function isSessionPrimitive(method) {
+    return method === SESSION_METHODS.SUBSCRIBE || method === WORKFLOW_EVENTS_OPERATION_NAME || method === SESSION_METHODS.FLEET_SUBSCRIBE || method === SESSION_METHODS.UNSUBSCRIBE;
+  }
+  async function handleSessionPrimitive(validation) {
+    const sessionPrimitiveError = validateSessionPrimitiveFrame(validation);
+    if (sessionPrimitiveError !== null) {
+      emit({
+        jsonrpc: JSON_RPC_VERSION,
+        error: sessionPrimitiveError.error,
+        id: sessionPrimitiveError.id
+      });
+      return;
+    }
+    const request = {
+      id: validation.id,
+      expectsResponse: validation.hasRequestId
+    };
+    if (validation.method === SESSION_METHODS.SUBSCRIBE || validation.method === WORKFLOW_EVENTS_OPERATION_NAME)
+      await handleSubscribe(request, validation.params);
+    else if (validation.method === SESSION_METHODS.FLEET_SUBSCRIBE)
+      await handleFleetSubscribe(request, validation.params);
+    else
+      handleUnsubscribe(request, validation.params);
+  }
   async function handleMessage(frame) {
     if (disposed || emitterBroken)
       return;
@@ -223,24 +222,8 @@ export function createJsonRpcWebSocketSession(options) {
       });
       return;
     }
-    if (validation.method === SESSION_METHODS.SUBSCRIBE || validation.method === SESSION_METHODS.UNSUBSCRIBE) {
-      const sessionPrimitiveError = validateSessionPrimitiveFrame(validation);
-      if (sessionPrimitiveError !== null) {
-        emit({
-          jsonrpc: JSON_RPC_VERSION,
-          error: sessionPrimitiveError.error,
-          id: sessionPrimitiveError.id
-        });
-        return;
-      }
-      const request = {
-        id: validation.id,
-        expectsResponse: validation.hasRequestId
-      };
-      if (validation.method === SESSION_METHODS.SUBSCRIBE)
-        await handleSubscribe(request, validation.params);
-      else
-        handleUnsubscribe(request, validation.params);
+    if (isSessionPrimitive(validation.method)) {
+      await handleSessionPrimitive(validation);
       return;
     }
     const result = await dispatchJsonRpc(validation.parsed, {

package/dist/server/openapi.d.ts

@@ -34,7 +34,8 @@ export type OpenApiOptions = {
     serverUrl?: string;
     /**
      * Security schemes the live server actually supports. When omitted,
-     * emit both schemes for backward-compatible call sites.
+     * emit both current API-key scheme names so generated clients can choose
+     * either header-oriented convention.
      */
     supportedSchemes?: ReadonlySet<OpenApiSecuritySchemeName>;
 };

package/dist/server/openapi.js

@@ -217,9 +217,7 @@ function buildDirectRouteResponses(route) {
   return responses;
 }
 function buildDirectRouteSecurity(route) {
-  if (route.access === "public")
-    return [];
-  return;
+  return route.access === "public" ? [] : void 0;
 }
 function emitDirectRoutes(paths, tagSet) {
   for (const route of DIRECT_HTTP_ROUTES) {

package/dist/server/openrpc-document-schema.d.ts

@@ -39,6 +39,45 @@ export declare const OpenRpcMethodSchema: z.ZodObject<{
             source: z.ZodLiteral<"live">;
         }, z.core.$strict>;
     }, z.core.$strict>>;
+    'x-weft-parameterizedAccess': z.ZodOptional<z.ZodObject<{
+        discriminator: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodString>;
+        variants: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"public">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"authenticated">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"scoped">;
+                scopes: z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        anyOf: "anyOf";
+                        allOf: "allOf";
+                    }>;
+                    scopes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"optionalAuth">;
+                authenticatedScopes: z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        anyOf: "anyOf";
+                        allOf: "allOf";
+                    }>;
+                    scopes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"scopedAlternatives">;
+                alternatives: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        anyOf: "anyOf";
+                        allOf: "allOf";
+                    }>;
+                    scopes: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const OpenRpcDocumentSchema: z.ZodObject<{
     openrpc: z.ZodLiteral<"1.3.2">;
@@ -90,6 +129,45 @@ export declare const OpenRpcDocumentSchema: z.ZodObject<{
                 source: z.ZodLiteral<"live">;
             }, z.core.$strict>;
         }, z.core.$strict>>;
+        'x-weft-parameterizedAccess': z.ZodOptional<z.ZodObject<{
+            discriminator: z.ZodString;
+            defaultValue: z.ZodOptional<z.ZodString>;
+            variants: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                access: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"public">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"authenticated">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"scoped">;
+                    scopes: z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            anyOf: "anyOf";
+                            allOf: "allOf";
+                        }>;
+                        scopes: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"optionalAuth">;
+                    authenticatedScopes: z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            anyOf: "anyOf";
+                            allOf: "allOf";
+                        }>;
+                        scopes: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"scopedAlternatives">;
+                    alternatives: z.ZodArray<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            anyOf: "anyOf";
+                            allOf: "allOf";
+                        }>;
+                        scopes: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     components: z.ZodOptional<z.ZodObject<{
         errors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/server/openrpc-document-schema.js

@@ -12,6 +12,31 @@ const OpenRpcMcpMethodMetadataSchema = z.strictObject({
     method: z.literal(MCP_TOOLS_LIST_METHOD),
     source: z.literal("live")
   })
+}), OpenRpcScopeRequirementSchema = z.strictObject({
+  kind: z.enum(["anyOf", "allOf"]),
+  scopes: z.array(z.string())
+}), OpenRpcAccessPolicySchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("public") }),
+  z.strictObject({ kind: z.literal("authenticated") }),
+  z.strictObject({
+    kind: z.literal("scoped"),
+    scopes: OpenRpcScopeRequirementSchema
+  }),
+  z.strictObject({
+    kind: z.literal("optionalAuth"),
+    authenticatedScopes: OpenRpcScopeRequirementSchema
+  }),
+  z.strictObject({
+    kind: z.literal("scopedAlternatives"),
+    alternatives: z.array(OpenRpcScopeRequirementSchema)
+  })
+]), OpenRpcParameterizedAccessSchema = z.strictObject({
+  discriminator: z.string(),
+  defaultValue: z.string().optional(),
+  variants: z.array(z.strictObject({
+    value: z.string(),
+    access: OpenRpcAccessPolicySchema
+  }))
 });
 export const OpenRpcMethodSchema = z.strictObject({
   name: z.string(),
@@ -23,7 +48,8 @@ export const OpenRpcMethodSchema = z.strictObject({
   result: ContentDescriptorSchema,
   errors: z.array(z.strictObject({ $ref: z.string() })).optional(),
   "x-weft-paramsSchema": z.record(z.string(), z.unknown()),
-  "x-weft-mcp": OpenRpcMcpMethodMetadataSchema.optional()
+  "x-weft-mcp": OpenRpcMcpMethodMetadataSchema.optional(),
+  "x-weft-parameterizedAccess": OpenRpcParameterizedAccessSchema.optional()
 });
 const OpenRpcMcpMetadataSchema = z.strictObject({
   discoveryPath: z.literal(MCP_DISCOVERY_PATH),

package/dist/server/openrpc-errors.d.ts

@@ -23,6 +23,9 @@ export declare const UnprocessableDataSchema: z.ZodObject<{
 export declare const TimeoutDataSchema: z.ZodObject<{
     operationName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const PayloadTooLargeDataSchema: z.ZodObject<{
+    maxBytes: z.ZodNumber;
+}, z.core.$strip>;
 export declare const NotImplementedDataSchema: z.ZodObject<{}, z.core.$strip>;
 export declare const UnsupportedTransportDataSchema: z.ZodObject<{
     transport: z.ZodEnum<{

package/dist/server/openrpc-errors.js

@@ -6,7 +6,7 @@ import {
 export const UnauthorizedDataSchema = z.object({ reason: z.string() }), ForbiddenDataSchema = z.object({ reason: z.string() }), NotFoundDataSchema = z.object({
   resource: z.string(),
   identifier: z.string().optional()
-}), ConflictDataSchema = z.object({ reason: z.string() }), UnprocessableDataSchema = z.object({ reason: z.string() }), TimeoutDataSchema = z.object({ operationName: z.string().optional() }), NotImplementedDataSchema = z.object({});
+}), ConflictDataSchema = z.object({ reason: z.string() }), UnprocessableDataSchema = z.object({ reason: z.string() }), TimeoutDataSchema = z.object({ operationName: z.string().optional() }), PayloadTooLargeDataSchema = z.object({ maxBytes: z.number() }), NotImplementedDataSchema = z.object({});
 const TransportKindSchema = z.enum([
   "http-rest",
   "jsonRpcHttp",
@@ -33,6 +33,7 @@ const FAULT_DATA_SCHEMAS = {
   Conflict: ConflictDataSchema,
   Unprocessable: UnprocessableDataSchema,
   Timeout: TimeoutDataSchema,
+  PayloadTooLarge: PayloadTooLargeDataSchema,
   NotImplemented: NotImplementedDataSchema,
   UnsupportedTransport: UnsupportedTransportDataSchema,
   SubscriptionOverflow: SubscriptionOverflowDataSchema,

package/dist/server/openrpc.js

@@ -117,9 +117,41 @@ function buildMethod(operation) {
     method.description = operation.description;
   if (operation.tags.length > 0)
     method.tags = [...operation.tags].toSorted(compareStrings).map((name) => ({ name }));
+  if (operation.parameterizedAccess !== void 0)
+    method["x-weft-parameterizedAccess"] = {
+      discriminator: operation.parameterizedAccess.discriminator,
+      ...operation.parameterizedAccess.defaultValue === void 0 ? {} : { defaultValue: operation.parameterizedAccess.defaultValue },
+      variants: operation.parameterizedAccess.variants.map((variant) => ({
+        value: variant.value,
+        access: accessPolicyExtension(variant.access)
+      }))
+    };
   method.errors = buildMethodErrorReferences(operation);
   return method;
 }
+function accessPolicyExtension(access) {
+  if (access.kind === "public")
+    return { kind: "public" };
+  if (access.kind === "authenticated")
+    return { kind: "authenticated" };
+  if (access.kind === "scoped")
+    return { kind: "scoped", scopes: scopeRequirementExtension(access.scopes) };
+  if (access.kind === "optionalAuth")
+    return {
+      kind: "optionalAuth",
+      authenticatedScopes: scopeRequirementExtension(access.authenticatedScopes)
+    };
+  return {
+    kind: "scopedAlternatives",
+    alternatives: access.alternatives.map(scopeRequirementExtension)
+  };
+}
+function scopeRequirementExtension(requirement) {
+  return {
+    kind: requirement.kind,
+    scopes: [...requirement.scopes].toSorted(compareStrings)
+  };
+}
 function buildDiscoverMethod() {
   return {
     name: "rpc.discover",

package/dist/server/operation-catalog/index.d.ts

@@ -17,6 +17,6 @@ export { executeOperation } from './pipeline.ts';
 export { UNIVERSAL_FAULT_DEFAULTS, raiseFault } from './raise-fault.ts';
 export { createOperationRegistry } from './registry.ts';
 export { SubscriptionElementValidationError, executeStream, executeSubscription, } from './stream-pipeline.ts';
-export { OPERATION_NAME_PATTERN, isValidOperationName, validateOperationName, type AuthorizationDecision, type DispatchContext, type DispatchResult, type ErasedOperation, type McpToolMetadata, type OperationContext, type OperationDefinition, type OperationInvocationResult, type OperationKind, type OperationRegistry, type PipelineTrace, type PipelineTraceMarker, type RegistrableOperation, type StreamOperationInvocation, type SubscriptionOperationInvocation, type TransportAvailability, type UnknownKeyDisposition, type UnknownKeyPolicy, } from './types.ts';
+export { OPERATION_NAME_PATTERN, isValidOperationName, validateOperationName, type AuthorizationDecision, type DispatchContext, type DispatchResult, type ErasedOperation, type McpToolMetadata, type OperationContext, type OperationDefinition, type OperationInvocationResult, type OperationKind, type OperationRegistry, type ParameterizedAccessHint, type PipelineTrace, type PipelineTraceMarker, type RegistrableOperation, type StreamOperationInvocation, type SubscriptionOperationInvocation, type TransportAvailability, type UnknownKeyDisposition, type UnknownKeyPolicy, } from './types.ts';
 export { catalogWorkflow } from './workflow-adapter.ts';
 export type { CatalogWorkflowOptions } from './workflow-adapter.ts';

package/dist/server/operation-catalog/pipeline-helpers.js

@@ -157,6 +157,7 @@ const FAULT_CODES = {
   Conflict: !0,
   Unprocessable: !0,
   Timeout: !0,
+  PayloadTooLarge: !0,
   NotImplemented: !0,
   UnsupportedTransport: !0,
   SubscriptionOverflow: !0,