@contractspec/lib.contracts 0.0.0-canary-20260113162409

package/dist/server/graphql-pothos.js

@@ -0,0 +1,134 @@
+import { defaultGqlField } from "../jsonschema.js";
+import { createInputTypeBuilder } from "./contracts-adapter-input.js";
+import { hydrateResourceIfNeeded, parseReturns } from "./contracts-adapter-hydration.js";
+import { isSchemaModel } from "@contractspec/lib.schema";
+import "@pothos/plugin-prisma";
+import "@pothos/plugin-complexity";
+import "@pothos/plugin-relay";
+import "@pothos/plugin-dataloader";
+import "@pothos/plugin-tracing";
+
+//#region src/server/graphql-pothos.ts
+/**
+* Registers all ContractSpecs from a OperationSpecRegistry onto a Pothos SchemaBuilder.
+*
+* This adapter:
+* 1. Discovers output types from specs and registers them as Pothos object types.
+* 2. Maps `ContractSpec` (OperationSpec) inputs to Pothos input types.
+* 3. Mounts `query` specs as `Query` fields and `command` specs as `Mutation` fields.
+* 4. Wraps the resolver to:
+*    - Enforce auth policies (basic check).
+*    - Build a `HandlerCtx`.
+*    - Execute via `OperationSpecRegistry`.
+*    - Hydrate resource references if applicable.
+*
+* @param builder - The Pothos SchemaBuilder instance.
+* @param reg - The OperationSpecRegistry containing operations.
+* @param resources - (Optional) ResourceRegistry for hydrating resource references.
+*/
+function registerContractsOnBuilder(builder, reg, resources) {
+	const { buildInputFieldArgs } = createInputTypeBuilder(builder);
+	const outputTypeCache = /* @__PURE__ */ new Map();
+	for (const spec of reg.list()) {
+		const out = spec.io.output;
+		if (out && "getZod" in out && typeof out.getZod === "function") {
+			const model = out;
+			const typeName = isSchemaModel(model) ? model.config?.name : "UnknownOutput";
+			if (typeName && !outputTypeCache.has(typeName)) outputTypeCache.set(typeName, model);
+		}
+	}
+	for (const [typeName, model] of outputTypeCache.entries()) {
+		if (!isSchemaModel(model)) continue;
+		builder.objectType(typeName, { fields: (t) => {
+			const entries = Object.entries(model.config.fields);
+			const acc = {};
+			for (const [key, field] of entries) {
+				const fieldType = field.type;
+				let gqlType = "JSON";
+				if (fieldType && typeof fieldType.getPothos === "function") {
+					gqlType = fieldType.getPothos().name || "JSON";
+					if (gqlType === "String_unsecure") gqlType = "String";
+					if (gqlType === "Int_unsecure") gqlType = "Int";
+					if (gqlType === "Float_unsecure") gqlType = "Float";
+					if (gqlType === "Boolean_unsecure") gqlType = "Boolean";
+					if (gqlType === "ID_unsecure") gqlType = "ID";
+				}
+				const typeRef = field.isArray ? [gqlType] : gqlType;
+				acc[key] = t.field({
+					type: typeRef,
+					nullable: field.isOptional,
+					resolve: (parent) => parent[key]
+				});
+			}
+			return acc;
+		} });
+	}
+	function resolveGraphQLTypeName(contractSpec) {
+		const returnsName = contractSpec.transport?.gql?.returns;
+		if (returnsName) return returnsName;
+		const out = contractSpec.io.output ?? {};
+		if (out && "kind" in out && out.kind === "resource_ref" && "graphQLType" in out && out.graphQLType) return String(out.graphQLType);
+		if (out && "getZod" in out && typeof out.getZod === "function") {
+			const model = out;
+			if (isSchemaModel(model)) {
+				const typeName = model.config?.name;
+				if (typeName && outputTypeCache.has(typeName)) return typeName;
+			}
+		}
+		return "JSON";
+	}
+	for (const spec of reg.list()) {
+		const fieldName = spec.transport?.gql?.field ?? defaultGqlField(spec.meta.key, spec.meta.version);
+		const byIdField = spec.transport?.gql?.byIdField ?? "id";
+		const returnsResource = spec.transport?.gql?.resource;
+		const isQuery = spec.meta.kind === "query";
+		const graphQLTypeName = resolveGraphQLTypeName(spec);
+		const returnsDecl = spec.transport?.gql?.returns;
+		const parsed = parseReturns(returnsDecl ?? graphQLTypeName);
+		const resolveFieldFn = async (_root, args, ctx) => {
+			if (spec.policy.auth !== "anonymous" && !ctx.user) throw new Error("Unauthorized");
+			const handlerCtx = {
+				traceId: ctx.logger?.getTraceId?.() ?? void 0,
+				userId: ctx.user?.id ?? null,
+				organizationId: ctx.session?.activeOrganizationId ?? null,
+				actor: ctx.user ? "user" : "anonymous",
+				channel: "web",
+				eventPublisher: ctx.eventPublisher
+			};
+			const parsedInput = spec.io.input?.getZod().parse(args.input ?? {});
+			const result = await reg.execute(spec.meta.key, spec.meta.version, parsedInput, handlerCtx);
+			const out = spec.io.output;
+			if (resources && (returnsResource || out?.kind === "resource_ref")) {
+				const varName = byIdField ?? out?.varName ?? "id";
+				const hydrated = await hydrateResourceIfNeeded(resources, result, {
+					template: returnsResource ?? out?.uriTemplate,
+					varName,
+					returns: parsed
+				});
+				if (hydrated !== result) return hydrated;
+			}
+			if (graphQLTypeName) {
+				if (parsed.inner === "Boolean" && !parsed.isList) return Boolean(result?.ok ?? result);
+				return result;
+			}
+			return spec.io.output.getZod().parse(result);
+		};
+		const fieldSettingsFn = (t) => {
+			const inputType = buildInputFieldArgs(spec.io.input);
+			return t.field({
+				type: parsed.isList ? [parsed.inner] : parsed.inner,
+				complexity: () => 10,
+				resolve: resolveFieldFn,
+				args: inputType ? { input: t.arg({
+					type: inputType,
+					required: true
+				}) } : void 0
+			});
+		};
+		if (isQuery) builder.queryField(fieldName, fieldSettingsFn);
+		else builder.mutationField(fieldName, fieldSettingsFn);
+	}
+}
+
+//#endregion
+export { registerContractsOnBuilder };

