@lostgradient/weft 0.2.0

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

@@ -0,0 +1,22 @@
+/**
+ * Transport-neutral operation catalog and the single dispatch pipeline.
+ *
+ * `executeOperation` is the only function transport adapters call to invoke an
+ * operation. REST, JSON-RPC HTTP, JSON-RPC WebSocket, and stdio all share one
+ * access check, one input validation step, one authorization hook, and one
+ * error classifier.
+ *
+ * @module server/operation-catalog
+ */
+export type { FaultCode } from '../operation-fault.ts';
+export { catalogActivities, catalogActivity } from './activity-adapter.ts';
+export type { CatalogActivityDefinition } from './activity-adapter.ts';
+export { DISPATCH_ALLOWLIST } from './dispatch-allowlist.ts';
+export { classifyEngineError } from './pipeline-helpers.ts';
+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 { catalogWorkflow } from './workflow-adapter.ts';
+export type { CatalogWorkflowOptions } from './workflow-adapter.ts';

package/dist/server/operation-catalog/index.js

@@ -0,0 +1,17 @@
+export { catalogActivities, catalogActivity } from "./activity-adapter.js";
+export { DISPATCH_ALLOWLIST } from "./dispatch-allowlist.js";
+export { classifyEngineError } from "./pipeline-helpers.js";
+export { executeOperation } from "./pipeline.js";
+export { UNIVERSAL_FAULT_DEFAULTS, raiseFault } from "./raise-fault.js";
+export { createOperationRegistry } from "./registry.js";
+export {
+  SubscriptionElementValidationError,
+  executeStream,
+  executeSubscription
+} from "./stream-pipeline.js";
+export {
+  OPERATION_NAME_PATTERN,
+  isValidOperationName,
+  validateOperationName
+} from "./types.js";
+export { catalogWorkflow } from "./workflow-adapter.js";

package/dist/server/operation-catalog/pipeline-helpers.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { WeftError } from '../../core/weft-error.ts';
+import type { FlattenedZodIssue, OperationFault, TransportKind } from '../operation-fault.ts';
+import type { TransportAvailability, UnknownKeyPolicy } from './types.ts';
+export declare const SUPPORTED_TRANSPORTS: ReadonlyArray<TransportKind>;
+export declare const UNSAFE_PROTOTYPE_KEYS: ReadonlySet<string>;
+export declare function transportToPolicyKey(transport: TransportKind): keyof UnknownKeyPolicy;
+export declare function transportToAvailabilityKey(transport: TransportKind): keyof TransportAvailability;
+/**
+ * Extract the top-level keys of an object schema. The registry validates at
+ * construction time that every `inputSchema` is a `z.ZodObject`.
+ */
+export declare function extractTopLevelObjectKeys(schema: z.ZodType): ReadonlySet<string>;
+/**
+ * Build a prototype-safe shallow projection of `rawInput` containing only
+ * keys present in `knownKeys`.
+ */
+export declare function sanitizeTopLevel(rawInput: Record<string, unknown>, knownKeys: ReadonlySet<string>): Record<string, unknown>;
+export declare function flattenZodIssues(issues: ReadonlyArray<{
+    path: ReadonlyArray<PropertyKey>;
+    message: string;
+    code: string;
+}>): ReadonlyArray<FlattenedZodIssue>;
+/**
+ * Translate a thrown value from `invoke` into a transport-neutral
+ * OperationFault.
+ *
+ * Typed engine errors (`WorkflowAlreadyExistsError`,
+ * `WorkflowNotFoundError`, `WorkflowNotRegisteredError`) are matched first
+ * so the fault classification is robust against future error-message
+ * rewording. Plain `Error` instances fall through to the message-pattern
+ * heuristics, which exist as a last-resort generic catch-all.
+ *
+ * **Producible-faults enforcement.** When `operation` is supplied (the
+ * dispatch pipeline always supplies it), any direct `OperationFault`
+ * throw whose `code` is NOT in the operation's `producibleFaults` ∪
+ * universal-defaults set is logged as a declaration violation:
+ *
+ *   - Test/dev (`NODE_ENV !== 'production'` OR `WEFT_STRICT_FAULTS=1`):
+ *     console.error so the developer notices and either declares the
+ *     fault or migrates the throw to `raiseFault`.
+ *   - Production: silent log. The original fault is preserved on the
+ *     wire to keep clients' actionable semantics intact.
+ *
+ * This makes the producibleFaults declarations runtime-load-bearing for
+ * direct throws too — not just calls routed through the `raiseFault`
+ * helper.
+ */
+export declare function classifyEngineError(error: unknown, operation?: {
+    name: string;
+    producibleFaults?: ReadonlyArray<string>;
+}): OperationFault;
+/**
+ * Sentinel thrown by `enforceProducibleFaults` in strict mode when an
+ * operation raises a fault code that isn't in its `producibleFaults`
+ * declaration. The dispatcher catches this in `executeOperation` and
+ * surfaces it as a generic `EngineFailure` so test failures point at the
+ * declaration mismatch rather than silently passing through.
+ */
+declare class UndeclaredFaultError extends WeftError<'UndeclaredFaultError'> {
+    readonly operationName: string;
+    readonly faultCode: string;
+    constructor(operationName: string, faultCode: string);
+}
+export declare function isUndeclaredFaultError(value: unknown): value is UndeclaredFaultError;
+export {};

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

