feat(operations): add audited runtime catalog

packages/operation-registry/src/runtime-registry.ts

@@ -1,4 +1,8 @@
 import { operationAcceptanceOverrides58e2204 } from './acceptance-58e2204.ts';
+import {
+  operationMetadata58e2204,
+  type OperationCatalogMetadata,
+} from './catalog-metadata-58e2204.ts';
 import { upstream58e2204Operations } from './upstream-58e2204.ts';
 
 export type RuntimeRegistryErrorCode = 'UNKNOWN_OPERATION' | 'DEDICATED_FLOW_REQUIRED';
@@ -13,18 +17,28 @@ export class RuntimeRegistryError extends Error {
   }
 }
 
-type UpstreamOperation = (typeof upstream58e2204Operations)[number];
-type AcceptanceOverride = Record<string, unknown> & { uiStrategy?: unknown };
+export interface RuntimeOperationDescriptor {
+  readonly operationId: string;
+  readonly method: string;
+  readonly pathTemplate: string;
+  readonly handler: string;
+  readonly capability: string;
+  readonly riskLevel: 'R0' | 'R1' | 'R2' | 'R3';
+  readonly batchable: boolean;
+  readonly executionPolicy: string;
+  readonly upstreamDomain: string;
+  readonly module: string;
+  readonly uiStrategy: string;
+  readonly title: string;
+  readonly parameterSchemaId: string;
+  readonly [field: string]: unknown;
+}
 
-export type RuntimeOperationDescriptor = Readonly<
-  UpstreamOperation & {
-    module: UpstreamOperation['upstreamDomain'];
-    uiStrategy: string;
-  }
->;
+type AcceptanceOverride = Readonly<Record<string, unknown>> & { readonly uiStrategy?: unknown };
 
 const OPERATION_ID_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
 const EXPECTED_OPERATION_COUNT = 117;
+const PARAMETER_SCHEMA_ID_PATTERN = /^[A-Za-z0-9]+(?:[.-][A-Za-z0-9]+)+$/;
 
 function deepFreeze<T>(value: T): T {
   if (value === null || typeof value !== 'object' || Object.isFrozen(value)) return value;
@@ -43,13 +57,16 @@ export class OperationRegistry {
   readonly #operations: readonly RuntimeOperationDescriptor[];
 
   constructor(
-    operations: readonly UpstreamOperation[],
+    operations: readonly Readonly<Record<string, unknown>>[],
     acceptanceOverrides: Readonly<Record<string, AcceptanceOverride>>,
+    metadata: Readonly<Record<string, OperationCatalogMetadata>>,
   ) {
-    const sourceById = new Map<string, UpstreamOperation>();
+    const sourceById = new Map<string, Readonly<Record<string, unknown>>>();
     for (const operation of operations) {
       const id = operation.operationId;
-      if (!OPERATION_ID_PATTERN.test(id)) throw new Error(`invalid operationId in registry: ${id}`);
+      if (typeof id !== 'string' || !OPERATION_ID_PATTERN.test(id)) {
+        throw new Error(`invalid operationId in registry: ${String(id)}`);
+      }
       if (sourceById.has(id)) throw new Error(`duplicate operationId: ${id}`);
       sourceById.set(id, operation);
     }
@@ -58,6 +75,9 @@ export class OperationRegistry {
         `runtime registry must contain exactly ${EXPECTED_OPERATION_COUNT} operations`,
       );
     }
+    for (const id of Object.keys(metadata)) {
+      if (!sourceById.has(id)) throw new Error(`extra operation metadata: ${id}`);
+    }
 
     const descriptors: RuntimeOperationDescriptor[] = [];
     for (const id of [...sourceById.keys()].sort()) {
@@ -69,10 +89,23 @@ export class OperationRegistry {
         throw new Error(`missing acceptance override: ${id}`);
       }
       const operation = sourceById.get(id)!;
+      if (!Object.hasOwn(metadata, id)) throw new Error(`missing operation metadata: ${id}`);
+      const catalog = metadata[id]!;
+      if (typeof catalog.title !== 'string' || catalog.title.trim().length === 0) {
+        throw new Error(`blank operation title: ${id}`);
+      }
+      if (!PARAMETER_SCHEMA_ID_PATTERN.test(catalog.parameterSchemaId)) {
+        throw new Error(`invalid parameter schema id: ${id}`);
+      }
+      if (typeof operation.upstreamDomain !== 'string') {
+        throw new Error(`invalid upstream domain: ${id}`);
+      }
       const descriptor = structuredClone({
         ...operation,
         module: operation.upstreamDomain,
         uiStrategy: acceptance.uiStrategy,
+        title: catalog.title,
+        parameterSchemaId: catalog.parameterSchemaId,
       }) as RuntimeOperationDescriptor;
       descriptors.push(deepFreeze(descriptor));
     }
@@ -98,20 +131,20 @@ export class OperationRegistry {
   }
 
   requireExecutableOperation(operationId: string): RuntimeOperationDescriptor {
-    const operation = this.requireOperation(operationId);
-    if (operation.executionPolicy === 'dedicatedFlow') {
+    const descriptor = this.requireOperation(operationId);
+    if (descriptor.executionPolicy !== 'registeredOperation') {
       throw new RuntimeRegistryError(
         'DEDICATED_FLOW_REQUIRED',
-        `Operation requires a dedicated flow: ${operationId}`,
+        `Operation is not executable through the registered-operation boundary: ${operationId}`,
       );
     }
-    return operation;
+    return descriptor;
   }
 }
-
 export const operationRegistry = new OperationRegistry(
   upstream58e2204Operations,
   operationAcceptanceOverrides58e2204,
+  operationMetadata58e2204,
 );
 
 export const listOperations = (): readonly RuntimeOperationDescriptor[] =>