package/dist/server/index.d.ts

@@ -0,0 +1,9 @@
+import { registerContractsOnBuilder } from "./graphql-pothos.js";
+import { createMcpServer } from "./mcp/createMcpServer.js";
+import "./provider-mcp.js";
+import { RestOptions, createFetchHandler } from "./rest-generic.js";
+import { elysiaPlugin } from "./rest-elysia.js";
+import { expressRouter } from "./rest-express.js";
+import { makeNextAppHandler } from "./rest-next-app.js";
+import { makeNextPagesHandler } from "./rest-next-pages.js";
+export { RestOptions, createFetchHandler, createMcpServer, elysiaPlugin, expressRouter, makeNextAppHandler, makeNextPagesHandler, registerContractsOnBuilder };

package/dist/server/index.js

@@ -0,0 +1,10 @@
+import { registerContractsOnBuilder } from "./graphql-pothos.js";
+import { createMcpServer } from "./mcp/createMcpServer.js";
+import "./provider-mcp.js";
+import { createFetchHandler } from "./rest-generic.js";
+import { elysiaPlugin } from "./rest-elysia.js";
+import { expressRouter } from "./rest-express.js";
+import { makeNextAppHandler } from "./rest-next-app.js";
+import { makeNextPagesHandler } from "./rest-next-pages.js";
+
+export { createFetchHandler, createMcpServer, elysiaPlugin, expressRouter, makeNextAppHandler, makeNextPagesHandler, registerContractsOnBuilder };

package/dist/server/mcp/createMcpServer.d.ts

