@contractspec/lib.contracts 1.44.0

package/dist/markdown.js

@@ -0,0 +1,119 @@
+import { isEmitDeclRef } from "./operations/operation.js";
+import "./operations/index.js";
+
+//#region src/markdown.ts
+/**
+* Render simple Markdown docs for each spec.
+* Useful for dev portals and repo docs generation.
+*/
+function operationsToMarkdown(registry, _extras) {
+	const lines = [];
+	for (const spec of registry.listSpecs()) {
+		const m = spec.meta;
+		lines.push(`# ${m.key}.v${m.version}`);
+		lines.push("");
+		lines.push(`**Kind:** ${m.kind} | **Stability:** ${m.stability} | **Owners:** ${m.owners.join(", ")}`);
+		lines.push("");
+		lines.push(`**Description:** ${m.description}`);
+		lines.push("");
+		lines.push(`## Goal`);
+		lines.push(m.goal);
+		lines.push("");
+		lines.push(`## Context`);
+		lines.push(m.context);
+		lines.push("");
+		lines.push(`## Policy`);
+		lines.push(`- Auth: ${spec.policy.auth}`);
+		lines.push(`- Idempotent: ${!!spec.policy.idempotent}`);
+		if (spec.policy.rateLimit) lines.push(`- Rate Limit: ${spec.policy.rateLimit.rpm}/min by ${spec.policy.rateLimit.key}`);
+		if (spec.policy.flags?.length) lines.push(`- Flags: ${spec.policy.flags.join(", ")}`);
+		if (spec.policy.pii?.length) lines.push(`- PII: ${spec.policy.pii.join(", ")}`);
+		lines.push("");
+		if (spec.sideEffects?.emits?.length) {
+			lines.push(`## Emits Events`);
+			for (const e of spec.sideEffects.emits) if (isEmitDeclRef(e)) lines.push(`- \`${e.ref.key}.v${e.ref.version}\` — ${e.when}`);
+			else lines.push(`- \`${e.key}.v${e.version}\` — ${e.when}`);
+			lines.push("");
+		}
+		if (spec.io.errors && Object.keys(spec.io.errors).length) {
+			lines.push(`## Errors`);
+			for (const [code, err] of Object.entries(spec.io.errors)) lines.push(`- \`${code}\` (${err.http ?? 400}) — ${err.description} (when: ${err.when})`);
+			lines.push("");
+		}
+		if (spec.acceptance?.scenarios?.length) {
+			lines.push(`## Acceptance Scenarios`);
+			for (const s of spec.acceptance.scenarios) {
+				lines.push(`### ${s.key}`);
+				lines.push(`- **Given:** ${s.given.join("; ")}`);
+				lines.push(`- **When:** ${s.when.join("; ")}`);
+				lines.push(`- **Then:** ${s.then.join("; ")}`);
+				lines.push("");
+			}
+		}
+		if (spec.acceptance?.examples?.length) {
+			lines.push(`## Examples`);
+			for (const ex of spec.acceptance.examples) {
+				lines.push(`- **${ex.key}**`);
+				lines.push("  - Input:");
+				lines.push("    ```json");
+				lines.push(JSON.stringify(ex.input, null, 2));
+				lines.push("    ```");
+				lines.push("  - Output:");
+				lines.push("    ```json");
+				lines.push(JSON.stringify(ex.output, null, 2));
+				lines.push("    ```");
+				lines.push("");
+			}
+		}
+		lines.push("---");
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/** Render presentations and features as additional sections. */
+function docsToMarkdown(reg, extras) {
+	const parts = [];
+	parts.push(operationsToMarkdown(reg, extras));
+	if (extras.presentations) {
+		parts.push("# Presentations");
+		parts.push("");
+		for (const p of extras.presentations.list()) {
+			parts.push(`## ${p.meta.key}.v${p.meta.version}`);
+			parts.push("");
+			parts.push(`- Type: ${p.source.type}`);
+			if (p.source.type === "component") {
+				parts.push(`- Framework: ${p.source.framework}`);
+				parts.push(`- Component Key: ${p.source.componentKey}`);
+			}
+			parts.push(`- Targets: ${p.targets.join(", ")}`);
+			parts.push("");
+		}
+		parts.push("");
+	}
+	if (extras.features) {
+		parts.push("# Features");
+		parts.push("");
+		for (const f of extras.features.list()) {
+			parts.push(`## ${f.meta.title} (${f.meta.key})`);
+			if (f.meta.description) parts.push(f.meta.description);
+			parts.push("");
+			if (f.operations?.length) {
+				parts.push("- Operations:");
+				for (const o of f.operations) parts.push(`  - ${o.key}.v${o.version}`);
+			}
+			if (f.events?.length) {
+				parts.push("- Events:");
+				for (const e of f.events) parts.push(`  - ${e.key}.v${e.version}`);
+			}
+			if (f.presentations?.length) {
+				parts.push("- Presentations:");
+				for (const pres of f.presentations) parts.push(`  - ${pres.key}.v${pres.version}`);
+			}
+			parts.push("");
+		}
+	}
+	return parts.join("\n");
+}
+
+//#endregion
+export { docsToMarkdown, operationsToMarkdown };

package/dist/migrations.d.ts

@@ -0,0 +1,52 @@
+import { OwnerShipMeta } from "./ownership.js";
+
+//#region src/migrations.d.ts
+type MigrationStepKind = 'schema' | 'data' | 'validation';
+interface MigrationCheck {
+  description: string;
+  expression: string;
+}
+interface MigrationStepBase {
+  kind: MigrationStepKind;
+  description?: string;
+  timeoutMs?: number;
+  retries?: number;
+  preChecks?: MigrationCheck[];
+  postChecks?: MigrationCheck[];
+}
+interface SchemaMigrationStep extends MigrationStepBase {
+  kind: 'schema';
+  sql: string;
+}
+interface DataMigrationStep extends MigrationStepBase {
+  kind: 'data';
+  script: string;
+}
+interface ValidationMigrationStep extends MigrationStepBase {
+  kind: 'validation';
+  assertion: string;
+}
+type MigrationStep = SchemaMigrationStep | DataMigrationStep | ValidationMigrationStep;
+interface MigrationMeta extends OwnerShipMeta {
+  /** Fully qualified migration name (e.g., "sigil.db.2025_01_add_users"). */
+  key: string;
+  /** Increment when the migration changes. */
+  version: number;
+}
+interface MigrationPlan {
+  up: MigrationStep[];
+  down?: MigrationStep[];
+}
+interface MigrationSpec {
+  meta: MigrationMeta;
+  plan: MigrationPlan;
+  dependencies?: string[];
+}
+declare class MigrationRegistry {
+  private readonly items;
+  register(spec: MigrationSpec): this;
+  list(): MigrationSpec[];
+  get(name: string, version?: number): MigrationSpec | undefined;
+}
+//#endregion
+export { DataMigrationStep, MigrationCheck, MigrationMeta, MigrationPlan, MigrationRegistry, MigrationSpec, MigrationStep, MigrationStepBase, MigrationStepKind, SchemaMigrationStep, ValidationMigrationStep };

package/dist/migrations.js

@@ -0,0 +1,33 @@
+//#region src/migrations.ts
+const migrationKey = (name, version) => `${name}.v${version}`;
+var MigrationRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	register(spec) {
+		const key = migrationKey(spec.meta.key, spec.meta.version);
+		if (this.items.has(key)) throw new Error(`Duplicate migration ${key}`);
+		this.items.set(key, spec);
+		return this;
+	}
+	list() {
+		return [...this.items.values()].sort((a, b) => compareKey(migrationKey(a.meta.key, a.meta.version), migrationKey(b.meta.key, b.meta.version)));
+	}
+	get(name, version) {
+		if (version != null) return this.items.get(migrationKey(name, version));
+		let candidate;
+		let max = -Infinity;
+		for (const spec of this.items.values()) {
+			if (spec.meta.key !== name) continue;
+			if (spec.meta.version > max) {
+				max = spec.meta.version;
+				candidate = spec;
+			}
+		}
+		return candidate;
+	}
+};
+function compareKey(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+//#endregion
+export { MigrationRegistry };

package/dist/model-registry.d.ts

@@ -0,0 +1,13 @@
+import { AnySchemaModel } from "@contractspec/lib.schema";
+
+//#region src/model-registry.d.ts
+/** In-memory registry for SchemaModel and SchemaType instances. */
+declare class ModelRegistry {
+  private items;
+  constructor(items?: AnySchemaModel[]);
+  register(p: AnySchemaModel): this;
+  list(): AnySchemaModel[];
+  get(name: string): AnySchemaModel | undefined;
+}
+//#endregion
+export { ModelRegistry };

package/dist/model-registry.js

@@ -0,0 +1,33 @@
+import { isSchemaModel } from "@contractspec/lib.schema";
+
+//#region src/model-registry.ts
+/**
+* Get a name for any schema model type.
+* For SchemaModel, uses config.name. For other SchemaType, generates a default.
+*/
+function getModelName(model) {
+	if (isSchemaModel(model)) return model.config.name;
+	return "AnonymousSchema_" + Math.random().toString(36).substring(7);
+}
+/** In-memory registry for SchemaModel and SchemaType instances. */
+var ModelRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	constructor(items) {
+		if (items) items.forEach((p) => this.register(p));
+	}
+	register(p) {
+		const name = getModelName(p);
+		if (this.items.has(name)) throw new Error(`Duplicate contract \`model\` ${name}`);
+		this.items.set(name, p);
+		return this;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(name) {
+		return this.items.get(name);
+	}
+};
+
+//#endregion
+export { ModelRegistry };

package/dist/onboarding-base.d.ts

@@ -0,0 +1,138 @@
+import { OperationSpec } from "./operations/operation.js";
+import "./index.js";
+import * as _contractspec_lib_schema53 from "@contractspec/lib.schema";
+import { SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/onboarding-base.d.ts
+/** Save/update onboarding draft (auto-save during flow) */
+declare const SaveOnboardingDraftInput: SchemaModel<{
+  data: {
+    type: _contractspec_lib_schema53.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>;
+declare const SaveOnboardingDraftOutput: SchemaModel<{
+  id: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: false;
+  };
+  organizationId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: false;
+  };
+}>;
+declare const SaveOnboardingDraftBaseSpec: OperationSpec<SchemaModel<{
+  data: {
+    type: _contractspec_lib_schema53.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>, SchemaModel<{
+  id: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: false;
+  };
+  organizationId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: false;
+  };
+}>, undefined>;
+/** Get current onboarding draft (on mount/restore) */
+declare const GetOnboardingDraftOutput: SchemaModel<{
+  id: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+  data: {
+    type: _contractspec_lib_schema53.FieldType<unknown, unknown>;
+    isOptional: true;
+  };
+  createdAt: {
+    type: _contractspec_lib_schema53.FieldType<Date, string>;
+    isOptional: true;
+  };
+  updatedAt: {
+    type: _contractspec_lib_schema53.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>;
+declare const GetOnboardingDraftBaseSpec: OperationSpec<_contractspec_lib_schema53.AnySchemaModel, SchemaModel<{
+  id: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+  data: {
+    type: _contractspec_lib_schema53.FieldType<unknown, unknown>;
+    isOptional: true;
+  };
+  createdAt: {
+    type: _contractspec_lib_schema53.FieldType<Date, string>;
+    isOptional: true;
+  };
+  updatedAt: {
+    type: _contractspec_lib_schema53.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+/** Delete onboarding draft (cleanup after completion or cancel) */
+declare const DeleteOnboardingDraftOutput: SchemaModel<{
+  ok: {
+    type: _contractspec_lib_schema53.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+}>;
+declare const DeleteOnboardingDraftBaseSpec: OperationSpec<_contractspec_lib_schema53.AnySchemaModel, SchemaModel<{
+  ok: {
+    type: _contractspec_lib_schema53.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+}>, undefined>;
+/** Complete onboarding (final submit, creates entities) */
+declare const CompleteOnboardingBaseInput: SchemaModel<{
+  data: {
+    type: _contractspec_lib_schema53.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>;
+declare const CompleteOnboardingBaseOutput: SchemaModel<{
+  success: {
+    type: _contractspec_lib_schema53.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+  userId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+}>;
+declare const CompleteOnboardingBaseSpec: OperationSpec<SchemaModel<{
+  data: {
+    type: _contractspec_lib_schema53.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>, SchemaModel<{
+  success: {
+    type: _contractspec_lib_schema53.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+  userId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _contractspec_lib_schema53.FieldType<string, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+//#endregion
+export { CompleteOnboardingBaseInput, CompleteOnboardingBaseOutput, CompleteOnboardingBaseSpec, DeleteOnboardingDraftBaseSpec, DeleteOnboardingDraftOutput, GetOnboardingDraftBaseSpec, GetOnboardingDraftOutput, SaveOnboardingDraftBaseSpec, SaveOnboardingDraftInput, SaveOnboardingDraftOutput };

package/dist/onboarding-base.js

@@ -0,0 +1,195 @@
+import { OwnersEnum, StabilityEnum } from "./ownership.js";
+import { defineCommand, defineQuery } from "./operations/operation.js";
+import "./operations/index.js";
+import { ScalarTypeEnum, SchemaModel } from "@contractspec/lib.schema";
+
+//#region src/onboarding-base.ts
+/**
+* Shared base contracts for onboarding flows across verticals.
+* These operations are reusable for any app that needs multi-step onboarding with draft persistence.
+*/
+/** Save/update onboarding draft (auto-save during flow) */
+const SaveOnboardingDraftInput = new SchemaModel({
+	name: "SaveOnboardingDraftInput",
+	description: "Input for saving onboarding draft",
+	fields: { data: {
+		type: ScalarTypeEnum.JSON(),
+		isOptional: false
+	} }
+});
+const SaveOnboardingDraftOutput = new SchemaModel({
+	name: "SaveOnboardingDraftOutput",
+	description: "Output for saving onboarding draft",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		organizationId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		}
+	}
+});
+const SaveOnboardingDraftBaseSpec = defineCommand({
+	meta: {
+		key: "base.onboarding.saveDraft",
+		version: 1,
+		stability: StabilityEnum.Beta,
+		owners: [OwnersEnum.PlatformSigil],
+		tags: ["onboarding", "draft"],
+		description: "Save or update onboarding draft for active organization",
+		goal: "Persist onboarding progress incrementally for resumption and safety",
+		context: "Auto-saves every few seconds during onboarding; enables users to leave and resume"
+	},
+	io: {
+		input: SaveOnboardingDraftInput,
+		output: SaveOnboardingDraftOutput
+	},
+	policy: {
+		auth: "user",
+		escalate: null
+	},
+	transport: {
+		gql: { field: "saveOnboardingDraft" },
+		rest: { method: "POST" }
+	}
+});
+/** Get current onboarding draft (on mount/restore) */
+const GetOnboardingDraftOutput = new SchemaModel({
+	name: "GetOnboardingDraftOutput",
+	description: "Onboarding draft payload",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		organizationId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		data: {
+			type: ScalarTypeEnum.JSON(),
+			isOptional: true
+		},
+		createdAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		},
+		updatedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		}
+	}
+});
+const GetOnboardingDraftBaseSpec = defineQuery({
+	meta: {
+		key: "base.onboarding.getDraft",
+		version: 1,
+		stability: StabilityEnum.Beta,
+		owners: [OwnersEnum.PlatformSigil],
+		tags: ["onboarding", "draft"],
+		description: "Get onboarding draft for active organization",
+		goal: "Retrieve saved onboarding progress",
+		context: "Called on mount to restore in-progress onboarding"
+	},
+	io: {
+		input: null,
+		output: GetOnboardingDraftOutput
+	},
+	policy: {
+		auth: "user",
+		escalate: null
+	},
+	transport: {
+		gql: { field: "getOnboardingDraft" },
+		rest: { method: "GET" }
+	}
+});
+/** Delete onboarding draft (cleanup after completion or cancel) */
+const DeleteOnboardingDraftOutput = new SchemaModel({
+	name: "DeleteOnboardingDraftOutput",
+	description: "Result of delete operation",
+	fields: { ok: {
+		type: ScalarTypeEnum.Boolean(),
+		isOptional: false
+	} }
+});
+const DeleteOnboardingDraftBaseSpec = defineCommand({
+	meta: {
+		key: "base.onboarding.deleteDraft",
+		version: 1,
+		stability: StabilityEnum.Beta,
+		owners: [OwnersEnum.PlatformSigil],
+		tags: ["onboarding", "draft"],
+		description: "Delete onboarding draft for active organization",
+		goal: "Clear draft after completion or if user wants to restart",
+		context: "Called after successful onboarding or explicit user reset"
+	},
+	io: {
+		input: null,
+		output: DeleteOnboardingDraftOutput
+	},
+	policy: {
+		auth: "user",
+		escalate: null
+	},
+	transport: {
+		gql: { field: "deleteOnboardingDraft" },
+		rest: { method: "POST" }
+	}
+});
+/** Complete onboarding (final submit, creates entities) */
+const CompleteOnboardingBaseInput = new SchemaModel({
+	name: "CompleteOnboardingBaseInput",
+	description: "Input for completing onboarding",
+	fields: { data: {
+		type: ScalarTypeEnum.JSON(),
+		isOptional: false
+	} }
+});
+const CompleteOnboardingBaseOutput = new SchemaModel({
+	name: "CompleteOnboardingBaseOutput",
+	description: "Result of onboarding completion",
+	fields: {
+		success: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: false
+		},
+		userId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		},
+		organizationId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: true
+		}
+	}
+});
+const CompleteOnboardingBaseSpec = defineCommand({
+	meta: {
+		key: "base.onboarding.complete",
+		version: 1,
+		stability: StabilityEnum.Beta,
+		owners: [OwnersEnum.PlatformSigil],
+		tags: ["onboarding"],
+		description: "Complete onboarding and finalize user/organization setup",
+		goal: "Transition from draft to active profile",
+		context: "Validates all required fields, creates/updates entities, marks onboarding complete"
+	},
+	io: {
+		input: CompleteOnboardingBaseInput,
+		output: CompleteOnboardingBaseOutput
+	},
+	policy: {
+		auth: "user",
+		escalate: null
+	},
+	transport: {
+		gql: { field: "completeOnboarding" },
+		rest: { method: "POST" }
+	}
+});
+
+//#endregion
+export { CompleteOnboardingBaseInput, CompleteOnboardingBaseOutput, CompleteOnboardingBaseSpec, DeleteOnboardingDraftBaseSpec, DeleteOnboardingDraftOutput, GetOnboardingDraftBaseSpec, GetOnboardingDraftOutput, SaveOnboardingDraftBaseSpec, SaveOnboardingDraftInput, SaveOnboardingDraftOutput };

package/dist/openapi.d.ts

@@ -0,0 +1,31 @@
+import { OperationSpecRegistry } from "./operations/registry.js";
+
+//#region src/openapi.d.ts
+
+interface OpenApiServer {
+  url: string;
+  description?: string;
+}
+interface OpenApiExportOptions {
+  title?: string;
+  version?: string;
+  description?: string;
+  servers?: OpenApiServer[];
+}
+type OpenApiSchemaObject = Record<string, unknown>;
+interface OpenApiDocument {
+  openapi: '3.1.0';
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+  };
+  servers?: OpenApiServer[];
+  paths: Record<string, Record<string, unknown>>;
+  components: {
+    schemas: Record<string, OpenApiSchemaObject>;
+  };
+}
+declare function openApiForRegistry(registry: OperationSpecRegistry, options?: OpenApiExportOptions): OpenApiDocument;
+//#endregion
+export { OpenApiDocument, OpenApiExportOptions, OpenApiServer, openApiForRegistry };

package/dist/openapi.js

@@ -0,0 +1,75 @@
+import { defaultRestPath, jsonSchemaForSpec } from "./jsonschema.js";
+
+//#region src/openapi.ts
+function toOperationId(name, version) {
+	return `${name.replace(/\./g, "_")}_v${version}`;
+}
+function toSchemaName(prefix, name, version) {
+	return `${prefix}_${toOperationId(name, version)}`;
+}
+function toHttpMethod(kind, override) {
+	return (override ?? (kind === "query" ? "GET" : "POST")).toLowerCase();
+}
+function toRestPath(spec) {
+	const path = spec.transport?.rest?.path ?? defaultRestPath(spec.meta.key, spec.meta.version);
+	return path.startsWith("/") ? path : `/${path}`;
+}
+function openApiForRegistry(registry, options = {}) {
+	const specs = registry.listSpecs().filter((s) => s.meta.kind === "command" || s.meta.kind === "query").slice().sort((a, b) => {
+		const byName = a.meta.key.localeCompare(b.meta.key);
+		return byName !== 0 ? byName : a.meta.version - b.meta.version;
+	});
+	const doc = {
+		openapi: "3.1.0",
+		info: {
+			title: options.title ?? "ContractSpec API",
+			version: options.version ?? "0.0.0",
+			...options.description ? { description: options.description } : {}
+		},
+		...options.servers ? { servers: options.servers } : {},
+		paths: {},
+		components: { schemas: {} }
+	};
+	for (const spec of specs) {
+		const schema = jsonSchemaForSpec(spec);
+		const method = toHttpMethod(spec.meta.kind, spec.transport?.rest?.method);
+		const path = toRestPath(spec);
+		const operationId = toOperationId(spec.meta.key, spec.meta.version);
+		const pathItem = doc.paths[path] ??= {};
+		const op = {
+			operationId,
+			summary: spec.meta.description ?? spec.meta.key,
+			description: spec.meta.description,
+			tags: spec.meta.tags ?? [],
+			"x-contractspec": {
+				name: spec.meta.key,
+				version: spec.meta.version,
+				kind: spec.meta.kind
+			},
+			responses: {}
+		};
+		if (schema.input) {
+			const inputName = toSchemaName("Input", spec.meta.key, spec.meta.version);
+			doc.components.schemas[inputName] = schema.input;
+			op["requestBody"] = {
+				required: true,
+				content: { "application/json": { schema: { $ref: `#/components/schemas/${inputName}` } } }
+			};
+		}
+		const responses = {};
+		if (schema.output) {
+			const outputName = toSchemaName("Output", spec.meta.key, spec.meta.version);
+			doc.components.schemas[outputName] = schema.output;
+			responses["200"] = {
+				description: "OK",
+				content: { "application/json": { schema: { $ref: `#/components/schemas/${outputName}` } } }
+			};
+		} else responses["200"] = { description: "OK" };
+		op["responses"] = responses;
+		pathItem[method] = op;
+	}
+	return doc;
+}
+
+//#endregion
+export { openApiForRegistry };

package/dist/operations/index.d.ts

@@ -0,0 +1,3 @@
+import { AnyOperationSpec, EmitDecl, EmitDeclInline, EmitDeclRef, ImplementationRef, ImplementationType, OpKind, OperationSpec, OperationSpecMeta, TelemetryTrigger, defineCommand, defineQuery, isEmitDeclRef } from "./operation.js";
+import { OperationKey, OperationSpecRegistry, opKey } from "./registry.js";
+export { AnyOperationSpec, EmitDecl, EmitDeclInline, EmitDeclRef, ImplementationRef, ImplementationType, OpKind, OperationKey, OperationSpec, OperationSpecMeta, OperationSpecRegistry, TelemetryTrigger, defineCommand, defineQuery, isEmitDeclRef, opKey };