@@ -0,0 +1,179 @@
+import { z } from "zod";
+import { WeftError } from "../../core/weft-error.js";
+import {
+  WorkflowAlreadyExistsError,
+  WorkflowNotFoundError,
+  WorkflowNotRegisteredError
+} from "../../core/engine/errors.js";
+export const SUPPORTED_TRANSPORTS = [
+  "http-rest",
+  "jsonRpcHttp",
+  "jsonRpcWebSocket",
+  "jsonRpcStdio"
+], UNSAFE_PROTOTYPE_KEYS = new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+export function transportToPolicyKey(transport) {
+  return transport === "http-rest" ? "http" : "jsonRpc";
+}
+export function transportToAvailabilityKey(transport) {
+  switch (transport) {
+    case "http-rest":
+      return "http";
+    case "jsonRpcHttp":
+      return "jsonRpcHttp";
+    case "jsonRpcWebSocket":
+      return "jsonRpcWebSocket";
+    case "jsonRpcStdio":
+      return "jsonRpcStdio";
+  }
+}
+export function extractTopLevelObjectKeys(schema) {
+  if (!(schema instanceof z.ZodObject))
+    throw Error("extractTopLevelObjectKeys called with a non-object schema \u2014 the operation registry should have rejected this at construction");
+  return new Set(Object.keys(schema.shape).filter((key) => !UNSAFE_PROTOTYPE_KEYS.has(key)));
+}
+export function sanitizeTopLevel(rawInput, knownKeys) {
+  const out = Object.create(null);
+  for (const key of Object.keys(rawInput)) {
+    if (UNSAFE_PROTOTYPE_KEYS.has(key))
+      continue;
+    if (knownKeys.has(key))
+      out[key] = rawInput[key];
+  }
+  return out;
+}
+export function flattenZodIssues(issues) {
+  return issues.map((issue) => ({
+    path: issue.path.map((segment) => typeof segment === "string" || typeof segment === "number" ? segment : String(segment)),
+    message: issue.message,
+    code: issue.code
+  }));
+}
+const UNIVERSAL_PRODUCIBLE_FAULTS = new Set([
+  "Unauthorized",
+  "Forbidden",
+  "InvalidParams",
+  "EngineFailure"
+]);
+export function classifyEngineError(error, operation) {
+  if (isOperationFault(error)) {
+    try {
+      enforceProducibleFaults(operation, error.code);
+    } catch (enforcementError) {
+      if (isUndeclaredFaultError(enforcementError))
+        return {
+          code: "EngineFailure",
+          message: enforcementError.message,
+          data: {}
+        };
+      throw enforcementError;
+    }
+    return error;
+  }
+  if (error instanceof WorkflowAlreadyExistsError)
+    return {
+      code: "Conflict",
+      message: "conflict",
+      data: { reason: "resource already exists" }
+    };
+  if (error instanceof WorkflowNotRegisteredError)
+    return {
+      code: "InvalidParams",
+      message: error.message,
+      data: { issues: [] }
+    };
+  if (error instanceof WorkflowNotFoundError)
+    return {
+      code: "NotFound",
+      message: "not found",
+      data: { resource: "workflow" }
+    };
+  if (error instanceof Error)
+    return classifyErrorMessage(error);
+  return { code: "EngineFailure", message: "internal error", data: {} };
+}
+
+class UndeclaredFaultError extends WeftError {
+  operationName;
+  faultCode;
+  constructor(operationName, faultCode) {
+    super("UndeclaredFaultError", `[weft] Operation "${operationName}" raised undeclared fault "${faultCode}". Add it to the operation's \`producibleFaults\` array or migrate the throw to \`raiseFault(operation, fault)\`.`);
+    this.operationName = operationName;
+    this.faultCode = faultCode;
+  }
+}
+export function isUndeclaredFaultError(value) {
+  return value instanceof UndeclaredFaultError;
+}
+function enforceProducibleFaults(operation, code) {
+  if (operation === void 0)
+    return;
+  if (UNIVERSAL_PRODUCIBLE_FAULTS.has(code))
+    return;
+  const declared = operation.producibleFaults;
+  if (declared !== void 0 && declared.includes(code))
+    return;
+  if (Bun.env.WEFT_STRICT_FAULTS === "1" || Bun.env.NODE_ENV !== "production")
+    throw new UndeclaredFaultError(operation.name, code);
+  console.warn(`[weft] Operation "${operation.name}" raised undeclared fault "${code}". Add it to the operation's \`producibleFaults\` array or migrate the throw to \`raiseFault(operation, fault)\`.`);
+}
+function classifyErrorMessage(error) {
+  let rawMessage;
+  try {
+    rawMessage = error.message;
+  } catch {
+    return { code: "EngineFailure", message: "internal error", data: {} };
+  }
+  if (typeof rawMessage !== "string")
+    return { code: "EngineFailure", message: "internal error", data: {} };
+  const message = rawMessage.toLowerCase();
+  if (message.includes("not found"))
+    return {
+      code: "NotFound",
+      message: "not found",
+      data: { resource: "unknown" }
+    };
+  if (message.includes("already exists"))
+    return {
+      code: "Conflict",
+      message: "conflict",
+      data: { reason: "resource already exists" }
+    };
+  if (message.includes("timeout") || message.includes("timed out"))
+    return {
+      code: "Timeout",
+      message: "operation timed out",
+      data: {}
+    };
+  return { code: "EngineFailure", message: "internal error", data: {} };
+}
+const FAULT_CODES = {
+  Unauthorized: !0,
+  Forbidden: !0,
+  NotFound: !0,
+  Conflict: !0,
+  Unprocessable: !0,
+  Timeout: !0,
+  NotImplemented: !0,
+  UnsupportedTransport: !0,
+  SubscriptionOverflow: !0,
+  InvalidParams: !0,
+  MethodNotFound: !0,
+  EngineFailure: !0
+};
+function isOperationFault(value) {
+  if (typeof value !== "object" || value === null)
+    return !1;
+  let code, message, data;
+  try {
+    code = value.code;
+    message = value.message;
+    data = value.data;
+  } catch {
+    return !1;
+  }
+  return typeof code === "string" && typeof message === "string" && typeof data === "object" && data !== null && !Array.isArray(data) && Object.hasOwn(FAULT_CODES, code);
+}