@@ -0,0 +1,15 @@
+import { ResourceRegistry } from "../../resources.js";
+import { OperationSpecRegistry } from "../../operations/registry.js";
+import { PromptRegistry } from "../../promptRegistry.js";
+import { McpCtxFactories } from "./mcpTypes.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/server/mcp/createMcpServer.d.ts
+
+/**
+ * Creates a unified Model Context Protocol (MCP) server exposing operations, resources, prompts,
+ * and (optionally) presentations.\n+ *
+ * ContractSpec exposes:\n+ * - Tools: `command` operations from `OperationSpecRegistry`.\n+ * - Resources: templates from `ResourceRegistry`.\n+ * - Prompts: templates from `PromptRegistry`.\n+ * - Presentations: V1 registry and/or V2 descriptors as read-only resources.\n+ */
+declare function createMcpServer(server: McpServer, ops: OperationSpecRegistry, resources: ResourceRegistry, prompts: PromptRegistry, ctxFactories: McpCtxFactories): McpServer;
+//#endregion
+export { createMcpServer };

package/dist/server/mcp/createMcpServer.js

@@ -0,0 +1,27 @@
+import { registerMcpTools } from "./registerTools.js";
+import { registerMcpResources } from "./registerResources.js";
+import { registerMcpPrompts } from "./registerPrompts.js";
+import { registerMcpPresentations } from "./registerPresentations.js";
+
+//#region src/server/mcp/createMcpServer.ts
+/**
+* Creates a unified Model Context Protocol (MCP) server exposing operations, resources, prompts,
+* and (optionally) presentations.\n+ *
+* ContractSpec exposes:\n+ * - Tools: `command` operations from `OperationSpecRegistry`.\n+ * - Resources: templates from `ResourceRegistry`.\n+ * - Prompts: templates from `PromptRegistry`.\n+ * - Presentations: V1 registry and/or V2 descriptors as read-only resources.\n+ */
+function createMcpServer(server, ops, resources, prompts, ctxFactories) {
+	ctxFactories.logger.debug("Creating MCP server");
+	registerMcpTools(server, ops, { toolCtx: ctxFactories.toolCtx });
+	registerMcpResources(server, resources, {
+		logger: ctxFactories.logger,
+		resourceCtx: ctxFactories.resourceCtx
+	});
+	registerMcpPresentations(server, {
+		logger: ctxFactories.logger,
+		presentations: ctxFactories.presentations
+	});
+	registerMcpPrompts(server, prompts, { promptCtx: ctxFactories.promptCtx });
+	return server;
+}
+
+//#endregion
+export { createMcpServer };

package/dist/server/mcp/mcpTypes.d.ts

@@ -0,0 +1,27 @@
+import { PresentationRegistry } from "../../presentations/registry.js";
+import "../../presentations/index.js";
+import { HandlerCtx } from "../../types.js";
+import { Logger } from "@contractspec/lib.logger";
+
+//#region src/server/mcp/mcpTypes.d.ts
+interface McpCtxFactories {
+  logger: Logger;
+  /** Factory for tool execution context (e.g., system actor) */
+  toolCtx: () => HandlerCtx;
+  /** Factory for prompt rendering context */
+  promptCtx: () => {
+    userId?: string | null;
+    orgId?: string | null;
+    locale?: string;
+  };
+  /** Factory for resource resolution context */
+  resourceCtx: () => {
+    userId?: string | null;
+    orgId?: string | null;
+    locale?: string;
+  };
+  /** Optional registry for presentations */
+  presentations?: PresentationRegistry;
+}
+//#endregion
+export { McpCtxFactories };

package/dist/server/mcp/registerPresentations.d.ts

@@ -0,0 +1,7 @@
+import { McpCtxFactories } from "./mcpTypes.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/server/mcp/registerPresentations.d.ts
+declare function registerMcpPresentations(server: McpServer, ctx: Pick<McpCtxFactories, 'logger' | 'presentations'>): void;
+//#endregion
+export { registerMcpPresentations };

package/dist/server/mcp/registerPresentations.js

