@contractspec/lib.contracts-transformers 1.57.0 → 1.58.0

package/dist/index.js

@@ -1,18 +1,2415 @@
-import { detectFormat, detectVersion, parseOpenApiString } from "./openapi/parser/utils.js";
-import { parseOpenApi, parseOpenApiDocument } from "./openapi/parser/document.js";
-import { defaultRestPath, exportOperations, generateOperationsRegistry, jsonSchemaForSpec, schemaModelToJsonSchema, toHttpMethod, toOperationId, toRestPath, toSchemaName } from "./openapi/exporter/operations.js";
-import { exportEvents, generateEventsExports } from "./openapi/exporter/events.js";
-import { exportFeatures, generateFeaturesRegistry } from "./openapi/exporter/features.js";
-import { exportPresentations, exportPresentationsFromArray, generatePresentationsRegistry } from "./openapi/exporter/presentations.js";
-import { exportForms, generateFormsRegistry } from "./openapi/exporter/forms.js";
-import { exportDataViews, generateDataViewsRegistry } from "./openapi/exporter/data-views.js";
-import { exportWorkflows, generateWorkflowsRegistry } from "./openapi/exporter/workflows.js";
-import { generateRegistryIndex } from "./openapi/exporter/registries.js";
-import { contractSpecToJson, contractSpecToYaml, exportContractSpec, openApiForRegistry, openApiToJson, openApiToYaml } from "./openapi/exporter.js";
-import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier } from "./common/utils.js";
-import { generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToType } from "./openapi/schema-converter.js";
-import { importFromOpenApi, importOperation } from "./openapi/importer/index.js";
-import { createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges } from "./openapi/differ.js";
-import "./openapi/index.js";
-
-export { contractSpecToJson, contractSpecToYaml, createSpecDiff, deepEqual, defaultRestPath, detectFormat, detectVersion, diffAll, diffSpecVsOperation, diffSpecs, exportContractSpec, exportDataViews, exportEvents, exportFeatures, exportForms, exportOperations, exportPresentations, exportPresentationsFromArray, exportWorkflows, extractPathParams, formatDiffChanges, generateDataViewsRegistry, generateEventsExports, generateFeaturesRegistry, generateFormsRegistry, generateImports, generateOperationsRegistry, generatePresentationsRegistry, generateRegistryIndex, generateSchemaModelCode, generateWorkflowsRegistry, getByPath, getScalarType, importFromOpenApi, importOperation, jsonSchemaForSpec, jsonSchemaToType, normalizePath, openApiForRegistry, openApiToJson, openApiToYaml, parseOpenApi, parseOpenApiDocument, parseOpenApiString, schemaModelToJsonSchema, toCamelCase, toFileName, toHttpMethod, toKebabCase, toOperationId, toPascalCase, toRestPath, toSchemaName, toSnakeCase, toSpecKey, toValidIdentifier };
+// @bun
+// src/common/utils.ts
+function toPascalCase(str) {
+  return str.replace(/[-_./\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_./]+/g, "-").toLowerCase();
+}
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-./]+/g, "_").toLowerCase();
+}
+function toValidIdentifier(str) {
+  let result = str.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(result)) {
+    result = "_" + result;
+  }
+  return result;
+}
+function toSpecKey(operationId, prefix) {
+  const key = toCamelCase(operationId);
+  return prefix ? `${prefix}.${key}` : key;
+}
+function toFileName(specName) {
+  return toKebabCase(specName.replace(/\./g, "-")) + ".ts";
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (const key of aKeys) {
+      if (!bKeys.includes(key))
+        return false;
+      if (!deepEqual(aObj[key], bObj[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function getByPath(obj, path) {
+  const parts = path.split(".").filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current !== "object")
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function extractPathParams(path) {
+  const matches = path.match(/\{([^}]+)\}/g) || [];
+  return matches.map((m) => m.slice(1, -1));
+}
+function normalizePath(path) {
+  let normalized = path.replace(/^\/+|\/+$/g, "");
+  normalized = normalized.replace(/\/+/g, "/");
+  return "/" + normalized;
+}
+// src/openapi/parser/utils.ts
+import { parse as parseYaml } from "yaml";
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace"
+];
+function parseOpenApiString(content, format = "json") {
+  if (format === "yaml") {
+    return parseYaml(content);
+  }
+  return JSON.parse(content);
+}
+function detectFormat(content) {
+  const trimmed = content.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return "json";
+  }
+  return "yaml";
+}
+function detectVersion(doc) {
+  const version = doc.openapi;
+  if (version.startsWith("3.1")) {
+    return "3.1";
+  }
+  return "3.0";
+}
+function generateOperationId(method, path) {
+  const pathParts = path.split("/").filter(Boolean).map((part) => {
+    if (part.startsWith("{") && part.endsWith("}")) {
+      return "By" + part.slice(1, -1).charAt(0).toUpperCase() + part.slice(2, -1);
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1);
+  });
+  return method + pathParts.join("");
+}
+// src/openapi/parser/resolvers.ts
+function isReference(obj) {
+  return typeof obj === "object" && obj !== null && "$ref" in obj;
+}
+function resolveRef(doc, ref) {
+  if (!ref.startsWith("#/")) {
+    return;
+  }
+  const path = ref.slice(2).split("/");
+  let current = doc;
+  for (const part of path) {
+    if (current === null || current === undefined)
+      return;
+    if (typeof current !== "object")
+      return;
+    current = current[part];
+  }
+  return current;
+}
+function dereferenceSchema(doc, schema, seen = new Set) {
+  if (!schema)
+    return;
+  if (isReference(schema)) {
+    if (seen.has(schema.$ref)) {
+      return schema;
+    }
+    const newSeen = new Set(seen);
+    newSeen.add(schema.$ref);
+    const resolved = resolveRef(doc, schema.$ref);
+    if (!resolved)
+      return schema;
+    const dereferenced = dereferenceSchema(doc, resolved, newSeen);
+    if (!dereferenced)
+      return schema;
+    const refParts = schema.$ref.split("/");
+    const typeName = refParts[refParts.length - 1];
+    return {
+      ...dereferenced,
+      _originalRef: schema.$ref,
+      _originalTypeName: typeName
+    };
+  }
+  const schemaObj = { ...schema };
+  if (schemaObj.properties) {
+    const props = schemaObj.properties;
+    const newProps = {};
+    for (const [key, prop] of Object.entries(props)) {
+      newProps[key] = dereferenceSchema(doc, prop, seen) ?? prop;
+    }
+    schemaObj.properties = newProps;
+  }
+  if (schemaObj.items) {
+    schemaObj.items = dereferenceSchema(doc, schemaObj.items, seen);
+  }
+  const combinators = ["allOf", "anyOf", "oneOf"];
+  for (const comb of combinators) {
+    if (Array.isArray(schemaObj[comb])) {
+      schemaObj[comb] = schemaObj[comb].map((s) => dereferenceSchema(doc, s, seen) ?? s);
+    }
+  }
+  return schemaObj;
+}
+// src/openapi/parser/parameters.ts
+function parseParameters(doc, params) {
+  const result = {
+    path: [],
+    query: [],
+    header: [],
+    cookie: []
+  };
+  if (!params)
+    return result;
+  for (const param of params) {
+    let resolved;
+    if (isReference(param)) {
+      const ref = resolveRef(doc, param.$ref);
+      if (!ref)
+        continue;
+      resolved = ref;
+    } else {
+      resolved = param;
+    }
+    const parsed = {
+      name: resolved.name,
+      in: resolved.in,
+      required: resolved.required ?? resolved.in === "path",
+      description: resolved.description,
+      schema: dereferenceSchema(doc, resolved.schema),
+      deprecated: resolved.deprecated ?? false
+    };
+    result[resolved.in]?.push(parsed);
+  }
+  return result;
+}
+// src/openapi/parser/operation.ts
+function parseOperation(doc, method, path, operation, pathParams) {
+  const allParams = [...pathParams ?? [], ...operation.parameters ?? []];
+  const params = parseParameters(doc, allParams);
+  let requestBody;
+  if (operation.requestBody) {
+    const body = isReference(operation.requestBody) ? resolveRef(doc, operation.requestBody.$ref) : operation.requestBody;
+    if (body) {
+      const contentType = Object.keys(body.content ?? {})[0] ?? "application/json";
+      const content = body.content?.[contentType];
+      if (content?.schema) {
+        requestBody = {
+          required: body.required ?? false,
+          schema: dereferenceSchema(doc, content.schema) ?? {},
+          contentType
+        };
+      }
+    }
+  }
+  const responses = {};
+  for (const [status, response] of Object.entries(operation.responses ?? {})) {
+    const resolved = isReference(response) ? resolveRef(doc, response.$ref) : response;
+    if (resolved) {
+      const contentType = Object.keys(resolved.content ?? {})[0];
+      const content = contentType ? resolved.content?.[contentType] : undefined;
+      responses[status] = {
+        description: resolved.description,
+        schema: content?.schema ? dereferenceSchema(doc, content.schema) : undefined,
+        contentType
+      };
+    }
+  }
+  const contractSpecMeta = operation?.["x-contractspec"];
+  return {
+    operationId: operation.operationId ?? generateOperationId(method, path),
+    method,
+    path,
+    summary: operation.summary,
+    description: operation.description,
+    tags: operation.tags ?? [],
+    pathParams: params.path,
+    queryParams: params.query,
+    headerParams: params.header,
+    cookieParams: params.cookie,
+    requestBody,
+    responses,
+    deprecated: operation.deprecated ?? false,
+    security: operation.security,
+    contractSpecMeta
+  };
+}
+// src/openapi/parser/document.ts
+function parseOpenApiDocument(doc, _options = {}) {
+  const version = detectVersion(doc);
+  const warnings = [];
+  const operations = [];
+  for (const [path, pathItem] of Object.entries(doc.paths ?? {})) {
+    if (!pathItem)
+      continue;
+    const pathParams = pathItem.parameters;
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (operation) {
+        try {
+          operations.push(parseOperation(doc, method, path, operation, pathParams));
+        } catch (error) {
+          warnings.push(`Failed to parse ${method.toUpperCase()} ${path}: ${error}`);
+        }
+      }
+    }
+  }
+  const schemas = {};
+  const components = doc.components;
+  if (components?.schemas) {
+    for (const [name, schema] of Object.entries(components.schemas)) {
+      schemas[name] = schema;
+    }
+  }
+  const servers = (doc.servers ?? []).map((s) => ({
+    url: s.url,
+    description: s.description,
+    variables: s.variables
+  }));
+  const events = [];
+  if ("webhooks" in doc && doc.webhooks) {
+    for (const [name, pathItem] of Object.entries(doc.webhooks)) {
+      if (typeof pathItem !== "object" || !pathItem)
+        continue;
+      const operation = pathItem["post"];
+      if (operation && operation.requestBody) {
+        if ("$ref" in operation.requestBody) {
+          throw new Error(`'$ref' isn't supported`);
+        }
+        const content = operation.requestBody.content?.["application/json"];
+        if (content?.schema) {
+          events.push({
+            name,
+            description: operation.summary || operation.description,
+            payload: content.schema
+          });
+        }
+      }
+    }
+  }
+  return {
+    document: doc,
+    version,
+    info: {
+      title: doc.info.title,
+      version: doc.info.version,
+      description: doc.info.description
+    },
+    operations,
+    schemas,
+    servers,
+    warnings,
+    events
+  };
+}
+async function parseOpenApi(source, options = {}) {
+  const {
+    fetch: fetchFn = globalThis.fetch,
+    readFile,
+    timeout = 30000
+  } = options;
+  let content;
+  let format;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetchFn(source, { signal: controller.signal });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      content = await response.text();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (source.endsWith(".yaml") || source.endsWith(".yml")) {
+      format = "yaml";
+    } else if (source.endsWith(".json")) {
+      format = "json";
+    } else {
+      format = detectFormat(content);
+    }
+  } else {
+    if (!readFile) {
+      throw new Error("readFile adapter required for file paths");
+    }
+    content = await readFile(source);
+    if (source.endsWith(".yaml") || source.endsWith(".yml")) {
+      format = "yaml";
+    } else if (source.endsWith(".json")) {
+      format = "json";
+    } else {
+      format = detectFormat(content);
+    }
+  }
+  const doc = parseOpenApiString(content, format);
+  return parseOpenApiDocument(doc, options);
+}
+// src/openapi/exporter/operations.ts
+import { z } from "zod";
+import { compareVersions } from "compare-versions";
+function toOperationId(name, version) {
+  return `${name.replace(/\./g, "_")}_v${version.replace(/\./g, "_")}`;
+}
+function toSchemaName(prefix, name, version) {
+  return `${prefix}_${toOperationId(name, version)}`;
+}
+function toHttpMethod(kind, override) {
+  const method = override ?? (kind === "query" ? "GET" : "POST");
+  return method.toLowerCase();
+}
+function defaultRestPath(name, version) {
+  return `/${name.replace(/\./g, "/")}/v${version}`;
+}
+function toRestPath(spec) {
+  const path = spec.transport?.rest?.path ?? defaultRestPath(spec.meta.key, spec.meta.version);
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function schemaModelToJsonSchema(schema) {
+  if (!schema)
+    return null;
+  return z.toJSONSchema(schema.getZod());
+}
+function jsonSchemaForSpec(spec) {
+  return {
+    input: schemaModelToJsonSchema(spec.io.input),
+    output: schemaModelToJsonSchema(spec.io.output),
+    meta: {
+      key: spec.meta.key,
+      version: spec.meta.version,
+      kind: spec.meta.kind,
+      description: spec.meta.description,
+      tags: spec.meta.tags ?? [],
+      stability: spec.meta.stability ?? "stable"
+    }
+  };
+}
+function exportOperations(registry) {
+  const specs = Array.from(registry.list().values()).filter((s) => s.meta.kind === "command" || s.meta.kind === "query").sort((a, b) => {
+    const byName = a.meta.key.localeCompare(b.meta.key);
+    return byName !== 0 ? byName : compareVersions(a.meta.version, b.meta.version);
+  });
+  const paths = {};
+  const 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 = 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);
+      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);
+      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 { paths, schemas };
+}
+function generateOperationsRegistry(registry) {
+  const specs = Array.from(registry.list().values());
+  const imports = new Set;
+  const registrations = [];
+  for (const spec of specs) {
+    const specVarName = spec.meta.key.replace(/\./g, "_") + `_v${spec.meta.version.replace(/\./g, "_")}`;
+    imports.add(`import { ${specVarName} } from './${spec.meta.key.split(".")[0]}';`);
+    registrations.push(`  .register(${specVarName})`);
+  }
+  const code = `/**
+ * Auto-generated operations registry.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+import { OperationSpecRegistry } from '@contractspec/lib.contracts';
+
+${Array.from(imports).join(`
+`)}
+
+export const operationsRegistry = new OperationSpecRegistry()
+${registrations.join(`
+`)};
+`;
+  return {
+    code,
+    fileName: "operations-registry.ts"
+  };
+}
+
+// src/openapi/exporter/events.ts
+import { z as z2 } from "zod";
+function exportEvents(events) {
+  return events.map((event) => ({
+    name: event.meta.key,
+    version: event.meta.version,
+    description: event.meta.description,
+    payload: event.payload ? z2.toJSONSchema(event.payload.getZod()) : null,
+    pii: event.pii
+  }));
+}
+function generateEventsExports(events) {
+  const eventExports = [];
+  for (const event of events) {
+    const eventVarName = event.meta.key.replace(/\./g, "_") + `_v${event.meta.version}`;
+    eventExports.push(`export { ${eventVarName} } from './${event.meta.key.split(".")[0]}';`);
+  }
+  const code = `/**
+ * Auto-generated events exports.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+
+${eventExports.join(`
+`)}
+`;
+  return {
+    code,
+    fileName: "events-exports.ts"
+  };
+}
+
+// src/openapi/exporter/features.ts
+function exportFeatures(registry) {
+  return registry.list().map((feature) => ({
+    key: feature.meta.key,
+    description: feature.meta.description,
+    owners: feature.meta.owners,
+    stability: feature.meta.stability,
+    operations: feature.operations,
+    events: feature.events,
+    presentations: feature.presentations
+  }));
+}
+function generateFeaturesRegistry(registry) {
+  const features = registry.list();
+  const imports = new Set;
+  const registrations = [];
+  for (const feature of features) {
+    const featureVarName = feature.meta.key.replace(/-/g, "_");
+    imports.add(`import { ${featureVarName} } from './${feature.meta.key}';`);
+    registrations.push(`  .register(${featureVarName})`);
+  }
+  const code = `/**
+ * Auto-generated features registry.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+import { FeatureRegistry } from '@contractspec/lib.contracts';
+
+${Array.from(imports).join(`
+`)}
+
+export const featuresRegistry = new FeatureRegistry()
+${registrations.join(`
+`)};
+`;
+  return {
+    code,
+    fileName: "features-registry.ts"
+  };
+}
+
+// src/openapi/exporter/presentations.ts
+function exportPresentations(registry) {
+  return registry.list().map((pres) => ({
+    name: pres.meta.key,
+    version: pres.meta.version,
+    description: pres.meta.description,
+    stability: pres.meta.stability,
+    sourceType: pres.source.type,
+    targets: pres.targets,
+    tags: pres.meta.tags
+  }));
+}
+function exportPresentationsFromArray(descriptors) {
+  return descriptors.map((desc) => ({
+    name: desc.meta.key,
+    version: desc.meta.version,
+    description: desc.meta.description,
+    stability: desc.meta.stability,
+    sourceType: desc.source.type,
+    targets: desc.targets,
+    tags: desc.meta.tags
+  }));
+}
+function generatePresentationsRegistry(registry) {
+  const presentations = registry.list();
+  const imports = new Set;
+  const registrations = [];
+  for (const pres of presentations) {
+    const presVarName = pres.meta.key.replace(/\./g, "_") + `_v${pres.meta.version}`;
+    imports.add(`import { ${presVarName} } from './${pres.meta.key.split(".")[0]}';`);
+    registrations.push(`  .register(${presVarName})`);
+  }
+  const code = `/**
+ * Auto-generated presentations registry.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+import { PresentationRegistry } from '@contractspec/lib.contracts';
+
+${Array.from(imports).join(`
+`)}
+
+export const presentationsRegistry = new PresentationRegistry()
+${registrations.join(`
+`)};
+`;
+  return {
+    code,
+    fileName: "presentations-registry.ts"
+  };
+}
+
+// src/openapi/exporter/forms.ts
+import { z as z3 } from "zod";
+function exportForms(registry) {
+  return registry.list().map((form) => ({
+    key: form.meta.key,
+    version: form.meta.version,
+    description: form.meta.description,
+    stability: form.meta.stability,
+    owners: form.meta.owners,
+    fields: form.fields,
+    model: form.model ? z3.toJSONSchema(form.model.getZod()) : null,
+    actions: form.actions
+  }));
+}
+function generateFormsRegistry(registry) {
+  const forms = registry.list();
+  const imports = new Set;
+  const registrations = [];
+  for (const form of forms) {
+    const formVarName = form.meta.key.replace(/-/g, "_") + `_v${form.meta.version}`;
+    imports.add(`import { ${formVarName} } from './${form.meta.key}';`);
+    registrations.push(`  .register(${formVarName})`);
+  }
+  const code = `/**
+ * Auto-generated forms registry.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+import { FormRegistry } from '@contractspec/lib.contracts';
+
+${Array.from(imports).join(`
+`)}
+
+export const formsRegistry = new FormRegistry()
+${registrations.join(`
+`)};
+`;
+  return {
+    code,
+    fileName: "forms-registry.ts"
+  };
+}
+
+// src/openapi/exporter/data-views.ts
+function exportDataViews(registry) {
+  return registry.list().map((dv) => ({
+    name: dv.meta.key,
+    version: dv.meta.version,
+    description: dv.meta.description,
+    stability: dv.meta.stability,
+    entity: dv.meta.entity,
+    kind: dv.view.kind,
+    source: dv.source,
+    fields: dv.view.fields
+  }));
+}
+function generateDataViewsRegistry(registry) {
+  const dataViews = registry.list();
+  const imports = new Set;
+  const registrations = [];
+  for (const dv of dataViews) {
+    const dvVarName = dv.meta.key.replace(/\./g, "_") + `_v${dv.meta.version}`;
+    imports.add(`import { ${dvVarName} } from './${dv.meta.key.split(".")[0]}';`);
+    registrations.push(`  .register(${dvVarName})`);
+  }
+  const code = `/**
+ * Auto-generated data views registry.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+import { DataViewRegistry } from '@contractspec/lib.contracts';
+
+${Array.from(imports).join(`
+`)}
+
+export const dataViewsRegistry = new DataViewRegistry()
+${registrations.join(`
+`)};
+`;
+  return {
+    code,
+    fileName: "dataviews-registry.ts"
+  };
+}
+
+// src/openapi/exporter/workflows.ts
+function exportWorkflows(registry) {
+  return registry.list().map((wf) => ({
+    name: wf.meta.key,
+    version: wf.meta.version,
+    description: wf.meta.description,
+    stability: wf.meta.stability,
+    owners: wf.meta.owners,
+    steps: wf.definition.steps.map((s) => ({
+      id: s.id,
+      type: s.type,
+      label: s.label
+    })),
+    transitions: wf.definition.transitions.map((t) => ({
+      from: t.from,
+      to: t.to,
+      label: t.label
+    }))
+  }));
+}
+function generateWorkflowsRegistry(registry) {
+  const workflows = registry.list();
+  const imports = new Set;
+  const registrations = [];
+  for (const wf of workflows) {
+    const wfVarName = wf.meta.key.replace(/\./g, "_") + `_v${wf.meta.version}`;
+    imports.add(`import { ${wfVarName} } from './${wf.meta.key.split(".")[0]}';`);
+    registrations.push(`  .register(${wfVarName})`);
+  }
+  const code = `/**
+ * Auto-generated workflows registry.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+import { WorkflowRegistry } from '@contractspec/lib.contracts';
+
+${Array.from(imports).join(`
+`)}
+
+export const workflowsRegistry = new WorkflowRegistry()
+${registrations.join(`
+`)};
+`;
+  return {
+    code,
+    fileName: "workflows-registry.ts"
+  };
+}
+
+// src/openapi/exporter/registries.ts
+function generateRegistryIndex(options = {}) {
+  const {
+    operations = true,
+    events = true,
+    features = true,
+    presentations = true,
+    forms = true,
+    dataViews = true,
+    workflows = true
+  } = options;
+  const exports = [];
+  if (operations) {
+    exports.push("export * from './operations-registry';");
+  }
+  if (events) {
+    exports.push("export * from './events-exports';");
+  }
+  if (features) {
+    exports.push("export * from './features-registry';");
+  }
+  if (presentations) {
+    exports.push("export * from './presentations-registry';");
+  }
+  if (forms) {
+    exports.push("export * from './forms-registry';");
+  }
+  if (dataViews) {
+    exports.push("export * from './dataviews-registry';");
+  }
+  if (workflows) {
+    exports.push("export * from './workflows-registry';");
+  }
+  const code = `/**
+ * Auto-generated registry index.
+ * DO NOT EDIT - This file is generated by ContractSpec exporter.
+ */
+
+${exports.join(`
+`)}
+`;
+  return {
+    code,
+    fileName: "index.ts"
+  };
+}
+
+// src/openapi/exporter.ts
+function openApiForRegistry(registry, options = {}) {
+  const { paths, schemas } = exportOperations(registry);
+  return {
+    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 }
+  };
+}
+function exportContractSpec(registries, options = {}) {
+  const {
+    operations: includeOps = true,
+    events: includeEvents = true,
+    features: includeFeatures = true,
+    presentations: includePresentations = true,
+    forms: includeForms = true,
+    dataViews: includeDataViews = true,
+    workflows: includeWorkflows = true,
+    generateRegistries = true
+  } = options;
+  let paths = {};
+  let schemas = {};
+  if (includeOps && registries.operations) {
+    const opResult = exportOperations(registries.operations);
+    paths = opResult.paths;
+    schemas = opResult.schemas;
+  }
+  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 }
+  };
+  if (includeEvents && registries.events?.length) {
+    doc["x-contractspec-events"] = exportEvents(registries.events);
+  }
+  if (includeFeatures && registries.features) {
+    doc["x-contractspec-features"] = exportFeatures(registries.features);
+  }
+  if (includePresentations && registries.presentations) {
+    doc["x-contractspec-presentations"] = exportPresentations(registries.presentations);
+  }
+  if (includeForms && registries.forms) {
+    doc["x-contractspec-forms"] = exportForms(registries.forms);
+  }
+  if (includeDataViews && registries.dataViews) {
+    doc["x-contractspec-dataviews"] = exportDataViews(registries.dataViews);
+  }
+  if (includeWorkflows && registries.workflows) {
+    doc["x-contractspec-workflows"] = exportWorkflows(registries.workflows);
+  }
+  const result = {
+    openApi: doc
+  };
+  if (generateRegistries) {
+    result.registries = {};
+    if (includeOps && registries.operations) {
+      result.registries.operations = generateOperationsRegistry(registries.operations);
+    }
+    if (includeEvents && registries.events?.length) {
+      result.registries.events = generateEventsExports(registries.events);
+    }
+    if (includeFeatures && registries.features) {
+      result.registries.features = generateFeaturesRegistry(registries.features);
+    }
+    if (includePresentations && registries.presentations) {
+      result.registries.presentations = generatePresentationsRegistry(registries.presentations);
+    }
+    if (includeForms && registries.forms) {
+      result.registries.forms = generateFormsRegistry(registries.forms);
+    }
+    if (includeDataViews && registries.dataViews) {
+      result.registries.dataViews = generateDataViewsRegistry(registries.dataViews);
+    }
+    if (includeWorkflows && registries.workflows) {
+      result.registries.workflows = generateWorkflowsRegistry(registries.workflows);
+    }
+    result.registries.index = generateRegistryIndex({
+      operations: includeOps && !!registries.operations,
+      events: includeEvents && !!registries.events?.length,
+      features: includeFeatures && !!registries.features,
+      presentations: includePresentations && !!registries.presentations,
+      forms: includeForms && !!registries.forms,
+      dataViews: includeDataViews && !!registries.dataViews,
+      workflows: includeWorkflows && !!registries.workflows
+    });
+  }
+  return result;
+}
+function openApiToJson(registry, options = {}) {
+  const doc = openApiForRegistry(registry, options);
+  return JSON.stringify(doc, null, 2);
+}
+function openApiToYaml(registry, options = {}) {
+  const doc = openApiForRegistry(registry, options);
+  return jsonToYaml(doc);
+}
+function contractSpecToJson(registries, options = {}) {
+  const result = exportContractSpec(registries, options);
+  return JSON.stringify(result.openApi, null, 2);
+}
+function contractSpecToYaml(registries, options = {}) {
+  const result = exportContractSpec(registries, options);
+  return jsonToYaml(result.openApi);
+}
+function jsonToYaml(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  let yaml = "";
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (typeof item === "object" && item !== null) {
+        yaml += `${spaces}-
+${jsonToYaml(item, indent + 1)}`;
+      } else {
+        yaml += `${spaces}- ${JSON.stringify(item)}
+`;
+      }
+    }
+  } else if (typeof obj === "object" && obj !== null) {
+    for (const [key, value] of Object.entries(obj)) {
+      if (Array.isArray(value)) {
+        yaml += `${spaces}${key}:
+${jsonToYaml(value, indent + 1)}`;
+      } else if (typeof value === "object" && value !== null) {
+        yaml += `${spaces}${key}:
+${jsonToYaml(value, indent + 1)}`;
+      } else {
+        yaml += `${spaces}${key}: ${JSON.stringify(value)}
+`;
+      }
+    }
+  }
+  return yaml;
+}
+// src/openapi/schema-generators/index.ts
+var JSON_SCHEMA_TO_SCALAR = {
+  string: "ScalarTypeEnum.String_unsecure",
+  integer: "ScalarTypeEnum.Int_unsecure",
+  number: "ScalarTypeEnum.Float_unsecure",
+  boolean: "ScalarTypeEnum.Boolean",
+  "string:date": "ScalarTypeEnum.Date",
+  "string:date-time": "ScalarTypeEnum.DateTime",
+  "string:email": "ScalarTypeEnum.EmailAddress",
+  "string:uri": "ScalarTypeEnum.URL",
+  "string:uuid": "ScalarTypeEnum.ID"
+};
+function isReference2(schema) {
+  return typeof schema === "object" && schema !== null && "$ref" in schema;
+}
+function typeNameFromRef(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] ?? "Unknown";
+}
+function createSchemaGenerator(format, config) {
+  switch (format) {
+    case "zod":
+      return new ZodSchemaGenerator(config);
+    case "json-schema":
+      return new JsonSchemaGenerator(config);
+    case "graphql":
+      return new GraphQLSchemaGenerator(config);
+    case "contractspec":
+    default:
+      return new ContractSpecSchemaGenerator(config);
+  }
+}
+
+class ContractSpecSchemaGenerator {
+  format = "contractspec";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  generateModel(schema, name) {
+    const model = this.generateContractSpecSchema(schema, name);
+    const dependencyImports = this.config ? generateImports(model.fields, this.config, false).split(`
+`).filter(Boolean) : [];
+    return {
+      code: model.code,
+      fileName: toKebabCase(name) + ".ts",
+      imports: [...this.getBaseImports(), ...dependencyImports],
+      name: model.name
+    };
+  }
+  generateField(schema, fieldName, required) {
+    const field = this.convertField(schema, fieldName, required);
+    return {
+      code: field.scalarType ? `${field.scalarType}()` : "ScalarTypeEnum.String_unsecure()",
+      typeRef: field.type.type,
+      isOptional: field.type.optional,
+      isArray: field.type.array
+    };
+  }
+  getBaseImports() {
+    return [
+      "import { defineSchemaModel, ScalarTypeEnum, EnumType } from '@contractspec/lib.schema';"
+    ];
+  }
+  generateContractSpecSchema(schema, modelName, indent = 0) {
+    const spaces = "  ".repeat(indent);
+    const fields = [];
+    if (isReference2(schema)) {
+      return {
+        name: toPascalCase(typeNameFromRef(schema.$ref)),
+        fields: [],
+        code: `// Reference to ${schema.$ref}`
+      };
+    }
+    const schemaObj = schema;
+    const description = schemaObj["description"];
+    const properties = schemaObj["properties"];
+    const required = schemaObj["required"] ?? [];
+    const enumValues = schemaObj["enum"];
+    if (enumValues && enumValues.length > 0) {
+      const safeModelName2 = toPascalCase(toValidIdentifier(modelName));
+      const enumCode = [
+        `${spaces}/**`,
+        `${spaces} * Enum type: ${safeModelName2}`,
+        description ? `${spaces} * ${description}` : null,
+        `${spaces} */`,
+        `${spaces}export const ${safeModelName2} = new EnumType('${safeModelName2}', [${enumValues.map((v) => `'${String(v)}'`).join(", ")}]);`
+      ].filter((line) => line !== null).join(`
+`);
+      return {
+        name: safeModelName2,
+        description,
+        fields: [],
+        code: enumCode
+      };
+    }
+    const schemaType = schemaObj["type"];
+    if (schemaType && !properties && !enumValues) {
+      const safeModelName2 = toPascalCase(toValidIdentifier(modelName));
+      const format = schemaObj["format"];
+      const scalarKey = format ? `${schemaType}:${format}` : schemaType;
+      const scalarType = JSON_SCHEMA_TO_SCALAR[scalarKey] ?? JSON_SCHEMA_TO_SCALAR[schemaType];
+      if (scalarType) {
+        const aliasCode = [
+          `${spaces}/**`,
+          `${spaces} * Type alias: ${safeModelName2}`,
+          description ? `${spaces} * ${description}` : null,
+          `${spaces} * Underlying type: ${scalarType}`,
+          `${spaces} */`,
+          `${spaces}export const ${safeModelName2} = defineSchemaModel({`,
+          `${spaces}  name: '${safeModelName2}',`,
+          description ? `${spaces}  description: ${JSON.stringify(description)},` : null,
+          `${spaces}  fields: {`,
+          `${spaces}    value: {`,
+          `${spaces}      type: ${scalarType}(),`,
+          `${spaces}      isOptional: false,`,
+          `${spaces}    },`,
+          `${spaces}  },`,
+          `${spaces}});`
+        ].filter((line) => line !== null).join(`
+`);
+        return {
+          name: safeModelName2,
+          description,
+          fields: [],
+          code: aliasCode
+        };
+      }
+    }
+    const additionalProperties = schemaObj["additionalProperties"];
+    if (additionalProperties && !properties) {
+      const safeModelName2 = toPascalCase(toValidIdentifier(modelName));
+      const dictCode = [
+        `${spaces}/**`,
+        `${spaces} * Dictionary/Record type: ${safeModelName2}`,
+        description ? `${spaces} * ${description}` : null,
+        `${spaces} * Use as: Record<string, unknown> - access via record[key]`,
+        `${spaces} */`,
+        `${spaces}export const ${safeModelName2} = ScalarTypeEnum.JSONObject();`
+      ].filter((line) => line !== null).join(`
+`);
+      return {
+        name: safeModelName2,
+        description,
+        fields: [],
+        code: dictCode
+      };
+    }
+    if (!properties) {
+      const safeModelName2 = toPascalCase(toValidIdentifier(modelName));
+      const emptyModelCode = [
+        `${spaces}export const ${safeModelName2} = defineSchemaModel({`,
+        `${spaces}  name: '${safeModelName2}',`,
+        description ? `${spaces}  description: ${JSON.stringify(description)},` : null,
+        `${spaces}  fields: {},`,
+        `${spaces}});`
+      ].filter((line) => line !== null).join(`
+`);
+      return {
+        name: safeModelName2,
+        description,
+        fields: [],
+        code: emptyModelCode
+      };
+    }
+    const safeModelName = toPascalCase(toValidIdentifier(modelName));
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.includes(propName);
+      fields.push(this.convertField(propSchema, propName, isRequired, safeModelName));
+    }
+    const lines = [];
+    for (const field of fields) {
+      if (field.nestedModel) {
+        lines.push(field.nestedModel.code);
+        lines.push("");
+      }
+    }
+    lines.push(`${spaces}export const ${safeModelName} = defineSchemaModel({`);
+    lines.push(`${spaces}  name: '${safeModelName}',`);
+    if (description) {
+      lines.push(`${spaces}  description: ${JSON.stringify(description)},`);
+    }
+    lines.push(`${spaces}  fields: {`);
+    for (const field of fields) {
+      const fieldLines = this.generateFieldCodeHelper(field, indent + 2);
+      lines.push(fieldLines);
+    }
+    lines.push(`${spaces}  },`);
+    lines.push(`${spaces}});`);
+    return {
+      name: safeModelName,
+      description,
+      fields,
+      code: lines.join(`
+`),
+      imports: []
+    };
+  }
+  convertField(schema, fieldName, required, parentName) {
+    const type = jsonSchemaToType(schema, fieldName);
+    const scalarType = getScalarType(schema);
+    let enumValues;
+    let nestedModel;
+    if (!isReference2(schema)) {
+      const schemaObj = schema;
+      const enumArr = schemaObj["enum"];
+      if (enumArr) {
+        enumValues = enumArr.map(String);
+      }
+      if (schemaObj["type"] === "object" && !scalarType && schemaObj["properties"] && !enumValues) {
+        const nestedName = (parentName ? parentName : "") + toPascalCase(fieldName);
+        nestedModel = this.generateContractSpecSchema(schema, nestedName);
+        type.type = nestedModel.name;
+        type.isReference = true;
+      }
+    }
+    return {
+      name: fieldName,
+      type: {
+        ...type,
+        optional: !required || type.optional,
+        description: !isReference2(schema) ? schema["description"] : undefined
+      },
+      scalarType,
+      enumValues,
+      nestedModel
+    };
+  }
+  generateFieldCodeHelper(field, indent) {
+    const spaces = "  ".repeat(indent);
+    const lines = [];
+    const isIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(field.name);
+    const safeKey = isIdentifier ? field.name : `'${field.name}'`;
+    lines.push(`${spaces}${safeKey}: {`);
+    if (field.enumValues) {
+      const enumName = toPascalCase(field.name) + "Enum";
+      lines.push(`${spaces}  type: new EnumType('${enumName}', [${field.enumValues.map((v) => `'${v}'`).join(", ")}]),`);
+    } else if (field.scalarType) {
+      lines.push(`${spaces}  type: ${field.scalarType}(),`);
+    } else if (field.nestedModel) {
+      lines.push(`${spaces}  type: ${field.nestedModel.name},`);
+    } else if (field.type.primitive) {
+      const fallbackScalar = field.type.type === "number" ? "ScalarTypeEnum.Float_unsecure" : field.type.type === "boolean" ? "ScalarTypeEnum.Boolean_unsecure" : "ScalarTypeEnum.String_unsecure";
+      lines.push(`${spaces}  type: ${fallbackScalar}(),`);
+    } else if (field.type.isReference) {
+      lines.push(`${spaces}  type: ${field.type.type},`);
+    } else {
+      lines.push(`${spaces}  type: ScalarTypeEnum.JSONObject(), // TODO: Define nested model for ${field.type.type}`);
+    }
+    lines.push(`${spaces}  isOptional: ${field.type.optional},`);
+    if (field.type.array) {
+      lines.push(`${spaces}  isArray: true,`);
+    }
+    lines.push(`${spaces}},`);
+    return lines.join(`
+`);
+  }
+}
+
+class ZodSchemaGenerator {
+  format = "zod";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  generateModel(schema, name, options) {
+    const schemaObj = schema;
+    const properties = schemaObj["properties"];
+    const _required = schemaObj["required"] ?? [];
+    const description = options?.description ?? schemaObj["description"];
+    const lines = [];
+    if (description) {
+      lines.push(`/**`);
+      lines.push(` * ${description}`);
+      lines.push(` */`);
+    }
+    const schemaName = `${name}Schema`;
+    let schemaCode;
+    if (properties) {
+      schemaCode = this.generateZodObject(schemaObj);
+    } else {
+      schemaCode = "z.object({})";
+    }
+    lines.push(`export const ${schemaName} = ${schemaCode};`);
+    lines.push(``);
+    lines.push(`export const ${name} = new ZodSchemaType(${schemaName}, { name: '${name}', description: ${JSON.stringify(description)} });`);
+    lines.push(``);
+    lines.push(`export type ${name} = z.infer<typeof ${schemaName}>;`);
+    return {
+      code: lines.join(`
+`),
+      fileName: toKebabCase(name) + ".ts",
+      imports: this.getBaseImports(),
+      name
+    };
+  }
+  generateField(schema, _fieldName, required) {
+    const schemaObj = schema;
+    const type = schemaObj["type"];
+    const format = schemaObj["format"];
+    const nullable = schemaObj["nullable"];
+    let zodType;
+    if (type === "object" && schemaObj["properties"]) {
+      zodType = this.generateZodObject(schemaObj);
+    } else {
+      zodType = this.mapTypeToZod(type, format);
+      if (schemaObj["enum"]) {
+        const enumValues = schemaObj["enum"];
+        zodType = `z.enum([${enumValues.map((v) => `'${v}'`).join(", ")}])`;
+      }
+      if (type === "array") {
+        const items = schemaObj["items"];
+        if (items) {
+          const itemField = this.generateField(items, "item", true);
+          zodType = `z.array(${itemField.code.replace(".optional()", "")})`;
+        } else {
+          zodType = "z.array(z.unknown())";
+        }
+      }
+    }
+    if (type === "string") {
+      if (schemaObj["minLength"] !== undefined)
+        zodType += `.min(${schemaObj["minLength"]})`;
+      if (schemaObj["maxLength"] !== undefined)
+        zodType += `.max(${schemaObj["maxLength"]})`;
+      if (schemaObj["pattern"] !== undefined)
+        zodType += `.regex(/${schemaObj["pattern"]}/)`;
+    } else if (type === "integer" || type === "number") {
+      if (schemaObj["minimum"] !== undefined) {
+        zodType += schemaObj["exclusiveMinimum"] === true ? `.gt(${schemaObj["minimum"]})` : `.min(${schemaObj["minimum"]})`;
+      } else if (typeof schemaObj["exclusiveMinimum"] === "number") {
+        zodType += `.gt(${schemaObj["exclusiveMinimum"]})`;
+      }
+      if (schemaObj["maximum"] !== undefined) {
+        zodType += schemaObj["exclusiveMaximum"] === true ? `.lt(${schemaObj["maximum"]})` : `.max(${schemaObj["maximum"]})`;
+      } else if (typeof schemaObj["exclusiveMaximum"] === "number") {
+        zodType += `.lt(${schemaObj["exclusiveMaximum"]})`;
+      }
+      if (schemaObj["multipleOf"] !== undefined) {
+        zodType += `.step(${schemaObj["multipleOf"]})`;
+      }
+    } else if (type === "array") {
+      if (schemaObj["minItems"] !== undefined)
+        zodType += `.min(${schemaObj["minItems"]})`;
+      if (schemaObj["maxItems"] !== undefined)
+        zodType += `.max(${schemaObj["maxItems"]})`;
+    }
+    if (schemaObj["default"] !== undefined) {
+      zodType += `.default(${JSON.stringify(schemaObj["default"])})`;
+    }
+    if (!required || nullable) {
+      zodType = `${zodType}.optional()`;
+    }
+    return {
+      code: zodType,
+      typeRef: type ?? "unknown",
+      isOptional: !required || Boolean(nullable),
+      isArray: type === "array"
+    };
+  }
+  getBaseImports() {
+    return [
+      "import * as z from 'zod';",
+      "import { ZodSchemaType } from '@contractspec/lib.schema';"
+    ];
+  }
+  generateZodObject(schemaObj) {
+    const required = schemaObj["required"] ?? [];
+    const properties = schemaObj["properties"];
+    const lines = ["z.object({"];
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = required.includes(propName);
+      const field = this.generateField(propSchema, propName, isRequired);
+      const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName) ? propName : `'${propName}'`;
+      lines.push(`  ${safeName}: ${field.code},`);
+    }
+    lines.push("})");
+    return lines.join(`
+`);
+  }
+  mapTypeToZod(type, format) {
+    if (format === "date-time")
+      return "z.string().datetime()";
+    if (format === "date")
+      return "z.string().date()";
+    if (format === "email")
+      return "z.string().email()";
+    if (format === "uri" || format === "url")
+      return "z.string().url()";
+    if (format === "uuid")
+      return "z.string().uuid()";
+    switch (type) {
+      case "string":
+        return "z.string()";
+      case "integer":
+        return "z.number().int()";
+      case "number":
+        return "z.number()";
+      case "boolean":
+        return "z.boolean()";
+      case "object":
+        return "z.record(z.string(), z.unknown())";
+      case "null":
+        return "z.null()";
+      default:
+        return "z.unknown()";
+    }
+  }
+}
+
+class JsonSchemaGenerator {
+  format = "json-schema";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  generateModel(schema, name, options) {
+    const schemaObj = schema;
+    const description = options?.description ?? schemaObj["description"];
+    const jsonSchema = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      title: name,
+      ...schemaObj
+    };
+    if (description) {
+      jsonSchema["description"] = description;
+    }
+    const lines = [];
+    lines.push(`/**`);
+    lines.push(` * JSON Schema: ${name}`);
+    if (description) {
+      lines.push(` * ${description}`);
+    }
+    lines.push(` */`);
+    const schemaName = `${name}Schema`;
+    lines.push(`export const ${schemaName} = ${JSON.stringify(jsonSchema, null, 2)} as const;`);
+    lines.push(``);
+    lines.push(`export const ${name} = new JsonSchemaType(${schemaName});`);
+    lines.push(``);
+    lines.push(`export type ${name} = unknown; // JSON Schema type inference not fully supported`);
+    return {
+      code: lines.join(`
+`),
+      fileName: toKebabCase(name) + ".ts",
+      imports: this.getBaseImports(),
+      name
+    };
+  }
+  generateField(schema, _fieldName, required) {
+    const schemaObj = schema;
+    const type = schemaObj["type"];
+    const nullable = schemaObj["nullable"];
+    return {
+      code: JSON.stringify(schemaObj),
+      typeRef: type ?? "unknown",
+      isOptional: !required || Boolean(nullable),
+      isArray: type === "array"
+    };
+  }
+  getBaseImports() {
+    return ["import { JsonSchemaType } from '@contractspec/lib.schema';"];
+  }
+}
+
+class GraphQLSchemaGenerator {
+  format = "graphql";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  generateModel(schema, name, options) {
+    const schemaObj = schema;
+    const properties = schemaObj["properties"];
+    const required = schemaObj["required"] ?? [];
+    const description = options?.description ?? schemaObj["description"];
+    const lines = [];
+    if (description) {
+      lines.push(`"""${description}"""`);
+    }
+    lines.push(`type ${name} {`);
+    if (properties) {
+      for (const [propName, propSchema] of Object.entries(properties)) {
+        const isRequired = required.includes(propName);
+        const field = this.generateField(propSchema, propName, isRequired);
+        const nullMarker = isRequired ? "!" : "";
+        lines.push(`  ${propName}: ${field.typeRef}${nullMarker}`);
+      }
+    }
+    lines.push(`}`);
+    const sdl = lines.join(`
+`);
+    const tsLines = [];
+    tsLines.push(`/**`);
+    tsLines.push(` * GraphQL type definition: ${name}`);
+    tsLines.push(` */`);
+    tsLines.push(`export const ${name}TypeDef = \`${sdl}\`;`);
+    tsLines.push(``);
+    tsLines.push(`export const ${name} = new GraphQLSchemaType(${name}TypeDef, '${name}');`);
+    return {
+      code: tsLines.join(`
+`),
+      fileName: toKebabCase(name) + ".ts",
+      imports: this.getBaseImports(),
+      name
+    };
+  }
+  generateField(schema, _fieldName, required) {
+    const schemaObj = schema;
+    const type = schemaObj["type"];
+    const format = schemaObj["format"];
+    const nullable = schemaObj["nullable"];
+    const gqlType = this.mapTypeToGraphQL(type, format);
+    return {
+      code: gqlType,
+      typeRef: gqlType,
+      isOptional: !required || Boolean(nullable),
+      isArray: type === "array"
+    };
+  }
+  getBaseImports() {
+    return ["import { GraphQLSchemaType } from '@contractspec/lib.schema';"];
+  }
+  mapTypeToGraphQL(type, format) {
+    if (format === "date-time")
+      return "DateTime";
+    if (format === "date")
+      return "Date";
+    if (format === "email")
+      return "String";
+    if (format === "uri" || format === "url")
+      return "String";
+    if (format === "uuid")
+      return "ID";
+    switch (type) {
+      case "string":
+        return "String";
+      case "integer":
+        return "Int";
+      case "number":
+        return "Float";
+      case "boolean":
+        return "Boolean";
+      case "object":
+        return "JSON";
+      case "array":
+        return "[JSON]";
+      default:
+        return "JSON";
+    }
+  }
+}
+
+// src/openapi/schema-converter.ts
+var JSON_SCHEMA_TO_SCALAR2 = {
+  string: "ScalarTypeEnum.String_unsecure",
+  integer: "ScalarTypeEnum.Int_unsecure",
+  number: "ScalarTypeEnum.Float_unsecure",
+  boolean: "ScalarTypeEnum.Boolean",
+  "string:date": "ScalarTypeEnum.Date",
+  "string:date-time": "ScalarTypeEnum.DateTime",
+  "string:email": "ScalarTypeEnum.EmailAddress",
+  "string:uri": "ScalarTypeEnum.URL",
+  "string:uuid": "ScalarTypeEnum.ID"
+};
+function isReference3(schema) {
+  return typeof schema === "object" && schema !== null && "$ref" in schema;
+}
+function typeNameFromRef2(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] ?? "Unknown";
+}
+function jsonSchemaToType(schema, name) {
+  if (isReference3(schema)) {
+    return {
+      type: toPascalCase(typeNameFromRef2(schema.$ref)),
+      optional: false,
+      array: false,
+      primitive: false,
+      isReference: true
+    };
+  }
+  const schemaObj = schema;
+  const type = schemaObj["type"];
+  const format = schemaObj["format"];
+  const nullable = schemaObj["nullable"];
+  const originalTypeName = schemaObj["_originalTypeName"];
+  if (originalTypeName) {
+    return {
+      type: toPascalCase(originalTypeName),
+      optional: nullable ?? false,
+      array: false,
+      primitive: false,
+      isReference: true
+    };
+  }
+  if (type === "array") {
+    const items = schemaObj["items"];
+    if (items) {
+      const itemType = jsonSchemaToType(items, name);
+      return {
+        ...itemType,
+        array: true,
+        optional: nullable ?? false
+      };
+    }
+    return {
+      type: "unknown",
+      optional: nullable ?? false,
+      array: true,
+      primitive: false,
+      isReference: true
+    };
+  }
+  if (type === "object" || schemaObj["properties"]) {
+    return {
+      type: name ? toPascalCase(name) : "Record<string, unknown>",
+      optional: nullable ?? false,
+      array: false,
+      primitive: false,
+      isReference: true
+    };
+  }
+  if (schemaObj["enum"]) {
+    return {
+      type: name ? toPascalCase(name) : "string",
+      optional: nullable ?? false,
+      array: false,
+      primitive: false,
+      isReference: true
+    };
+  }
+  const scalarKey = format ? `${type}:${format}` : type;
+  if (scalarKey === "string") {
+    return {
+      type: "string",
+      optional: nullable ?? false,
+      array: false,
+      primitive: true
+    };
+  }
+  if (scalarKey === "integer" || type === "number") {
+    return {
+      type: "number",
+      optional: nullable ?? false,
+      array: false,
+      primitive: true
+    };
+  }
+  if (scalarKey === "boolean") {
+    return {
+      type: "boolean",
+      optional: nullable ?? false,
+      array: false,
+      primitive: true
+    };
+  }
+  return {
+    type: "unknown",
+    optional: nullable ?? false,
+    array: false,
+    primitive: false,
+    isReference: true
+  };
+}
+function getScalarType(schema) {
+  if (isReference3(schema)) {
+    return;
+  }
+  const schemaObj = schema;
+  const type = schemaObj["type"];
+  const format = schemaObj["format"];
+  if (!type)
+    return;
+  if (type === "array") {
+    const items = schemaObj["items"];
+    if (items) {
+      return getScalarType(items);
+    }
+    return;
+  }
+  const key = format ? `${type}:${format}` : type;
+  return JSON_SCHEMA_TO_SCALAR2[key] ?? JSON_SCHEMA_TO_SCALAR2[type] ?? undefined;
+}
+function generateSchemaModelCode(schema, modelName, schemaFormat = "contractspec", config) {
+  const generator = createSchemaGenerator(schemaFormat, config);
+  const result = generator.generateModel(schema, modelName, {
+    description: schema["description"]
+  });
+  return {
+    name: result.name,
+    description: schema["description"],
+    fields: [],
+    code: result.code,
+    imports: result.imports
+  };
+}
+function generateImports(fields, options, sameDirectory = true) {
+  const imports = new Set;
+  const modelsDir = sameDirectory ? "." : `../${options.conventions.models}`;
+  imports.add("import { defineSchemaModel, ScalarTypeEnum, EnumType } from '@contractspec/lib.schema';");
+  for (const field of fields) {
+    if (field.type.isReference && !field.type.primitive && !field.enumValues && !field.scalarType && !field.nestedModel) {
+      const modelName = field.type.type;
+      const kebabName = modelName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      imports.add(`import { ${modelName} } from '${modelsDir}/${kebabName}';`);
+    }
+  }
+  return Array.from(imports).join(`
+`);
+}
+
+// src/openapi/importer/schemas.ts
+function buildInputSchemas(operation2) {
+  const result = {};
+  if (operation2.pathParams.length > 0) {
+    result.params = {
+      type: "object",
+      properties: operation2.pathParams.reduce((acc, p) => {
+        acc[p.name] = p.schema;
+        return acc;
+      }, {}),
+      required: operation2.pathParams.map((p) => p.name)
+    };
+  }
+  if (operation2.queryParams.length > 0) {
+    result.query = {
+      type: "object",
+      properties: operation2.queryParams.reduce((acc, p) => {
+        acc[p.name] = p.schema;
+        return acc;
+      }, {}),
+      required: operation2.queryParams.filter((p) => p.required).map((p) => p.name)
+    };
+  }
+  const excludedHeaders = [
+    "authorization",
+    "content-type",
+    "accept",
+    "user-agent"
+  ];
+  const actualHeaders = operation2.headerParams.filter((p) => !excludedHeaders.includes(p.name.toLowerCase()));
+  if (actualHeaders.length > 0) {
+    result.headers = {
+      type: "object",
+      properties: actualHeaders.reduce((acc, p) => {
+        acc[p.name] = p.schema;
+        return acc;
+      }, {}),
+      required: actualHeaders.filter((p) => p.required).map((p) => p.name)
+    };
+  }
+  if (operation2.requestBody?.schema) {
+    result.body = operation2.requestBody.schema;
+  }
+  return result;
+}
+function getOutputSchema(operation2) {
+  const successCodes = ["200", "201", "202", "204"];
+  for (const code of successCodes) {
+    const response = operation2.responses[code];
+    if (response?.schema) {
+      return response.schema;
+    }
+  }
+  for (const [code, response] of Object.entries(operation2.responses)) {
+    if (code.startsWith("2") && response.schema) {
+      return response.schema;
+    }
+  }
+  return null;
+}
+
+// src/openapi/importer/analyzer.ts
+var COMMAND_METHODS = ["post", "put", "delete", "patch"];
+function inferOpKind(method) {
+  return COMMAND_METHODS.includes(method.toLowerCase()) ? "command" : "query";
+}
+function inferAuthLevel(operation2, defaultAuth) {
+  if (!operation2.security || operation2.security.length === 0) {
+    return defaultAuth;
+  }
+  for (const sec of operation2.security) {
+    if (Object.keys(sec).length === 0) {
+      return "anonymous";
+    }
+  }
+  return "user";
+}
+
+// src/openapi/importer/generator.ts
+function generateSpecCode(operation2, contractspecConfig, options = {}, inputModel, outputModel, queryModel = null, paramsModel = null, headersModel = null) {
+  const specKey = toSpecKey(operation2.operationId, options.prefix);
+  const kind = inferOpKind(operation2.method);
+  const auth = inferAuthLevel(operation2, options.defaultAuth ?? "user");
+  const lines = [];
+  lines.push("import { defineCommand, defineQuery } from '@contractspec/lib.contracts';");
+  if (inputModel || outputModel || queryModel || paramsModel || headersModel) {
+    const collectedImports = new Set;
+    const models = [
+      inputModel,
+      outputModel,
+      queryModel,
+      paramsModel,
+      headersModel
+    ].filter((m) => !!m);
+    models.forEach((m) => {
+      if (m.imports && m.imports.length > 0) {
+        m.imports.forEach((i) => collectedImports.add(i));
+      }
+    });
+    const legacyModels = models.filter((m) => !m.imports || m.imports.length === 0);
+    const legacyFields = legacyModels.flatMap((m) => m.fields);
+    if (legacyFields.length > 0) {
+      const legacyImportStr = generateImports(legacyFields, contractspecConfig, false);
+      legacyImportStr.split(`
+`).filter(Boolean).forEach((i) => collectedImports.add(i));
+    }
+    if (collectedImports.size > 0) {
+      lines.push(Array.from(collectedImports).sort().join(`
+`));
+    }
+  }
+  lines.push("");
+  const schemaSections = [
+    { label: "Input schema", model: inputModel },
+    { label: "Query schema", model: queryModel },
+    { label: "Path schema", model: paramsModel },
+    { label: "Header schema", model: headersModel },
+    { label: "Output schema", model: outputModel }
+  ];
+  for (const section of schemaSections) {
+    if (section.model && section.model.code) {
+      lines.push(`// ${section.label}`);
+      lines.push(section.model.code);
+      lines.push("");
+    }
+  }
+  const defineFunc = kind === "command" ? "defineCommand" : "defineQuery";
+  const safeName = toValidIdentifier(toPascalCase(operation2.operationId));
+  lines.push(`/**`);
+  lines.push(` * ${operation2.summary ?? operation2.operationId}`);
+  if (operation2.description) {
+    lines.push(` *`);
+    lines.push(` * ${operation2.description}`);
+  }
+  lines.push(` *`);
+  lines.push(` * @source OpenAPI: ${operation2.method.toUpperCase()} ${operation2.path}`);
+  lines.push(` */`);
+  lines.push(`export const ${safeName}Spec = ${defineFunc}({`);
+  lines.push("  meta: {");
+  lines.push(`    key: '${specKey}',`);
+  lines.push("    version: '1.0.0',");
+  lines.push(`    stability: '${options.defaultStability ?? "stable"}',`);
+  lines.push(`    owners: [${(options.defaultOwners ?? []).map((o) => `'${o}'`).join(", ")}],`);
+  lines.push(`    tags: [${operation2.tags.map((t) => `'${t}'`).join(", ")}],`);
+  lines.push(`    description: ${JSON.stringify(operation2.summary ?? operation2.operationId)},`);
+  lines.push(`    goal: ${JSON.stringify(operation2.description ?? "Imported from OpenAPI")},`);
+  lines.push(`    context: 'Imported from OpenAPI: ${operation2.method.toUpperCase()} ${operation2.path}',`);
+  lines.push("  },");
+  lines.push("  io: {");
+  lines.push(`    input: ${inputModel?.name ?? "null"},`);
+  if (queryModel)
+    lines.push(`    query: ${queryModel.name},`);
+  if (paramsModel)
+    lines.push(`    params: ${paramsModel.name},`);
+  if (headersModel)
+    lines.push(`    headers: ${headersModel.name},`);
+  if (outputModel) {
+    lines.push(`    output: ${outputModel.name},`);
+  } else {
+    lines.push("    output: null, // TODO: Define output schema");
+  }
+  lines.push("  },");
+  lines.push("  policy: {");
+  lines.push(`    auth: '${auth}',`);
+  lines.push("  },");
+  const httpMethod = operation2.method.toUpperCase();
+  const restMethod = httpMethod === "GET" ? "GET" : "POST";
+  lines.push("  transport: {");
+  lines.push("    rest: {");
+  lines.push(`      method: '${restMethod}',`);
+  lines.push(`      path: '${operation2.path}',`);
+  lines.push("    },");
+  lines.push("  },");
+  lines.push("});");
+  return lines.join(`
+`);
+}
+
+// src/openapi/importer/models.ts
+function generateModelCode(name, schema, options) {
+  const modelName = toPascalCase(toValidIdentifier(name));
+  const schemaFormat = options.schemaFormat || "contractspec";
+  const model = generateSchemaModelCode(schema, modelName, schemaFormat, options);
+  let imports = "";
+  if (model.imports && model.imports.length > 0) {
+    imports = model.imports.join(`
+`);
+  } else if (model.fields.length > 0) {
+    imports = generateImports(model.fields, options);
+  }
+  return `
+${imports}
+
+${model.code}
+`.trim();
+}
+
+// src/openapi/importer/events.ts
+function generateEventCode(event, options) {
+  const eventName = toValidIdentifier(event.name);
+  const modelName = toPascalCase(eventName) + "Payload";
+  const schemaFormat = options.schemaFormat || "contractspec";
+  const payloadModel = generateSchemaModelCode(event.payload, modelName, schemaFormat, options);
+  const imports = new Set;
+  imports.add("import { defineEvent, type EventSpec } from '@contractspec/lib.contracts';");
+  if (payloadModel.imports && payloadModel.imports.length > 0) {
+    payloadModel.imports.forEach((i) => imports.add(i));
+  } else if (payloadModel.fields && payloadModel.fields.length > 0) {
+    const modelImports = generateImports(payloadModel.fields, options);
+    modelImports.split(`
+`).filter(Boolean).forEach((i) => imports.add(i));
+  }
+  if (payloadModel.name !== modelName) {
+    const modelsDir = `../${options.conventions.models}`;
+    const kebabName = payloadModel.name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+    imports.add(`import { ${payloadModel.name} } from '${modelsDir}/${kebabName}';`);
+  }
+  const allImports = Array.from(imports).join(`
+`);
+  return `
+${allImports}
+
+${payloadModel.code}
+
+export const ${eventName} = defineEvent({
+  meta: {
+    key: '${event.name}',
+    version: '1.0.0',
+    description: ${JSON.stringify(event.description ?? "")},
+  },
+  payload: ${payloadModel.name},
+});
+`.trim();
+}
+
+// src/openapi/importer/grouping.ts
+function resolveOperationGroupFolder(operation2, conventions) {
+  const groupingRule = conventions.operationsGrouping;
+  if (!groupingRule || groupingRule.strategy === "none") {
+    return "";
+  }
+  return applyGroupingStrategy(groupingRule, {
+    name: operation2.operationId,
+    tags: operation2.tags,
+    path: operation2.path
+  });
+}
+function resolveModelGroupFolder(modelName, conventions, relatedPath, relatedTags) {
+  const groupingRule = conventions.modelsGrouping;
+  if (!groupingRule || groupingRule.strategy === "none") {
+    return "";
+  }
+  return applyGroupingStrategy(groupingRule, {
+    name: modelName,
+    tags: relatedTags ?? [],
+    path: relatedPath
+  });
+}
+function resolveEventGroupFolder(eventName, conventions, relatedTags) {
+  const groupingRule = conventions.eventsGrouping;
+  if (!groupingRule || groupingRule.strategy === "none") {
+    return "";
+  }
+  return applyGroupingStrategy(groupingRule, {
+    name: eventName,
+    tags: relatedTags ?? []
+  });
+}
+function applyGroupingStrategy(rule, context) {
+  switch (rule.strategy) {
+    case "by-tag":
+      return context.tags?.[0] ?? "untagged";
+    case "by-owner":
+      return context.owners?.[0] ?? "unowned";
+    case "by-domain":
+      return extractDomain(context.name);
+    case "by-url-path-single":
+      return extractUrlPathLevel(context.path, 1);
+    case "by-url-path-multi":
+      return extractUrlPathLevel(context.path, rule.urlPathLevel ?? 2);
+    case "by-feature":
+      return extractDomain(context.name);
+    case "none":
+    default:
+      return "";
+  }
+}
+function extractDomain(name) {
+  if (name.includes(".")) {
+    return name.split(".")[0] ?? "default";
+  }
+  if (name.includes("_")) {
+    return name.split("_")[0] ?? "default";
+  }
+  const match = name.match(/^([a-z]+)/i);
+  return match?.[1]?.toLowerCase() ?? "default";
+}
+function extractUrlPathLevel(path, level) {
+  if (!path)
+    return "root";
+  const segments = path.split("/").filter(Boolean);
+  const nonParamSegments = segments.filter((s) => !s.startsWith("{"));
+  if (nonParamSegments.length === 0)
+    return "root";
+  return nonParamSegments.slice(0, level).join("/");
+}
+
+// src/openapi/importer/index.ts
+var importFromOpenApi = (parseResult, contractspecOptions, importOptions = {}) => {
+  const { tags, exclude = [], include } = importOptions;
+  const specs = [];
+  const skipped = [];
+  const errors = [];
+  for (const operation2 of parseResult.operations) {
+    if (tags && tags.length > 0) {
+      const hasMatchingTag = operation2.tags.some((t) => tags.includes(t));
+      if (!hasMatchingTag) {
+        skipped.push({
+          sourceId: operation2.operationId,
+          reason: `No matching tags (has: ${operation2.tags.join(", ")})`
+        });
+        continue;
+      }
+    }
+    if (include && include.length > 0) {
+      if (!include.includes(operation2.operationId)) {
+        skipped.push({
+          sourceId: operation2.operationId,
+          reason: "Not in include list"
+        });
+        continue;
+      }
+    } else if (exclude.includes(operation2.operationId)) {
+      skipped.push({
+        sourceId: operation2.operationId,
+        reason: "In exclude list"
+      });
+      continue;
+    }
+    if (operation2.deprecated && importOptions.defaultStability !== "deprecated") {
+      skipped.push({
+        sourceId: operation2.operationId,
+        reason: "Deprecated operation"
+      });
+      continue;
+    }
+    try {
+      const inputSchemas = buildInputSchemas(operation2);
+      const schemaFormat = importOptions.schemaFormat || contractspecOptions.schemaFormat || "contractspec";
+      const inputModel = inputSchemas.body ? generateSchemaModelCode(inputSchemas.body, `${operation2.operationId}Input`, schemaFormat, contractspecOptions) : null;
+      const queryModel = inputSchemas.query ? generateSchemaModelCode(inputSchemas.query, `${operation2.operationId}Query`, schemaFormat, contractspecOptions) : null;
+      const paramsModel = inputSchemas.params ? generateSchemaModelCode(inputSchemas.params, `${operation2.operationId}Params`, schemaFormat, contractspecOptions) : null;
+      const headersModel = inputSchemas.headers ? generateSchemaModelCode(inputSchemas.headers, `${operation2.operationId}Headers`, schemaFormat, contractspecOptions) : null;
+      const outputSchema = getOutputSchema(operation2);
+      let outputModel = outputSchema ? generateSchemaModelCode(outputSchema, `${operation2.operationId}Output`, schemaFormat, contractspecOptions) : null;
+      if (outputModel && schemaFormat === "contractspec" && !outputModel.code.includes("defineSchemaModel")) {
+        outputModel = null;
+      }
+      const code = generateSpecCode(operation2, contractspecOptions, importOptions, inputModel, outputModel, queryModel, paramsModel, headersModel);
+      const specName = toSpecKey(operation2.operationId, importOptions.prefix);
+      const fileName = toFileName(specName);
+      const transportHints = {
+        rest: {
+          method: operation2.method.toUpperCase(),
+          path: operation2.path,
+          params: {
+            path: operation2.pathParams.map((p) => p.name),
+            query: operation2.queryParams.map((p) => p.name),
+            header: operation2.headerParams.map((p) => p.name),
+            cookie: operation2.cookieParams.map((p) => p.name)
+          }
+        }
+      };
+      const source = {
+        type: "openapi",
+        sourceId: operation2.operationId,
+        operationId: operation2.operationId,
+        openApiVersion: parseResult.version,
+        importedAt: new Date
+      };
+      const groupFolder = resolveOperationGroupFolder(operation2, contractspecOptions.conventions);
+      specs.push({
+        code,
+        fileName,
+        groupFolder: groupFolder || undefined,
+        source,
+        transportHints
+      });
+    } catch (error) {
+      errors.push({
+        sourceId: operation2.operationId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  for (const [name, schema] of Object.entries(parseResult.schemas)) {
+    try {
+      const code = generateModelCode(name, schema, {
+        ...contractspecOptions,
+        schemaFormat: importOptions.schemaFormat || contractspecOptions.schemaFormat
+      });
+      const fileName = toFileName(toSpecKey(name, importOptions.prefix));
+      const groupFolder = resolveModelGroupFolder(name, contractspecOptions.conventions);
+      specs.push({
+        code,
+        fileName,
+        groupFolder: groupFolder || undefined,
+        source: {
+          type: "openapi",
+          sourceId: name,
+          operationId: name,
+          openApiVersion: parseResult.version,
+          importedAt: new Date
+        },
+        transportHints: {}
+      });
+    } catch (error) {
+      errors.push({
+        sourceId: name,
+        error: error instanceof Error ? "Model conversion failed: " + error.message : String(error)
+      });
+    }
+  }
+  for (const event of parseResult.events) {
+    try {
+      const code = generateEventCode(event, {
+        ...contractspecOptions,
+        schemaFormat: importOptions.schemaFormat || contractspecOptions.schemaFormat
+      });
+      const fileName = toFileName(toSpecKey(event.name, importOptions.prefix));
+      const groupFolder = resolveEventGroupFolder(event.name, contractspecOptions.conventions);
+      specs.push({
+        code,
+        fileName,
+        groupFolder: groupFolder || undefined,
+        source: {
+          type: "openapi",
+          sourceId: event.name,
+          operationId: event.name,
+          openApiVersion: parseResult.version,
+          importedAt: new Date
+        },
+        transportHints: {}
+      });
+    } catch (error) {
+      errors.push({
+        sourceId: event.name,
+        error: error instanceof Error ? "Event conversion failed: " + error.message : String(error)
+      });
+    }
+  }
+  return {
+    operationSpecs: specs,
+    skipped,
+    errors,
+    summary: {
+      total: parseResult.operations.length + Object.keys(parseResult.schemas).length + parseResult.events.length,
+      imported: specs.length,
+      skipped: skipped.length,
+      errors: errors.length
+    }
+  };
+};
+function importOperation(operation2, options = {}, contractspecOptions) {
+  const inputSchemas = buildInputSchemas(operation2);
+  const schemaFormat = options.schemaFormat || contractspecOptions.schemaFormat || "contractspec";
+  const inputModel = inputSchemas.body ? generateSchemaModelCode(inputSchemas.body, `${operation2.operationId}Input`, schemaFormat, contractspecOptions) : null;
+  const queryModel = inputSchemas.query ? generateSchemaModelCode(inputSchemas.query, `${operation2.operationId}Query`, schemaFormat, contractspecOptions) : null;
+  const paramsModel = inputSchemas.params ? generateSchemaModelCode(inputSchemas.params, `${operation2.operationId}Params`, schemaFormat, contractspecOptions) : null;
+  const headersModel = inputSchemas.headers ? generateSchemaModelCode(inputSchemas.headers, `${operation2.operationId}Headers`, schemaFormat, contractspecOptions) : null;
+  const outputSchema = getOutputSchema(operation2);
+  const outputModel = outputSchema ? generateSchemaModelCode(outputSchema, `${operation2.operationId}Output`, schemaFormat, contractspecOptions) : null;
+  return generateSpecCode(operation2, contractspecOptions, options, inputModel, outputModel, queryModel, paramsModel, headersModel);
+}
+// src/openapi/differ.ts
+function compareValues(path, oldValue, newValue, description) {
+  if (deepEqual(oldValue, newValue)) {
+    return null;
+  }
+  let changeType = "modified";
+  if (oldValue === undefined || oldValue === null) {
+    changeType = "added";
+  } else if (newValue === undefined || newValue === null) {
+    changeType = "removed";
+  } else if (typeof oldValue !== typeof newValue) {
+    changeType = "type_changed";
+  }
+  return {
+    path,
+    type: changeType,
+    oldValue,
+    newValue,
+    description
+  };
+}
+function diffObjects(path, oldObj, newObj, options) {
+  const changes = [];
+  if (!oldObj && !newObj)
+    return changes;
+  if (!oldObj) {
+    changes.push({
+      path,
+      type: "added",
+      newValue: newObj,
+      description: `Added ${path}`
+    });
+    return changes;
+  }
+  if (!newObj) {
+    changes.push({
+      path,
+      type: "removed",
+      oldValue: oldObj,
+      description: `Removed ${path}`
+    });
+    return changes;
+  }
+  const allKeys = new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+  for (const key of allKeys) {
+    const keyPath = path ? `${path}.${key}` : key;
+    if (options.ignorePaths?.some((p) => keyPath.startsWith(p))) {
+      continue;
+    }
+    const oldVal = oldObj[key];
+    const newVal = newObj[key];
+    if (typeof oldVal === "object" && typeof newVal === "object") {
+      changes.push(...diffObjects(keyPath, oldVal, newVal, options));
+    } else {
+      const change = compareValues(keyPath, oldVal, newVal, `Changed ${keyPath}`);
+      if (change) {
+        changes.push(change);
+      }
+    }
+  }
+  return changes;
+}
+function diffSpecVsOperation(spec, operation2, options = {}) {
+  const changes = [];
+  if (!options.ignoreDescriptions) {
+    const descChange = compareValues("meta.description", spec.meta.description, operation2.summary ?? operation2.description, "Description changed");
+    if (descChange)
+      changes.push(descChange);
+  }
+  if (!options.ignoreTags) {
+    const oldTags = [...spec.meta.tags ?? []].sort();
+    const newTags = [...operation2.tags].sort();
+    if (!deepEqual(oldTags, newTags)) {
+      changes.push({
+        path: "meta.tags",
+        type: "modified",
+        oldValue: oldTags,
+        newValue: newTags,
+        description: "Tags changed"
+      });
+    }
+  }
+  if (!options.ignoreTransport) {
+    const specMethod = spec.transport?.rest?.method ?? (spec.meta.kind === "query" ? "GET" : "POST");
+    const opMethod = operation2.method.toUpperCase();
+    if (specMethod !== opMethod) {
+      changes.push({
+        path: "transport.rest.method",
+        type: "modified",
+        oldValue: specMethod,
+        newValue: opMethod,
+        description: "HTTP method changed"
+      });
+    }
+    const specPath = spec.transport?.rest?.path;
+    if (specPath && specPath !== operation2.path) {
+      changes.push({
+        path: "transport.rest.path",
+        type: "modified",
+        oldValue: specPath,
+        newValue: operation2.path,
+        description: "Path changed"
+      });
+    }
+  }
+  const specDeprecated = spec.meta.stability === "deprecated";
+  if (specDeprecated !== operation2.deprecated) {
+    changes.push({
+      path: "meta.stability",
+      type: "modified",
+      oldValue: spec.meta.stability,
+      newValue: operation2.deprecated ? "deprecated" : "stable",
+      description: "Deprecation status changed"
+    });
+  }
+  return changes;
+}
+function diffSpecs(oldSpec, newSpec, options = {}) {
+  const changes = [];
+  const metaChanges = diffObjects("meta", oldSpec.meta, newSpec.meta, {
+    ...options,
+    ignorePaths: [
+      ...options.ignorePaths ?? [],
+      ...options.ignoreDescriptions ? ["meta.description", "meta.goal", "meta.context"] : [],
+      ...options.ignoreTags ? ["meta.tags"] : []
+    ]
+  });
+  changes.push(...metaChanges);
+  if (!options.ignoreTransport) {
+    const transportChanges = diffObjects("transport", oldSpec.transport, newSpec.transport, options);
+    changes.push(...transportChanges);
+  }
+  const policyChanges = diffObjects("policy", oldSpec.policy, newSpec.policy, options);
+  changes.push(...policyChanges);
+  return changes;
+}
+function createSpecDiff(operationId, existing, incoming, options = {}) {
+  let changes = [];
+  let isEquivalent = false;
+  if (existing && incoming.operationSpec) {
+    changes = diffSpecs(existing, incoming.operationSpec, options);
+    isEquivalent = changes.length === 0;
+  } else if (existing && !incoming.operationSpec) {
+    changes = [
+      {
+        path: "",
+        type: "modified",
+        oldValue: existing,
+        newValue: incoming.code,
+        description: "Spec code imported from OpenAPI (runtime comparison not available)"
+      }
+    ];
+  } else {
+    changes = [
+      {
+        path: "",
+        type: "added",
+        newValue: incoming.operationSpec ?? incoming.code,
+        description: "New spec imported from OpenAPI"
+      }
+    ];
+  }
+  return {
+    operationId,
+    existing,
+    incoming,
+    changes,
+    isEquivalent
+  };
+}
+function diffAll(existingSpecs, importedSpecs, options = {}) {
+  const diffs = [];
+  const matchedExisting = new Set;
+  for (const imported of importedSpecs) {
+    const operationId = imported.source.sourceId;
+    let existing;
+    for (const [key, spec] of existingSpecs) {
+      const specName = spec.meta.key;
+      if (key === operationId || specName.includes(operationId)) {
+        existing = spec;
+        matchedExisting.add(key);
+        break;
+      }
+    }
+    diffs.push(createSpecDiff(operationId, existing, imported, options));
+  }
+  for (const [key, spec] of existingSpecs) {
+    if (!matchedExisting.has(key)) {
+      diffs.push({
+        operationId: key,
+        existing: spec,
+        incoming: undefined,
+        changes: [
+          {
+            path: "",
+            type: "removed",
+            oldValue: spec,
+            description: "Spec no longer exists in OpenAPI source"
+          }
+        ],
+        isEquivalent: false
+      });
+    }
+  }
+  return diffs;
+}
+function formatDiffChanges(changes) {
+  if (changes.length === 0) {
+    return "No changes detected";
+  }
+  const lines = [];
+  for (const change of changes) {
+    const prefix = {
+      added: "+",
+      removed: "-",
+      modified: "~",
+      type_changed: "!",
+      required_changed: "?"
+    }[change.type];
+    lines.push(`${prefix} ${change.path}: ${change.description}`);
+    if (change.type === "modified" || change.type === "type_changed") {
+      lines.push(`    old: ${JSON.stringify(change.oldValue)}`);
+      lines.push(`    new: ${JSON.stringify(change.newValue)}`);
+    } else if (change.type === "added") {
+      lines.push(`    value: ${JSON.stringify(change.newValue)}`);
+    } else if (change.type === "removed") {
+      lines.push(`    was: ${JSON.stringify(change.oldValue)}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+export {
+  toValidIdentifier,
+  toSpecKey,
+  toSnakeCase,
+  toSchemaName,
+  toRestPath,
+  toPascalCase,
+  toOperationId,
+  toKebabCase,
+  toHttpMethod,
+  toFileName,
+  toCamelCase,
+  schemaModelToJsonSchema,
+  parseOpenApiString,
+  parseOpenApiDocument,
+  parseOpenApi,
+  openApiToYaml,
+  openApiToJson,
+  openApiForRegistry,
+  normalizePath,
+  jsonSchemaToType,
+  jsonSchemaForSpec,
+  importOperation,
+  importFromOpenApi,
+  getScalarType,
+  getByPath,
+  generateWorkflowsRegistry,
+  generateSchemaModelCode,
+  generateRegistryIndex,
+  generatePresentationsRegistry,
+  generateOperationsRegistry,
+  generateImports,
+  generateFormsRegistry,
+  generateFeaturesRegistry,
+  generateEventsExports,
+  generateDataViewsRegistry,
+  formatDiffChanges,
+  extractPathParams,
+  exportWorkflows,
+  exportPresentationsFromArray,
+  exportPresentations,
+  exportOperations,
+  exportForms,
+  exportFeatures,
+  exportEvents,
+  exportDataViews,
+  exportContractSpec,
+  diffSpecs,
+  diffSpecVsOperation,
+  diffAll,
+  detectVersion,
+  detectFormat,
+  defaultRestPath,
+  deepEqual,
+  createSpecDiff,
+  contractSpecToYaml,
+  contractSpecToJson
+};