package/dist/server/operation-catalog/pipeline-stages.d.ts

@@ -0,0 +1,23 @@
+import type { OperationFault } from '../operation-fault.ts';
+import { type DispatchContext, type DispatchResult, type ErasedOperation, type PipelineTrace, type PipelineTraceMarker, type UnknownKeyPolicy } from './types.ts';
+export type PipelineParseOutcome = {
+    kind: 'ok';
+    input: unknown;
+} | {
+    kind: 'failure';
+    fault: OperationFault;
+};
+/** Verify that an operation is available on the current transport. */
+export declare function checkTransport(operation: ErasedOperation, context: DispatchContext): DispatchResult<never> | null;
+/** Verify the operation's static access policy against the caller principal. */
+export declare function checkAccess(operation: ErasedOperation, context: DispatchContext): DispatchResult<never> | null;
+/** Run the optional parameter-aware authorization hook. */
+export declare function checkAuthorization(operation: ErasedOperation, input: unknown, context: DispatchContext): Promise<DispatchResult<never> | null>;
+/**
+ * Input parsing stage: apply the catalog's top-level unknown-key policy,
+ * run the schema's `safeParse`, and re-attach passthrough extras onto a
+ * prototype-safe null-prototype object.
+ */
+export declare function parseAndApplyUnknownKeyPolicy(operation: ErasedOperation, rawInput: unknown, policyKey: keyof UnknownKeyPolicy, pipelineTrace?: PipelineTrace): PipelineParseOutcome;
+/** Emit one pipeline trace marker when a trace observer is installed. */
+export declare function tracePipeline(pipelineTrace: PipelineTrace | undefined, marker: PipelineTraceMarker): void;

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