@@ -0,0 +1,54 @@
+import { createDefaultTransformEngine, registerBasicValidation, registerDefaultReactRenderer } from "../../presentations/transform-engine.js";
+import "../../presentations/index.js";
+import { sanitizeMcpName } from "../../jsonschema.js";
+
+//#region src/server/mcp/registerPresentations.ts
+function isEngineRenderOutput(x) {
+	if (!x || typeof x !== "object") return false;
+	return "body" in x && typeof x.body === "string";
+}
+function registerMcpPresentations(server, ctx) {
+	if (!ctx.presentations?.count()) return;
+	const engine = registerBasicValidation(registerDefaultReactRenderer(createDefaultTransformEngine()));
+	for (const presentationSpec of ctx.presentations.list()) {
+		const baseKey = sanitizeMcpName(`presentation_${presentationSpec.meta.key}_v${presentationSpec.meta.version}`);
+		const baseUri = `presentation://${presentationSpec.meta.key}/v${presentationSpec.meta.version}`;
+		ctx.logger.debug(`Registering presentation ${baseUri} for ${baseKey}`);
+		server.registerResource(baseKey, baseUri, {
+			title: `${presentationSpec.meta.key} v${presentationSpec.meta.version}`,
+			description: presentationSpec.meta.description ?? "Presentation",
+			mimeType: "application/json"
+		}, async () => {
+			return { contents: [{
+				uri: baseUri,
+				mimeType: "application/json",
+				text: JSON.stringify({
+					meta: presentationSpec.meta,
+					source: presentationSpec.source,
+					targets: presentationSpec.targets
+				}, null, 2)
+			}] };
+		});
+		for (const v of [{
+			ext: ".md",
+			target: "markdown"
+		}]) {
+			const key = `${baseKey}${v.ext}`;
+			const uri = `${baseUri}${v.ext}`;
+			server.registerResource(key, uri, {
+				title: `${presentationSpec.meta.key} v${presentationSpec.meta.version} (${v.ext})`,
+				description: `${presentationSpec.meta.description ?? "Presentation"} (${v.ext})`
+			}, async () => {
+				const out = await engine.render(v.target, presentationSpec);
+				return { contents: [{
+					uri,
+					mimeType: isEngineRenderOutput(out) && out.mimeType ? out.mimeType : v.target === "markdown" ? "text/markdown" : v.target,
+					text: isEngineRenderOutput(out) && typeof out.body === "string" ? out.body : String(out)
+				}] };
+			});
+		}
+	}
+}
+
+//#endregion
+export { registerMcpPresentations };

package/dist/server/mcp/registerPrompts.d.ts

@@ -0,0 +1,8 @@
+import { PromptRegistry } from "../../promptRegistry.js";
+import { McpCtxFactories } from "./mcpTypes.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/server/mcp/registerPrompts.d.ts
+declare function registerMcpPrompts(server: McpServer, prompts: PromptRegistry, ctx: Pick<McpCtxFactories, 'promptCtx'>): void;
+//#endregion
+export { registerMcpPrompts };

package/dist/server/mcp/registerPrompts.js

@@ -0,0 +1,41 @@
+import { defaultMcpPrompt } from "../../jsonschema.js";
+import z from "zod";
+
+//#region src/server/mcp/registerPrompts.ts
+function promptArgsSchemaFromPromptArgs(args) {
+	const shape = {};
+	for (const a of args) shape[a.name] = a.schema;
+	return shape;
+}
+function registerMcpPrompts(server, prompts, ctx) {
+	for (const prompt of prompts.list()) {
+		const promptName = defaultMcpPrompt(prompt.meta.key);
+		server.registerPrompt(promptName, {
+			title: prompt.meta.title,
+			description: prompt.meta.description,
+			argsSchema: promptArgsSchemaFromPromptArgs(prompt.args)
+		}, async (args) => {
+			const link = (tpl, vars) => {
+				let out = tpl;
+				for (const [k, v] of Object.entries(vars)) out = out.replace(new RegExp(`\\{${k}\\}`, "g"), encodeURIComponent(String(v)));
+				return out;
+			};
+			return {
+				messages: [{
+					role: "assistant",
+					content: {
+						type: "text",
+						text: (await prompt.render(prompt.input.parse(args), {
+							...ctx.promptCtx(),
+							link
+						})).map((p) => p.type === "text" ? p.text : `See resource: ${p.title ?? p.uri}\nURI: ${p.uri}`).join("\n\n")
+					}
+				}],
+				description: prompt.meta.description
+			};
+		});
+	}
+}
+
+//#endregion
+export { registerMcpPrompts };

package/dist/server/mcp/registerResources.d.ts

@@ -0,0 +1,8 @@
+import { ResourceRegistry } from "../../resources.js";
+import { McpCtxFactories } from "./mcpTypes.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/server/mcp/registerResources.d.ts
+declare function registerMcpResources(server: McpServer, resources: ResourceRegistry, ctx: Pick<McpCtxFactories, 'logger' | 'resourceCtx'>): void;
+//#endregion
+export { registerMcpResources };

package/dist/server/mcp/registerResources.js

@@ -0,0 +1,35 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Buffer } from "node:buffer";
+
+//#region src/server/mcp/registerResources.ts
+function mcpResourceMeta(resource) {
+	return {
+		title: resource.meta.title,
+		description: resource.meta.description,
+		mimeType: resource.meta.mimeType,
+		_meta: { tags: resource.meta.tags ?? [] }
+	};
+}
+function registerMcpResources(server, resources, ctx) {
+	for (const resource of resources.listTemplates()) {
+		ctx.logger.debug("Registering resource: " + resource.meta.uriTemplate);
+		server.registerResource(resource.meta.uriTemplate, new ResourceTemplate(resource.meta.uriTemplate, { list: void 0 }), mcpResourceMeta(resource), async (_uri, variables) => {
+			const parsedArgs = resource.input.parse(variables);
+			const out = await resource.resolve(parsedArgs, ctx.resourceCtx());
+			if (typeof out.data === "string") return { contents: [{
+				uri: out.uri,
+				mimeType: out.mimeType ?? resource.meta.mimeType,
+				text: out.data
+			}] };
+			return { contents: [{
+				uri: out.uri,
+				mimeType: out.mimeType ?? resource.meta.mimeType,
+				blob: Buffer.from(out.data).toString("base64")
+			}] };
+		});
+		ctx.logger.debug("Registered resource: " + resource.meta.uriTemplate);
+	}
+}
+
+//#endregion
+export { registerMcpResources };

package/dist/server/mcp/registerTools.d.ts

@@ -0,0 +1,8 @@
+import { OperationSpecRegistry } from "../../operations/registry.js";
+import { McpCtxFactories } from "./mcpTypes.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/server/mcp/registerTools.d.ts
+declare function registerMcpTools(server: McpServer, ops: OperationSpecRegistry, ctx: Pick<McpCtxFactories, 'toolCtx'>): void;
+//#endregion
+export { registerMcpTools };

package/dist/server/mcp/registerTools.js

@@ -0,0 +1,22 @@
+import { defaultMcpTool } from "../../jsonschema.js";
+
+//#region src/server/mcp/registerTools.ts
+function registerMcpTools(server, ops, ctx) {
+	for (const spec of ops.list()) {
+		if (spec.meta.kind !== "command") continue;
+		const toolName = spec.transport?.mcp?.toolName ?? defaultMcpTool(spec.meta.key, spec.meta.version);
+		server.registerTool(toolName, {
+			description: spec.meta.description,
+			inputSchema: spec.io.input?.getZod()
+		}, async (args) => {
+			const result = await ops.execute(spec.meta.key, spec.meta.version, args ?? {}, ctx.toolCtx());
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 4)
+			}] };
+		});
+	}
+}
+
+//#endregion
+export { registerMcpTools };

package/dist/server/provider-mcp.d.ts

@@ -0,0 +1,2 @@
+import { createMcpServer } from "./mcp/createMcpServer.js";
+export { createMcpServer };

package/dist/server/provider-mcp.js

@@ -0,0 +1,3 @@
+import { createMcpServer } from "./mcp/createMcpServer.js";
+
+export { createMcpServer };

package/dist/server/rest-elysia.d.ts

@@ -0,0 +1,40 @@
+import { OperationSpecRegistry } from "../operations/registry.js";
+import { HandlerCtx } from "../types.js";
+import { RestOptions } from "./rest-generic.js";
+import { Elysia } from "elysia";
+
+//#region src/server/rest-elysia.d.ts
+/** Mount routes on an Elysia instance */
+declare function elysiaPlugin(app: Elysia, reg: OperationSpecRegistry, ctxFactory: (c: {
+  request: Request;
+  store: unknown;
+}) => HandlerCtx, options?: RestOptions): Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+//#endregion
+export { elysiaPlugin };

package/dist/server/rest-elysia.js