@@ -0,0 +1,189 @@
+import { z } from "zod";
+import { evaluateAccess } from "../authorization.js";
+import { isPlainObject } from "../json-schema-utilities.js";
+import {
+  SUPPORTED_TRANSPORTS,
+  UNSAFE_PROTOTYPE_KEYS,
+  extractTopLevelObjectKeys,
+  flattenZodIssues,
+  sanitizeTopLevel,
+  transportToAvailabilityKey
+} from "./pipeline-helpers.js";
+export function checkTransport(operation, context) {
+  if (operation.transports[transportToAvailabilityKey(context.transport)])
+    return null;
+  const supported = SUPPORTED_TRANSPORTS.filter((transport) => operation.transports[transportToAvailabilityKey(transport)]);
+  return failure({
+    code: "UnsupportedTransport",
+    message: `operation "${operation.name}" does not support transport "${context.transport}"`,
+    data: { transport: context.transport, supported }
+  });
+}
+export function checkAccess(operation, context) {
+  const access = evaluateAccess(operation.access, context.principal);
+  if (access.allowed)
+    return null;
+  if (access.classification === "unauthorized")
+    return failure({
+      code: "Unauthorized",
+      message: access.reason,
+      data: { reason: access.reason }
+    });
+  return failure({
+    code: "Forbidden",
+    message: access.reason,
+    data: { reason: access.reason }
+  });
+}
+export async function checkAuthorization(operation, input, context) {
+  if (operation.authorize === void 0)
+    return null;
+  let decision;
+  try {
+    decision = await operation.authorize({
+      input,
+      principal: context.principal,
+      engine: context.engine,
+      transport: context.transport
+    });
+  } catch {
+    return failure({ code: "EngineFailure", message: "internal error", data: {} });
+  }
+  if (!isAuthorizationDecision(decision))
+    return failure({ code: "EngineFailure", message: "internal error", data: {} });
+  if (!decision.allowed)
+    return failure({
+      code: "Forbidden",
+      message: decision.reason,
+      data: { reason: decision.reason }
+    });
+  return null;
+}
+export function parseAndApplyUnknownKeyPolicy(operation, rawInput, policyKey, pipelineTrace) {
+  const policy = operation.unknownKeyPolicy[policyKey], knownKeys = readKnownTopLevelKeys(operation);
+  if (knownKeys.kind === "failure")
+    return knownKeys;
+  const preParse = buildPreParseInput(rawInput, policy, knownKeys.keys);
+  if (preParse.kind === "failure")
+    return preParse;
+  const parseResult = safeParseInput(operation.inputSchema, preParse.input);
+  if (parseResult.kind === "failure")
+    return parseResult;
+  tracePipeline(pipelineTrace, "parsed");
+  const parsed = parseResult.input;
+  if (policy !== "passthrough") {
+    tracePipeline(pipelineTrace, "unknown-key-policy-applied");
+    return { kind: "ok", input: parsed };
+  }
+  const passthroughOutput = buildPassthroughOutput(parsed, preParse.passthroughExtras);
+  tracePipeline(pipelineTrace, "unknown-key-policy-applied");
+  return { kind: "ok", input: passthroughOutput };
+}
+export function tracePipeline(pipelineTrace, marker) {
+  if (pipelineTrace === void 0)
+    return;
+  pipelineTrace(marker);
+}
+function readKnownTopLevelKeys(operation) {
+  try {
+    return { kind: "ok", keys: extractTopLevelObjectKeys(operation.inputSchema) };
+  } catch {
+    return {
+      kind: "failure",
+      fault: { code: "EngineFailure", message: "internal error", data: {} }
+    };
+  }
+}
+function buildPreParseInput(rawInput, policy, knownKeys) {
+  if (!isPlainObject(rawInput))
+    return { kind: "ok", input: rawInput, passthroughExtras: [] };
+  const rawRecord = rawInput, unknownTopLevel = Object.keys(rawRecord).filter((key) => !knownKeys.has(key));
+  if (unknownTopLevel.length === 0)
+    return { kind: "ok", input: rawInput, passthroughExtras: [] };
+  if (policy === "reject")
+    return {
+      kind: "failure",
+      fault: {
+        code: "InvalidParams",
+        message: "unrecognized top-level keys",
+        data: {
+          issues: [
+            {
+              path: [],
+              message: `unrecognized top-level keys: ${unknownTopLevel.join(", ")}`,
+              code: "unrecognized_keys"
+            }
+          ]
+        }
+      }
+    };
+  return {
+    kind: "ok",
+    input: sanitizeTopLevel(rawRecord, knownKeys),
+    passthroughExtras: collectPassthroughExtras(rawRecord, unknownTopLevel, policy)
+  };
+}
+function collectPassthroughExtras(rawInput, unknownTopLevel, policy) {
+  if (policy !== "passthrough")
+    return [];
+  return unknownTopLevel.filter((key) => !UNSAFE_PROTOTYPE_KEYS.has(key)).map((key) => [key, rawInput[key]]);
+}
+function buildPassthroughOutput(parsed, passthroughExtras) {
+  const merged = Object.create(null);
+  for (const [key, value] of Object.entries(parsed)) {
+    if (UNSAFE_PROTOTYPE_KEYS.has(key))
+      continue;
+    merged[key] = value;
+  }
+  for (const [key, value] of passthroughExtras) {
+    if (key in merged)
+      continue;
+    merged[key] = value;
+  }
+  return merged;
+}
+function safeParseInput(inputSchema, input) {
+  let parseResult;
+  try {
+    parseResult = inputSchema.safeParse(input);
+  } catch {
+    return {
+      kind: "failure",
+      fault: { code: "EngineFailure", message: "internal error", data: {} }
+    };
+  }
+  if (!parseResult.success)
+    return {
+      kind: "failure",
+      fault: {
+        code: "InvalidParams",
+        message: "invalid params",
+        data: { issues: flattenZodIssues(parseResult.error.issues) }
+      }
+    };
+  return { kind: "ok", input: parseResult.data };
+}
+function isAuthorizationDecision(value) {
+  if (typeof value !== "object" || value === null)
+    return !1;
+  let allowed;
+  try {
+    allowed = value.allowed;
+  } catch {
+    return !1;
+  }
+  if (allowed === !0)
+    return !0;
+  if (allowed !== !1)
+    return !1;
+  let reason;
+  try {
+    reason = value.reason;
+  } catch {
+    return !1;
+  }
+  return typeof reason === "string";
+}
+function failure(fault) {
+  return { ok: !1, fault };
+}

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