@@ -0,0 +1,20 @@
+import { createFetchHandler } from "./rest-generic.js";
+
+//#region src/server/rest-elysia.ts
+/** Mount routes on an Elysia instance */
+function elysiaPlugin(app, reg, ctxFactory, options) {
+	const handler = createFetchHandler(reg, (req) => ctxFactory({
+		request: req,
+		store: app.store
+	}), options);
+	for (const spec of reg.list()) {
+		const method = spec.transport?.rest?.method ?? (spec.meta.kind === "query" ? "GET" : "POST");
+		const path = (options?.basePath ?? "") + (spec.transport?.rest?.path ?? `/${spec.meta.key.replace(/\./g, "/")}/v${spec.meta.version}`);
+		app[method.toLowerCase()](path, ({ request }) => handler(request));
+	}
+	if (options?.cors) app.options("*", ({ request }) => handler(request));
+	return app;
+}
+
+//#endregion
+export { elysiaPlugin };

package/dist/server/rest-express.d.ts

@@ -0,0 +1,16 @@
+import { OperationSpecRegistry } from "../operations/registry.js";
+import { HandlerCtx } from "../types.js";
+import { RestOptions } from "./rest-generic.js";
+import { Request, Router } from "express";
+
+//#region src/server/rest-express.d.ts
+
+/**
+ * Build an Express Router that proxies to the Fetch-style handler.
+ * You can mount it at any base path; pass the same basePath in options.
+ */
+declare function expressRouter(express: {
+  Router: () => Router;
+}, reg: OperationSpecRegistry, ctxFactory: (req: Request) => HandlerCtx, options?: RestOptions): Router;
+//#endregion
+export { expressRouter };

package/dist/server/rest-express.js

@@ -0,0 +1,36 @@
+import { createFetchHandler } from "./rest-generic.js";
+
+//#region src/server/rest-express.ts
+/**
+* Build an Express Router that proxies to the Fetch-style handler.
+* You can mount it at any base path; pass the same basePath in options.
+*/
+function expressRouter(express, reg, ctxFactory, options) {
+	const router = express.Router();
+	for (const spec of reg.list()) {
+		const method = spec.transport?.rest?.method ?? (spec.meta.kind === "query" ? "GET" : "POST");
+		const path = (options?.basePath ?? "") + (spec.transport?.rest?.path ?? `/${spec.meta.key.replace(/\./g, "/")}/v${spec.meta.version}`);
+		router[method.toLowerCase()](path, async (req, res) => {
+			const url = new URL(`${req.protocol}://${req.get("host")}${req.originalUrl}`);
+			const request = new Request(url.toString(), {
+				method,
+				headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, String(v)])),
+				body: method === "POST" ? JSON.stringify(req.body ?? {}) : void 0
+			});
+			const response = await createFetchHandler(reg, () => ctxFactory(req), options)(request);
+			res.status(response.status);
+			response.headers.forEach((v, k) => res.setHeader(k, v));
+			const text = await response.text();
+			res.send(text);
+		});
+	}
+	if (options?.cors) router.options("*", (_req, res) => {
+		const h = new Headers();
+		new Response(null, { status: 204 }).headers.forEach((v, k) => h.set(k, v));
+		res.status(204).send();
+	});
+	return router;
+}
+
+//#endregion
+export { expressRouter };

package/dist/server/rest-generic.d.ts

@@ -0,0 +1,32 @@
+import { OperationSpecRegistry } from "../operations/registry.js";
+import { HandlerCtx } from "../types.js";
+
+//#region src/server/rest-generic.d.ts
+interface RestOptions {
+  /** Prefix all routes, e.g. "/api" */
+  basePath?: string;
+  /** If true, handle OPTIONS and set CORS headers */
+  cors?: boolean | {
+    origin?: string | '*';
+    methods?: string[];
+    headers?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+  };
+  /** JSON spacing in responses (dev only ideally) */
+  prettyJson?: number | false;
+  /** Map thrown errors to {status, body} */
+  onError?: (err: unknown) => {
+    status: number;
+    body: unknown;
+  };
+}
+/**
+ * Build a single Fetch-style handler: (req) => Response
+ * - Discovers routes from OperationSpecRegistry
+ * - Validates with zod via registry.execute()
+ * - Handles CORS (optional)
+ */
+declare function createFetchHandler(reg: OperationSpecRegistry, ctxFactory: (req: Request) => HandlerCtx, options?: RestOptions): (req: Request) => Promise<Response>;
+//#endregion
+export { RestOptions, createFetchHandler };