@@ -0,0 +1,7 @@
+import { type DispatchContext, type DispatchResult } from './types.ts';
+/**
+ * Single request/response dispatch pipeline. Every request/response transport
+ * call goes through the same transport, access, input validation,
+ * authorization, invocation, and output-validation stages.
+ */
+export declare function executeOperation<Output>(operationName: string, rawInput: unknown, context: DispatchContext): Promise<DispatchResult<Output>>;

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

@@ -0,0 +1,32 @@
+import {
+  dispatchFailure,
+  lookupOperation,
+  prepareAuthorizedInput,
+  validateOutputAgainstSchema
+} from "./dispatch-preparation.js";
+import { classifyEngineError } from "./pipeline-helpers.js";
+import { tracePipeline } from "./pipeline-stages.js";
+export async function executeOperation(operationName, rawInput, context) {
+  const lookup = lookupOperation(operationName, context);
+  if (!lookup.ok)
+    return lookup;
+  const operation = lookup.value, prepared = await prepareAuthorizedInput(operation, rawInput, context);
+  if (!prepared.ok)
+    return prepared;
+  let output;
+  try {
+    output = await operation.invoke({
+      input: prepared.value.input,
+      principal: context.principal,
+      engine: context.engine,
+      transport: context.transport
+    });
+  } catch (error) {
+    return dispatchFailure(classifyEngineError(error, operation));
+  }
+  tracePipeline(context.pipelineTrace, "invoked");
+  const outputResult = validateOutputAgainstSchema(operation.outputSchema, output);
+  if (outputResult.ok)
+    tracePipeline(context.pipelineTrace, "output-validated");
+  return outputResult;
+}

package/dist/server/operation-catalog/raise-fault.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Helpers for enforcing an operation's declared producible fault set.
+ *
+ * @module server/operation-catalog/raise-fault
+ */
+import type { FaultCode, OperationFault } from '../operation-fault.ts';
+import type { ErasedOperation } from './types.ts';
+/**
+ * Fault codes that every operation can raise through the shared pipeline
+ * without listing them in `producibleFaults`.
+ */
+export declare const UNIVERSAL_FAULT_DEFAULTS: ReadonlySet<FaultCode>;
+/**
+ * Throw an `OperationFault` after checking it against an operation's declared
+ * `producibleFaults`.
+ *
+ * Development and test environments fail hard for undeclared faults. Production
+ * preserves the original fault semantics and logs the declaration violation so
+ * clients still receive actionable error codes.
+ *
+ * Universal defaults (always allowed, never need declaration):
+ * Unauthorized | Forbidden | InvalidParams | EngineFailure
+ *
+ * In test/development (NODE_ENV !== 'production' OR WEFT_STRICT_FAULTS=1),
+ * raising an undeclared fault throws a hard error so the developer must
+ * declare or remove the fault. In production the original fault is preserved
+ * and forwarded; the violation is logged to console.error.
+ */
+export declare function raiseFault(operation: ErasedOperation | {
+    readonly name: string;
+    readonly producibleFaults?: readonly FaultCode[];
+}, fault: OperationFault): never;

package/dist/server/operation-catalog/raise-fault.js

@@ -0,0 +1,18 @@
+export const UNIVERSAL_FAULT_DEFAULTS = new Set([
+  "Unauthorized",
+  "Forbidden",
+  "InvalidParams",
+  "EngineFailure"
+]);
+export function raiseFault(operation, fault) {
+  const declared = new Set([
+    ...UNIVERSAL_FAULT_DEFAULTS,
+    ...operation.producibleFaults ?? []
+  ]), isStrict = Bun.env.WEFT_STRICT_FAULTS === "1" || Bun.env.NODE_ENV !== "production";
+  if (!declared.has(fault.code)) {
+    if (isStrict)
+      throw Error(`Operation "${operation.name}" raised undeclared fault "${fault.code}". Add "${fault.code}" to producibleFaults or remove the fault.`);
+    console.error(`[weft] Operation "${operation.name}" raised undeclared fault "${fault.code}". This will become a hard error in a future version.`);
+  }
+  throw fault;
+}

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

@@ -0,0 +1,6 @@
+import { type OperationRegistry, type RegistrableOperation } from './types.ts';
+/**
+ * Build an immutable registry. Throws on duplicate names, invalid names,
+ * non-object input schemas, and unsafe top-level schema keys.
+ */
+export declare function createOperationRegistry(operations: ReadonlyArray<RegistrableOperation>): OperationRegistry;