@grapity/grapity 0.1.0

package/dist/registry/serve.js

@@ -0,0 +1,3523 @@
+// src/registry/serve.ts
+import path from "path";
+import fs from "fs";
+import { serve } from "@hono/node-server";
+
+// src/registry/server.ts
+import { Hono as Hono22 } from "hono";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { prettyJSON } from "hono/pretty-json";
+
+// src/registry/routes/push.ts
+import { Hono } from "hono";
+
+// src/registry/services/registry.ts
+import { v4 as uuid2 } from "uuid";
+
+// src/registry/utils.ts
+import crypto from "crypto";
+function computeChecksum(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+// src/registry/utils/normalize-spec.ts
+import yaml from "js-yaml";
+var HTTP_METHODS = ["get", "post", "put", "delete", "patch", "head", "options", "trace"];
+var ROOT_ORDER = ["openapi", "info", "servers", "tags", "paths", "webhooks", "components", "security", "externalDocs"];
+var OPERATION_ORDER = ["tags", "summary", "description", "operationId", "parameters", "requestBody", "responses", "security", "deprecated"];
+var COMPONENTS_ORDER = ["schemas", "responses", "parameters", "requestBodies", "headers", "securitySchemes", "links", "callbacks"];
+function normalizeSpec(content) {
+  const trimmed = content.trimStart();
+  const isJson = trimmed.startsWith("{") || trimmed.startsWith("[");
+  const parsed = yaml.load(content);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Invalid spec content: not a valid YAML/JSON object");
+  }
+  const canonical = sortObjectKeys(parsed, []);
+  if (isJson) {
+    return JSON.stringify(canonical, null, 2) + "\n";
+  }
+  return yaml.dump(canonical, {
+    noRefs: true,
+    lineWidth: -1
+  });
+}
+function sortObjectKeys(value, path2) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortObjectKeys(item, path2));
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    const sortedKeys = getSortedKeys(keys, path2);
+    const sorted = {};
+    for (const key of sortedKeys) {
+      sorted[key] = sortObjectKeys(obj[key], [...path2, key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function getSortedKeys(keys, path2) {
+  if (path2.length === 0) {
+    return sortKeysByOrder(keys, ROOT_ORDER);
+  }
+  if (path2.length === 2 && (path2[0] === "paths" || path2[0] === "webhooks")) {
+    return sortPathItemKeys(keys);
+  }
+  if (path2.length === 3 && (path2[0] === "paths" || path2[0] === "webhooks") && HTTP_METHODS.includes(path2[2])) {
+    return sortKeysByOrder(keys, OPERATION_ORDER);
+  }
+  if (path2.length === 1 && path2[0] === "components") {
+    return sortKeysByOrder(keys, COMPONENTS_ORDER);
+  }
+  return keys.sort();
+}
+function sortKeysByOrder(keys, order) {
+  const known = new Set(order);
+  const knownKeys = [];
+  const unknownKeys = [];
+  for (const key of keys) {
+    if (known.has(key)) {
+      knownKeys.push(key);
+    } else {
+      unknownKeys.push(key);
+    }
+  }
+  knownKeys.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+  unknownKeys.sort();
+  return [...knownKeys, ...unknownKeys];
+}
+function sortPathItemKeys(keys) {
+  const methodSet = new Set(HTTP_METHODS);
+  const methods = [];
+  const others = [];
+  for (const key of keys) {
+    if (methodSet.has(key)) {
+      methods.push(key);
+    } else {
+      others.push(key);
+    }
+  }
+  methods.sort((a, b) => HTTP_METHODS.indexOf(a) - HTTP_METHODS.indexOf(b));
+  others.sort();
+  return [...methods, ...others];
+}
+
+// src/registry/parser/openapi/parse.ts
+import yaml2 from "js-yaml";
+function parseOpenApiSpec(content) {
+  const obj = yaml2.load(content);
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    throw new Error("Invalid spec content: not a valid YAML/JSON object");
+  }
+  return obj;
+}
+
+// src/registry/compat-engine/differ.ts
+var HTTP_METHODS2 = ["get", "post", "put", "delete", "patch", "head", "options", "trace"];
+function createRefResolver(spec) {
+  return (ref) => {
+    if (!ref.startsWith("#/")) return void 0;
+    const path2 = ref.replace("#/", "").split("/");
+    let current = spec;
+    for (const key of path2) {
+      if (current && typeof current === "object") {
+        current = current[key];
+      } else {
+        return void 0;
+      }
+    }
+    return current;
+  };
+}
+function resolveSchemaRef(resolver, schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema.$ref) {
+    const resolved = resolver(schema.$ref);
+    if (resolved && typeof resolved === "object") {
+      return resolved;
+    }
+  }
+  return schema;
+}
+function resolveParamRef(resolver, param) {
+  if (!param || typeof param !== "object") return param;
+  if (param.$ref) {
+    const resolved = resolver(param.$ref);
+    if (resolved && typeof resolved === "object") {
+      return resolved;
+    }
+  }
+  return param;
+}
+function diffSpecs(oldSpec, newSpec) {
+  const changes = [];
+  const oldResolver = createRefResolver(oldSpec);
+  const newResolver = createRefResolver(newSpec);
+  changes.push(...diffGlobalMetadata(oldSpec, newSpec));
+  const oldPaths = oldSpec.paths ?? {};
+  const newPaths = newSpec.paths ?? {};
+  for (const path2 of Object.keys(oldPaths)) {
+    const oldPathItem = oldPaths[path2] ?? {};
+    const newPathItem = newPaths[path2] ?? {};
+    for (const method of HTTP_METHODS2) {
+      const oldOp = oldPathItem[method];
+      const newOp = newPathItem[method];
+      if (oldOp && !newOp) {
+        changes.push({
+          type: "endpoint-removed",
+          path: path2,
+          method,
+          wasDeprecated: !!oldOp.deprecated,
+          xSunset: typeof oldOp["x-sunset"] === "string" ? oldOp["x-sunset"] : void 0,
+          wasDraft: !!oldOp["x-draft"]
+        });
+      } else if (oldOp && newOp) {
+        if (!oldOp["x-draft"] && newOp["x-draft"]) {
+          changes.push({ type: "stable-endpoint-marked-draft", path: path2, method });
+        }
+        if (oldOp["x-draft"] && !newOp["x-draft"]) {
+          changes.push({ type: "draft-endpoint-marked-stable", path: path2, method });
+        }
+        if (!oldOp.deprecated && newOp.deprecated) {
+          changes.push({
+            type: "endpoint-deprecated",
+            path: path2,
+            method,
+            xSunset: typeof newOp["x-sunset"] === "string" ? newOp["x-sunset"] : void 0
+          });
+        }
+        if (oldOp.deprecated && !newOp.deprecated) {
+          changes.push({ type: "endpoint-un-deprecated", path: path2, method });
+        }
+        changes.push(...diffOperationMetadata(path2, method, oldOp, newOp));
+        changes.push(...diffParameters(path2, method, oldOp, newOp, oldResolver, newResolver));
+        changes.push(...diffRequestBody(path2, method, oldOp, newOp, oldResolver, newResolver));
+        changes.push(...diffResponses(path2, method, oldOp, newOp, oldResolver, newResolver));
+      }
+    }
+  }
+  for (const path2 of Object.keys(newPaths)) {
+    const oldPathItem = oldPaths[path2] ?? {};
+    const newPathItem = newPaths[path2] ?? {};
+    for (const method of HTTP_METHODS2) {
+      if (!oldPathItem[method] && newPathItem[method]) {
+        changes.push({ type: "endpoint-added", path: path2, method });
+      }
+    }
+  }
+  return changes;
+}
+function diffGlobalMetadata(oldSpec, newSpec) {
+  const changes = [];
+  const oldInfo = oldSpec.info ?? {};
+  const newInfo = newSpec.info ?? {};
+  if (oldInfo.title !== newInfo.title && (oldInfo.title !== void 0 || newInfo.title !== void 0)) {
+    changes.push({ type: "documentation-updated", kind: "info-title-changed", path: "/info/title", detail: `${oldInfo.title} \u2192 ${newInfo.title}` });
+  }
+  if (oldInfo.version !== newInfo.version && (oldInfo.version !== void 0 || newInfo.version !== void 0)) {
+    changes.push({ type: "documentation-updated", kind: "info-version-changed", path: "/info/version", detail: `${oldInfo.version} \u2192 ${newInfo.version}` });
+  }
+  if (oldInfo.description !== newInfo.description && (oldInfo.description !== void 0 || newInfo.description !== void 0)) {
+    changes.push({ type: "documentation-updated", kind: "info-description-changed", path: "/info/description" });
+  }
+  const oldServers = (oldSpec.servers ?? []).map((s) => typeof s === "string" ? s : s?.url).filter(Boolean);
+  const newServers = (newSpec.servers ?? []).map((s) => typeof s === "string" ? s : s?.url).filter(Boolean);
+  if (!arraysEqual(oldServers, newServers)) {
+    changes.push({ type: "documentation-updated", kind: "servers-changed", path: "/servers" });
+  }
+  const oldSecurity = oldSpec.security ?? [];
+  const newSecurity = newSpec.security ?? [];
+  if (oldSecurity.length === 0 && newSecurity.length > 0) {
+    changes.push({ type: "global-security-added" });
+  } else if (oldSecurity.length > 0 && newSecurity.length === 0) {
+    changes.push({ type: "global-security-removed" });
+  } else if (!deepEqual(oldSecurity, newSecurity)) {
+    changes.push({ type: "documentation-updated", kind: "security-scheme-changed", path: "/security" });
+  }
+  const oldWebhooks = Object.keys(oldSpec.webhooks ?? {});
+  const newWebhooks = Object.keys(newSpec.webhooks ?? {});
+  const addedWebhooks = newWebhooks.filter((w) => !oldWebhooks.includes(w));
+  const removedWebhooks = oldWebhooks.filter((w) => !newWebhooks.includes(w));
+  for (const w of addedWebhooks) {
+    changes.push({ type: "documentation-updated", kind: "webhook-added", path: `/webhooks/${w}` });
+  }
+  for (const w of removedWebhooks) {
+    changes.push({ type: "documentation-updated", kind: "webhook-removed", path: `/webhooks/${w}` });
+  }
+  if (!deepEqual(oldSpec.externalDocs, newSpec.externalDocs)) {
+    changes.push({ type: "documentation-updated", kind: "external-docs-changed", path: "/externalDocs" });
+  }
+  return changes;
+}
+function diffOperationMetadata(path2, method, oldOp, newOp) {
+  const changes = [];
+  if (oldOp.operationId !== newOp.operationId && (oldOp.operationId !== void 0 || newOp.operationId !== void 0)) {
+    changes.push({ type: "documentation-updated", kind: "operation-id-changed", path: path2, method });
+  }
+  if (oldOp.summary !== newOp.summary && (oldOp.summary !== void 0 || newOp.summary !== void 0)) {
+    changes.push({ type: "documentation-updated", kind: "summary-changed", path: path2, method });
+  }
+  if (oldOp.description !== newOp.description && (oldOp.description !== void 0 || newOp.description !== void 0)) {
+    changes.push({ type: "documentation-updated", kind: "description-changed", path: path2, method });
+  }
+  if (!arraysEqual(oldOp.tags ?? [], newOp.tags ?? [])) {
+    changes.push({ type: "documentation-updated", kind: "tags-changed", path: path2, method });
+  }
+  return changes;
+}
+function diffParameters(path2, method, oldOp, newOp, oldResolver, newResolver) {
+  const changes = [];
+  const wasDraft = !!oldOp["x-draft"];
+  const oldParamMap = /* @__PURE__ */ new Map();
+  for (const p of oldOp.parameters ?? []) {
+    const resolved = resolveParamRef(oldResolver, p);
+    if (resolved) {
+      oldParamMap.set(`${resolved.name}:${resolved.in}`, resolved);
+    }
+  }
+  const newParamMap = /* @__PURE__ */ new Map();
+  for (const p of newOp.parameters ?? []) {
+    const resolved = resolveParamRef(newResolver, p);
+    if (resolved) {
+      newParamMap.set(`${resolved.name}:${resolved.in}`, resolved);
+    }
+  }
+  for (const [key, newParam] of newParamMap) {
+    if (!oldParamMap.has(key)) {
+      if (newParam.required) {
+        changes.push({ type: "required-param-added", path: path2, method, paramName: newParam.name, paramIn: newParam.in, wasDraft });
+      } else {
+        changes.push({ type: "optional-param-added", path: path2, method, paramName: newParam.name, paramIn: newParam.in });
+      }
+    }
+  }
+  for (const [key, oldParam] of oldParamMap) {
+    const newParam = newParamMap.get(key);
+    if (!newParam) {
+      changes.push({
+        type: "param-removed",
+        path: path2,
+        method,
+        paramName: oldParam.name,
+        paramIn: oldParam.in,
+        wasDeprecated: !!oldParam.deprecated,
+        xSunset: typeof oldParam["x-sunset"] === "string" ? oldParam["x-sunset"] : void 0,
+        wasDraft
+      });
+      continue;
+    }
+    const oldType = oldParam.schema?.type ?? oldParam.type ?? "any";
+    const newType = newParam.schema?.type ?? newParam.type ?? "any";
+    if (oldType !== newType) {
+      changes.push({ type: "param-type-changed", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in, oldType, newType, wasDraft });
+    }
+    const oldFormat = oldParam.schema?.format ?? oldParam.format ?? "";
+    const newFormat = newParam.schema?.format ?? newParam.format ?? "";
+    if (oldFormat !== newFormat) {
+      changes.push({ type: "param-format-changed", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in, oldFormat, newFormat });
+    }
+    if (!oldParam.required && newParam.required) {
+      changes.push({ type: "param-now-required", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in, wasDraft });
+    }
+    if (oldParam.required && !newParam.required) {
+      changes.push({ type: "param-now-optional", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in });
+    }
+    if (oldParam.description !== newParam.description && (oldParam.description !== void 0 || newParam.description !== void 0)) {
+      changes.push({ type: "param-description-changed", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in });
+    }
+    if (!deepEqual(oldParam.default, newParam.default)) {
+      changes.push({ type: "param-default-changed", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in });
+    }
+    if (!oldParam.deprecated && newParam.deprecated) {
+      changes.push({
+        type: "param-deprecated",
+        path: path2,
+        method,
+        paramName: oldParam.name,
+        paramIn: oldParam.in,
+        xSunset: typeof newParam["x-sunset"] === "string" ? newParam["x-sunset"] : void 0
+      });
+    }
+    if (oldParam.deprecated && !newParam.deprecated) {
+      changes.push({ type: "param-un-deprecated", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in });
+    }
+    const oldEnum = new Set(Array.isArray(oldParam.schema?.enum) ? oldParam.schema.enum : []);
+    const newEnum = new Set(Array.isArray(newParam.schema?.enum) ? newParam.schema.enum : []);
+    for (const v of newEnum) {
+      if (!oldEnum.has(v)) {
+        changes.push({ type: "param-enum-value-added", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in, value: String(v) });
+      }
+    }
+    for (const v of oldEnum) {
+      if (!newEnum.has(v)) {
+        changes.push({ type: "param-enum-value-removed", path: path2, method, paramName: oldParam.name, paramIn: oldParam.in, value: String(v), wasDraft });
+      }
+    }
+  }
+  return changes;
+}
+function diffRequestBody(path2, method, oldOp, newOp, oldResolver, newResolver) {
+  const changes = [];
+  const wasDraft = !!oldOp["x-draft"];
+  const oldBody = oldOp.requestBody;
+  const newBody = newOp.requestBody;
+  if (!oldBody && newBody) {
+    changes.push({ type: "request-body-added", path: path2, method });
+    return changes;
+  }
+  if (oldBody && !newBody) {
+    changes.push({ type: "request-body-removed", path: path2, method, wasDraft });
+    return changes;
+  }
+  if (!oldBody && !newBody) {
+    return changes;
+  }
+  const oldMediaTypes = Object.keys(oldBody.content ?? {});
+  const newMediaTypes = Object.keys(newBody.content ?? {});
+  const sharedMediaTypes = oldMediaTypes.filter((m) => newMediaTypes.includes(m));
+  if (oldMediaTypes.length > 0 && newMediaTypes.length > 0 && sharedMediaTypes.length === 0) {
+    changes.push({
+      type: "request-body-media-type-changed",
+      path: path2,
+      method,
+      oldMediaType: oldMediaTypes[0],
+      newMediaType: newMediaTypes[0]
+    });
+  }
+  if (oldBody.description !== newBody.description && (oldBody.description !== void 0 || newBody.description !== void 0)) {
+    changes.push({ type: "request-body-description-changed", path: path2, method });
+  }
+  for (const mediaType of sharedMediaTypes) {
+    const oldSchema = oldBody.content[mediaType]?.schema;
+    const newSchema = newBody.content[mediaType]?.schema;
+    if (oldSchema && newSchema) {
+      changes.push(...diffSchemaProperties(path2, method, oldSchema, newSchema, "request-body", wasDraft, oldResolver, newResolver));
+    }
+  }
+  return changes;
+}
+function diffResponses(path2, method, oldOp, newOp, oldResolver, newResolver) {
+  const changes = [];
+  const wasDraft = !!oldOp["x-draft"];
+  const oldResponses = oldOp.responses ?? {};
+  const newResponses = newOp.responses ?? {};
+  for (const status of Object.keys(oldResponses)) {
+    if (!newResponses[status]) {
+      changes.push({ type: "response-status-removed", path: path2, method, statusCode: status, wasDraft });
+    } else {
+      changes.push(...diffResponse(path2, method, status, oldResponses[status], newResponses[status], wasDraft, oldResolver, newResolver));
+    }
+  }
+  for (const status of Object.keys(newResponses)) {
+    if (!oldResponses[status]) {
+      changes.push({ type: "response-status-added", path: path2, method, statusCode: status });
+    }
+  }
+  return changes;
+}
+function diffResponse(path2, method, statusCode, oldResp, newResp, wasDraft, oldResolver, newResolver) {
+  const changes = [];
+  if (oldResp.description !== newResp.description && (oldResp.description !== void 0 || newResp.description !== void 0)) {
+    changes.push({ type: "response-description-changed", path: path2, method, statusCode });
+  }
+  const oldMediaTypes = Object.keys(oldResp.content ?? {});
+  const newMediaTypes = Object.keys(newResp.content ?? {});
+  const sharedMediaTypes = oldMediaTypes.filter((m) => newMediaTypes.includes(m));
+  if (oldMediaTypes.length > 0 && newMediaTypes.length > 0 && sharedMediaTypes.length === 0) {
+    changes.push({
+      type: "response-media-type-changed",
+      path: path2,
+      method,
+      statusCode,
+      oldMediaType: oldMediaTypes[0],
+      newMediaType: newMediaTypes[0]
+    });
+  }
+  for (const mediaType of sharedMediaTypes) {
+    const oldSchema = oldResp.content[mediaType]?.schema;
+    const newSchema = newResp.content[mediaType]?.schema;
+    if (oldSchema && newSchema) {
+      changes.push(...diffSchemaProperties(path2, method, oldSchema, newSchema, `response/${statusCode}`, wasDraft, oldResolver, newResolver));
+    }
+  }
+  return changes;
+}
+function diffSchemaProperties(path2, method, oldSchema, newSchema, prefix, wasDraft, oldResolver, newResolver) {
+  const changes = [];
+  const oldProps = flattenSchemaProperties(oldSchema, oldResolver);
+  const newProps = flattenSchemaProperties(newSchema, newResolver);
+  for (const [propPath, newProp] of newProps) {
+    const fullPath = prefix ? `${prefix}.${propPath}` : propPath;
+    if (!oldProps.has(propPath)) {
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-added",
+          path: path2,
+          method,
+          propertyPath: propPath,
+          required: newProp.required,
+          wasDraft
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-added",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath
+        });
+      }
+    }
+  }
+  for (const [propPath, oldProp] of oldProps) {
+    const fullPath = prefix ? `${prefix}.${propPath}` : propPath;
+    const newProp = newProps.get(propPath);
+    if (!newProp) {
+      const wasDeprecated = !!oldProp.schema?.deprecated;
+      const xSunset = typeof oldProp.schema?.["x-sunset"] === "string" ? oldProp.schema["x-sunset"] : void 0;
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-removed",
+          path: path2,
+          method,
+          propertyPath: propPath,
+          wasDeprecated,
+          xSunset,
+          wasDraft
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-removed",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath,
+          originalValue: safeStringify(oldProp.schema),
+          wasDeprecated,
+          xSunset,
+          wasDraft
+        });
+      }
+      continue;
+    }
+    if (!oldProp.schema?.deprecated && newProp.schema?.deprecated) {
+      const xSunset = typeof newProp.schema?.["x-sunset"] === "string" ? newProp.schema["x-sunset"] : void 0;
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-deprecated",
+          path: path2,
+          method,
+          propertyPath: propPath,
+          xSunset
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-deprecated",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath,
+          xSunset
+        });
+      }
+    }
+    if (oldProp.schema?.deprecated && !newProp.schema?.deprecated) {
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-un-deprecated",
+          path: path2,
+          method,
+          propertyPath: propPath
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-un-deprecated",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath
+        });
+      }
+    }
+    const oldType = oldProp.schema?.type ?? "any";
+    const newType = newProp.schema?.type ?? "any";
+    if (oldType !== newType) {
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-type-changed",
+          path: path2,
+          method,
+          propertyPath: propPath,
+          oldType,
+          newType,
+          wasDraft
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-type-changed",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath,
+          oldType,
+          newType,
+          wasDraft
+        });
+      }
+    }
+    if (!oldProp.required && newProp.required) {
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-now-required",
+          path: path2,
+          method,
+          propertyPath: propPath,
+          wasDraft
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-now-required",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath,
+          wasDraft
+        });
+      }
+    }
+    if (oldProp.required && !newProp.required) {
+      if (prefix.startsWith("request-body")) {
+        changes.push({
+          type: "request-body-property-now-optional",
+          path: path2,
+          method,
+          propertyPath: propPath
+        });
+      } else if (prefix.startsWith("response/")) {
+        const statusCode = prefix.split("/")[1];
+        changes.push({
+          type: "response-property-now-optional",
+          path: path2,
+          method,
+          statusCode,
+          propertyPath: propPath
+        });
+      }
+    }
+  }
+  return changes;
+}
+function flattenSchemaProperties(schema, resolver, prefix = "", parentRequired = false) {
+  const result = /* @__PURE__ */ new Map();
+  if (!schema || typeof schema !== "object") return result;
+  const resolved = resolveSchemaRef(resolver, schema);
+  if (!resolved || typeof resolved !== "object") return result;
+  const requiredSet = new Set(Array.isArray(resolved.required) ? resolved.required : []);
+  if (resolved.properties) {
+    for (const [key, value] of Object.entries(resolved.properties)) {
+      const propPath = prefix ? `${prefix}.${key}` : key;
+      const isRequired = requiredSet.has(key);
+      result.set(propPath, { schema: value, required: isRequired });
+      if (value?.properties || value?.allOf || value?.anyOf || value?.oneOf || value?.$ref || value?.additionalProperties && typeof value.additionalProperties === "object") {
+        for (const [subKey, subVal] of flattenSchemaProperties(value, resolver, propPath, isRequired)) {
+          result.set(subKey, subVal);
+        }
+      }
+    }
+  }
+  if (resolved.additionalProperties && typeof resolved.additionalProperties === "object") {
+    const ap = resolved.additionalProperties;
+    if (ap.type || ap.properties || ap.allOf || ap.anyOf || ap.oneOf || ap.$ref) {
+      for (const [subKey, subVal] of flattenSchemaProperties(ap, resolver, prefix, parentRequired)) {
+        if (!result.has(subKey)) {
+          result.set(subKey, subVal);
+        }
+      }
+    }
+  }
+  const composed = resolved.allOf ?? resolved.anyOf ?? resolved.oneOf;
+  if (composed) {
+    for (const sub of composed) {
+      for (const [subKey, subVal] of flattenSchemaProperties(sub, resolver, prefix, parentRequired)) {
+        if (!result.has(subKey)) {
+          result.set(subKey, subVal);
+        }
+      }
+    }
+  }
+  return result;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!deepEqual(a[i], b[i])) return false;
+  }
+  return true;
+}
+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") return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!bKeys.includes(key)) return false;
+    if (!deepEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/registry/compat-engine/grace-period.ts
+function checkGracePeriod(changes) {
+  const violations = [];
+  const now = /* @__PURE__ */ new Date();
+  for (const change of changes) {
+    if (change.type === "endpoint-removed" && change.wasDraft) continue;
+    if (change.type === "param-removed" && change.wasDraft) continue;
+    if (change.type === "request-body-property-removed" && change.wasDraft) continue;
+    if (change.type === "response-property-removed" && change.wasDraft) continue;
+    if (change.type === "endpoint-removed") {
+      if (!change.wasDeprecated) {
+        violations.push({ path: change.path, method: change.method, rule: "endpoint-removed-without-deprecation" });
+        continue;
+      }
+      if (!change.xSunset) {
+        violations.push({ path: change.path, method: change.method, rule: "endpoint-removed-missing-sunset" });
+        continue;
+      }
+      const sunsetDate = new Date(change.xSunset);
+      if (isNaN(sunsetDate.getTime()) || sunsetDate >= now) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "endpoint-removed-before-sunset",
+          xSunset: change.xSunset
+        });
+      }
+      continue;
+    }
+    if (change.type === "param-removed") {
+      if (!change.wasDeprecated) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "param-removed-without-deprecation",
+          paramName: change.paramName,
+          paramIn: change.paramIn
+        });
+        continue;
+      }
+      if (!change.xSunset) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "param-removed-missing-sunset",
+          paramName: change.paramName,
+          paramIn: change.paramIn
+        });
+        continue;
+      }
+      const sunsetDate = new Date(change.xSunset);
+      if (isNaN(sunsetDate.getTime()) || sunsetDate >= now) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "param-removed-before-sunset",
+          xSunset: change.xSunset,
+          paramName: change.paramName,
+          paramIn: change.paramIn
+        });
+      }
+      continue;
+    }
+    if (change.type === "request-body-property-removed") {
+      if (!change.wasDeprecated) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "request-body-property-removed-without-deprecation",
+          propertyPath: change.propertyPath
+        });
+        continue;
+      }
+      if (!change.xSunset) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "request-body-property-removed-missing-sunset",
+          propertyPath: change.propertyPath
+        });
+        continue;
+      }
+      const sunsetDate = new Date(change.xSunset);
+      if (isNaN(sunsetDate.getTime()) || sunsetDate >= now) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "request-body-property-removed-before-sunset",
+          xSunset: change.xSunset,
+          propertyPath: change.propertyPath
+        });
+      }
+      continue;
+    }
+    if (change.type === "response-property-removed") {
+      if (!change.wasDeprecated) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "response-property-removed-without-deprecation",
+          statusCode: change.statusCode,
+          propertyPath: change.propertyPath
+        });
+        continue;
+      }
+      if (!change.xSunset) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "response-property-removed-missing-sunset",
+          statusCode: change.statusCode,
+          propertyPath: change.propertyPath
+        });
+        continue;
+      }
+      const sunsetDate = new Date(change.xSunset);
+      if (isNaN(sunsetDate.getTime()) || sunsetDate >= now) {
+        violations.push({
+          path: change.path,
+          method: change.method,
+          rule: "response-property-removed-before-sunset",
+          xSunset: change.xSunset,
+          statusCode: change.statusCode,
+          propertyPath: change.propertyPath
+        });
+      }
+      continue;
+    }
+  }
+  return violations;
+}
+
+// src/registry/compat-engine/classify.ts
+import { v4 as uuid } from "uuid";
+function classifyChanges(changes, graceViolations, previousVersion) {
+  const breakingChanges = [];
+  const safeChanges = [];
+  let hasGraceViolations = false;
+  const violationByKey = /* @__PURE__ */ new Map();
+  for (const v of graceViolations) {
+    let key = `${v.path}:${v.method}`;
+    if (v.paramName && v.paramIn) {
+      key = `${key}:param:${v.paramIn}:${v.paramName}`;
+    } else if (v.statusCode && v.propertyPath) {
+      key = `${key}:response:${v.statusCode}:${v.propertyPath}`;
+    } else if (v.propertyPath) {
+      key = `${key}:request-body:${v.propertyPath}`;
+    }
+    violationByKey.set(key, v);
+  }
+  for (const change of changes) {
+    switch (change.type) {
+      case "stable-endpoint-marked-draft":
+        breakingChanges.push({
+          id: uuid(),
+          rule: "stable-endpoint-marked-draft",
+          description: `${change.method.toUpperCase()} ${change.path} cannot be downgraded from stable to draft`,
+          path: `${change.path}/${change.method.toUpperCase()}`,
+          category: "structural"
+        });
+        break;
+      case "endpoint-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `${change.method.toUpperCase()} ${change.path} was removed (endpoint was marked x-draft)`,
+            path: `${change.path}/${change.method.toUpperCase()}`,
+            category: "documentation"
+          });
+          break;
+        }
+        const violation = violationByKey.get(`${change.path}:${change.method}`);
+        if (violation) {
+          hasGraceViolations = true;
+          breakingChanges.push({
+            id: uuid(),
+            rule: violation.rule,
+            description: describeGraceViolation(change.path, change.method, violation),
+            path: `${change.path}/${change.method.toUpperCase()}`,
+            category: "structural",
+            originalValue: "endpoint existed",
+            newValue: "endpoint removed"
+          });
+        } else {
+          breakingChanges.push({
+            id: uuid(),
+            rule: "endpoint-removed",
+            description: `${change.method.toUpperCase()} ${change.path} was removed after sunset on ${change.xSunset ?? "unknown"}`,
+            path: `${change.path}/${change.method.toUpperCase()}`,
+            category: "structural",
+            originalValue: "endpoint existed",
+            newValue: "endpoint removed"
+          });
+        }
+        break;
+      }
+      case "endpoint-added":
+        safeChanges.push({
+          id: uuid(),
+          rule: "endpoint-added",
+          description: `${change.method.toUpperCase()} ${change.path} was added`,
+          path: `${change.path}/${change.method.toUpperCase()}`,
+          category: "structural"
+        });
+        break;
+      case "endpoint-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "endpoint-deprecated",
+          description: `${change.method.toUpperCase()} ${change.path} was marked deprecated${change.xSunset ? ` (sunset: ${change.xSunset})` : ""}`,
+          path: `${change.path}/${change.method.toUpperCase()}`,
+          category: "structural"
+        });
+        break;
+      case "endpoint-un-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "endpoint-un-deprecated",
+          description: `${change.method.toUpperCase()} ${change.path} was un-deprecated`,
+          path: `${change.path}/${change.method.toUpperCase()}`,
+          category: "documentation"
+        });
+        break;
+      case "draft-endpoint-marked-stable":
+        safeChanges.push({
+          id: uuid(),
+          rule: "draft-endpoint-marked-stable",
+          description: `${change.method.toUpperCase()} ${change.path} was promoted from draft to stable`,
+          path: `${change.path}/${change.method.toUpperCase()}`,
+          category: "documentation"
+        });
+        break;
+      case "required-param-added":
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Required ${change.paramIn} parameter '${change.paramName}' was added to draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "required-request-param-added",
+          description: `Required ${change.paramIn} parameter '${change.paramName}' was added to ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      case "optional-param-added":
+        safeChanges.push({
+          id: uuid(),
+          rule: "optional-request-param-added",
+          description: `Optional ${change.paramIn} parameter '${change.paramName}' was added to ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      case "param-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `${change.method.toUpperCase()} ${change.path}: ${change.paramIn} parameter '${change.paramName}' was removed from draft endpoint`,
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "documentation"
+          });
+          break;
+        }
+        const violation = violationByKey.get(`${change.path}:${change.method}:param:${change.paramIn}:${change.paramName}`);
+        if (violation) {
+          hasGraceViolations = true;
+          breakingChanges.push({
+            id: uuid(),
+            rule: violation.rule,
+            description: describeGraceViolation(change.path, change.method, violation, change.paramName, change.paramIn),
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "structural"
+          });
+        } else {
+          breakingChanges.push({
+            id: uuid(),
+            rule: "param-removed",
+            description: `${change.method.toUpperCase()} ${change.path}: ${change.paramIn} parameter '${change.paramName}' was removed after sunset on ${change.xSunset ?? "unknown"}`,
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "structural"
+          });
+        }
+        break;
+      }
+      case "param-type-changed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `${change.paramIn} parameter '${change.paramName}' type changed from ${change.oldType} to ${change.newType} on draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "param-type-changed",
+          description: `${change.paramIn} parameter '${change.paramName}' type changed from ${change.oldType} to ${change.newType} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "param-format-changed":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-format-changed",
+          description: `${change.paramIn} parameter '${change.paramName}' format changed from ${change.oldFormat} to ${change.newFormat} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "documentation"
+        });
+        break;
+      case "param-now-required": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `${change.paramIn} parameter '${change.paramName}' became required on draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "param-now-required",
+          description: `${change.paramIn} parameter '${change.paramName}' became required on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "param-now-optional":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-now-optional",
+          description: `${change.paramIn} parameter '${change.paramName}' became optional on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "documentation"
+        });
+        break;
+      case "param-description-changed":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-description-changed",
+          description: `Description of ${change.paramIn} parameter '${change.paramName}' changed on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "documentation"
+        });
+        break;
+      case "param-default-changed":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-default-changed",
+          description: `Default value of ${change.paramIn} parameter '${change.paramName}' changed on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "documentation"
+        });
+        break;
+      case "param-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-deprecated",
+          description: `${change.paramIn} parameter '${change.paramName}' was marked deprecated${change.xSunset ? ` (sunset: ${change.xSunset})` : ""} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      case "param-un-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-un-deprecated",
+          description: `${change.paramIn} parameter '${change.paramName}' was un-deprecated on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "documentation"
+        });
+        break;
+      case "param-enum-value-added":
+        safeChanges.push({
+          id: uuid(),
+          rule: "param-enum-value-added",
+          description: `Enum value '${change.value}' added to ${change.paramIn} parameter '${change.paramName}' on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      case "param-enum-value-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Enum value '${change.value}' removed from ${change.paramIn} parameter '${change.paramName}' on draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "param-enum-value-removed",
+          description: `Enum value '${change.value}' removed from ${change.paramIn} parameter '${change.paramName}' on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/parameters/${change.paramName}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "request-body-added":
+        breakingChanges.push({
+          id: uuid(),
+          rule: "request-body-added",
+          description: `Request body added to ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody`,
+          category: "structural"
+        });
+        break;
+      case "request-body-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Request body removed from draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody`,
+            category: "documentation"
+          });
+          break;
+        }
+        safeChanges.push({
+          id: uuid(),
+          rule: "request-body-removed",
+          description: `Request body removed from ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody`,
+          category: "documentation"
+        });
+        break;
+      }
+      case "request-body-property-added":
+        if (change.required) {
+          if (change.wasDraft) {
+            safeChanges.push({
+              id: uuid(),
+              rule: "draft-endpoint-changed",
+              description: `Required request body property '${change.propertyPath}' added to draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+              path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+              category: "documentation"
+            });
+          } else {
+            breakingChanges.push({
+              id: uuid(),
+              rule: "request-body-property-added",
+              description: `Required request body property '${change.propertyPath}' added to ${change.method.toUpperCase()} ${change.path}`,
+              path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+              category: "structural"
+            });
+          }
+        } else {
+          safeChanges.push({
+            id: uuid(),
+            rule: "request-body-property-added",
+            description: `Optional request body property '${change.propertyPath}' added to ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+            category: "documentation"
+          });
+        }
+        break;
+      case "request-body-property-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `${change.method.toUpperCase()} ${change.path}: request body property '${change.propertyPath}' was removed from draft endpoint`,
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+            category: "documentation"
+          });
+          break;
+        }
+        const violation = violationByKey.get(`${change.path}:${change.method}:request-body:${change.propertyPath}`);
+        if (violation) {
+          hasGraceViolations = true;
+          breakingChanges.push({
+            id: uuid(),
+            rule: violation.rule,
+            description: describeGraceViolation(change.path, change.method, violation, void 0, void 0, change.propertyPath),
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+            category: "structural",
+            originalValue: "property existed",
+            newValue: "property removed"
+          });
+        } else {
+          breakingChanges.push({
+            id: uuid(),
+            rule: "request-body-property-removed",
+            description: `${change.method.toUpperCase()} ${change.path}: request body property '${change.propertyPath}' was removed after sunset on ${change.xSunset ?? "unknown"}`,
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+            category: "structural"
+          });
+        }
+        break;
+      }
+      case "request-body-property-type-changed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Request body property '${change.propertyPath}' type changed from ${change.oldType} to ${change.newType} on draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "request-body-property-type-changed",
+          description: `Request body property '${change.propertyPath}' type changed from ${change.oldType} to ${change.newType} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "request-body-property-now-required": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Request body property '${change.propertyPath}' became required on draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "request-body-property-now-required",
+          description: `Request body property '${change.propertyPath}' became required on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "request-body-property-now-optional":
+        safeChanges.push({
+          id: uuid(),
+          rule: "request-body-property-now-optional",
+          description: `Request body property '${change.propertyPath}' became optional on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+          category: "documentation"
+        });
+        break;
+      case "request-body-property-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "request-body-property-deprecated",
+          description: `Request body property '${change.propertyPath}' was marked deprecated${change.xSunset ? ` (sunset: ${change.xSunset})` : ""} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+          category: "structural"
+        });
+        break;
+      case "request-body-property-un-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "request-body-property-un-deprecated",
+          description: `Request body property '${change.propertyPath}' was un-deprecated on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody/${change.propertyPath}`,
+          category: "documentation"
+        });
+        break;
+      case "request-body-media-type-changed":
+        breakingChanges.push({
+          id: uuid(),
+          rule: "request-body-media-type-changed",
+          description: `Request body media type changed from ${change.oldMediaType} to ${change.newMediaType} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody`,
+          category: "structural"
+        });
+        break;
+      case "request-body-description-changed":
+        safeChanges.push({
+          id: uuid(),
+          rule: "request-body-description-changed",
+          description: `Request body description changed on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/requestBody`,
+          category: "documentation"
+        });
+        break;
+      case "response-property-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `${change.method.toUpperCase()} ${change.path}: response property '${change.propertyPath}' was removed from ${change.statusCode} response in draft endpoint`,
+            path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+            category: "documentation"
+          });
+          break;
+        }
+        const violation = violationByKey.get(`${change.path}:${change.method}:response:${change.statusCode}:${change.propertyPath}`);
+        if (violation) {
+          hasGraceViolations = true;
+          breakingChanges.push({
+            id: uuid(),
+            rule: violation.rule,
+            description: describeGraceViolation(change.path, change.method, violation, void 0, void 0, change.propertyPath, change.statusCode),
+            path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+            category: "structural",
+            originalValue: change.originalValue,
+            newValue: void 0
+          });
+        } else {
+          breakingChanges.push({
+            id: uuid(),
+            rule: "response-property-removed",
+            description: `${change.method.toUpperCase()} ${change.path}: response property '${change.propertyPath}' was removed from ${change.statusCode} response after sunset on ${change.xSunset ?? "unknown"}`,
+            path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+            category: "structural",
+            originalValue: change.originalValue,
+            newValue: void 0
+          });
+        }
+        break;
+      }
+      case "response-property-added":
+        safeChanges.push({
+          id: uuid(),
+          rule: "response-property-added",
+          description: `Response property '${change.propertyPath}' added to ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+          category: "documentation"
+        });
+        break;
+      case "response-property-type-changed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Response property '${change.propertyPath}' type changed from ${change.oldType} to ${change.newType} on draft endpoint ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+            path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "response-property-type-changed",
+          description: `Response property '${change.propertyPath}' type changed from ${change.oldType} to ${change.newType} on ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "response-property-now-required": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Response property '${change.propertyPath}' became required on draft endpoint ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+            path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "response-property-now-required",
+          description: `Response property '${change.propertyPath}' became required on ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "response-property-now-optional":
+        safeChanges.push({
+          id: uuid(),
+          rule: "response-property-now-optional",
+          description: `Response property '${change.propertyPath}' became optional on ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+          category: "documentation"
+        });
+        break;
+      case "response-property-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "response-property-deprecated",
+          description: `Response property '${change.propertyPath}' was marked deprecated${change.xSunset ? ` (sunset: ${change.xSunset})` : ""} on ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+          category: "structural"
+        });
+        break;
+      case "response-property-un-deprecated":
+        safeChanges.push({
+          id: uuid(),
+          rule: "response-property-un-deprecated",
+          description: `Response property '${change.propertyPath}' was un-deprecated on ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/response/${change.statusCode}/${change.propertyPath}`,
+          category: "documentation"
+        });
+        break;
+      case "response-status-removed": {
+        if (change.wasDraft) {
+          safeChanges.push({
+            id: uuid(),
+            rule: "draft-endpoint-changed",
+            description: `Response status ${change.statusCode} was removed from draft endpoint ${change.method.toUpperCase()} ${change.path}`,
+            path: `${change.path}/${change.method.toUpperCase()}/responses/${change.statusCode}`,
+            category: "documentation"
+          });
+          break;
+        }
+        breakingChanges.push({
+          id: uuid(),
+          rule: "response-status-removed",
+          description: `Response status ${change.statusCode} was removed from ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/responses/${change.statusCode}`,
+          category: "structural"
+        });
+        break;
+      }
+      case "response-status-added":
+        safeChanges.push({
+          id: uuid(),
+          rule: "response-status-added",
+          description: `Response status ${change.statusCode} was added to ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/responses/${change.statusCode}`,
+          category: "structural"
+        });
+        break;
+      case "response-media-type-changed":
+        breakingChanges.push({
+          id: uuid(),
+          rule: "response-media-type-changed",
+          description: `Response media type changed from ${change.oldMediaType} to ${change.newMediaType} on ${change.method.toUpperCase()} ${change.path} (${change.statusCode})`,
+          path: `${change.path}/${change.method.toUpperCase()}/responses/${change.statusCode}`,
+          category: "structural"
+        });
+        break;
+      case "response-description-changed":
+        safeChanges.push({
+          id: uuid(),
+          rule: "response-description-changed",
+          description: `Response description changed for ${change.statusCode} on ${change.method.toUpperCase()} ${change.path}`,
+          path: `${change.path}/${change.method.toUpperCase()}/responses/${change.statusCode}`,
+          category: "documentation"
+        });
+        break;
+      case "global-security-added":
+        breakingChanges.push({
+          id: uuid(),
+          rule: "global-security-added",
+          description: "Global security requirement was added",
+          path: "/security",
+          category: "structural"
+        });
+        break;
+      case "global-security-removed":
+        safeChanges.push({
+          id: uuid(),
+          rule: "global-security-removed",
+          description: "Global security requirement was removed",
+          path: "/security",
+          category: "documentation"
+        });
+        break;
+      case "documentation-updated":
+        safeChanges.push({
+          id: uuid(),
+          rule: change.kind,
+          description: `${change.kind.replace(/-/g, " ")}${change.detail ? ` (${change.detail})` : ""}`,
+          path: change.method ? `${change.path}/${change.method.toUpperCase()}` : change.path,
+          category: "documentation"
+        });
+        break;
+    }
+  }
+  const hasStructuralSafe = safeChanges.some((c) => c.category === "structural");
+  const classification = breakingChanges.length > 0 ? "major" : hasStructuralSafe ? "minor" : safeChanges.length > 0 ? "patch" : "patch";
+  return {
+    compatReport: {
+      previousVersion,
+      classification,
+      breakingChanges,
+      safeChanges
+    },
+    hasGraceViolations
+  };
+}
+function describeGraceViolation(path2, method, violation, paramName, paramIn, propertyPath, statusCode) {
+  const endpoint = `${method.toUpperCase()} ${path2}`;
+  if (paramName && paramIn) {
+    switch (violation.rule) {
+      case "param-removed-without-deprecation":
+        return `${endpoint}: ${paramIn} parameter '${paramName}' was removed without first being marked as deprecated`;
+      case "param-removed-missing-sunset":
+        return `${endpoint}: ${paramIn} parameter '${paramName}' is deprecated but has no x-sunset date set`;
+      case "param-removed-before-sunset":
+        return `${endpoint}: ${paramIn} parameter '${paramName}' was removed before its sunset date (${violation.xSunset ?? "unknown"})`;
+    }
+  }
+  if (propertyPath && statusCode) {
+    switch (violation.rule) {
+      case "response-property-removed-without-deprecation":
+        return `${endpoint}: response property '${propertyPath}' was removed from ${statusCode} response without first being marked as deprecated`;
+      case "response-property-removed-missing-sunset":
+        return `${endpoint}: response property '${propertyPath}' in ${statusCode} response is deprecated but has no x-sunset date set`;
+      case "response-property-removed-before-sunset":
+        return `${endpoint}: response property '${propertyPath}' was removed from ${statusCode} response before its sunset date (${violation.xSunset ?? "unknown"})`;
+    }
+  }
+  if (propertyPath) {
+    switch (violation.rule) {
+      case "request-body-property-removed-without-deprecation":
+        return `${endpoint}: request body property '${propertyPath}' was removed without first being marked as deprecated`;
+      case "request-body-property-removed-missing-sunset":
+        return `${endpoint}: request body property '${propertyPath}' is deprecated but has no x-sunset date set`;
+      case "request-body-property-removed-before-sunset":
+        return `${endpoint}: request body property '${propertyPath}' was removed before its sunset date (${violation.xSunset ?? "unknown"})`;
+    }
+  }
+  switch (violation.rule) {
+    case "endpoint-removed-without-deprecation":
+      return `${endpoint} was removed without first being marked as deprecated`;
+    case "endpoint-removed-missing-sunset":
+      return `${endpoint} is deprecated but has no x-sunset date set`;
+    case "endpoint-removed-before-sunset":
+      return `${endpoint} was removed before its sunset date (${violation.xSunset ?? "unknown"})`;
+    default:
+      return `${endpoint} grace period violation: ${violation.rule}`;
+  }
+}
+
+// src/registry/services/registry.ts
+var BreakingChangeError = class extends Error {
+  constructor(compatReport) {
+    super("Breaking changes detected");
+    this.compatReport = compatReport;
+    this.name = "BreakingChangeError";
+  }
+  compatReport;
+};
+var PrereleaseConstraintError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrereleaseConstraintError";
+  }
+};
+var RegistryService = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async pushSpec(content, name, options) {
+    const prerelease = options?.prerelease ?? false;
+    const existingSpec = await this.store.getSpec(name);
+    const isNewSpec = !existingSpec;
+    const isOpenApi = (options?.type ?? "openapi") === "openapi";
+    const normalized = isOpenApi ? normalizeSpec(content) : content;
+    const checksum = computeChecksum(normalized);
+    let spec;
+    let compatReport;
+    let semver;
+    let previousVersion;
+    if (isNewSpec) {
+      spec = {
+        id: uuid2(),
+        name,
+        type: options?.type ?? "openapi",
+        description: options?.description,
+        owner: options?.owner,
+        sourceRepo: options?.sourceRepo,
+        tags: options?.tags ?? [],
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      semver = prerelease ? "0.1.0" : "1.0.0";
+    } else {
+      spec = existingSpec;
+      const latestVersion = await this.store.getLatestVersion(name);
+      if (prerelease && latestVersion && !latestVersion.isPrerelease) {
+        throw new PrereleaseConstraintError(
+          `Cannot push pre-release version. ${name}@${latestVersion.semver} is already a release version.`
+        );
+      }
+      if (!latestVersion) {
+        semver = prerelease ? "0.1.0" : "1.0.0";
+      } else {
+        previousVersion = latestVersion.semver;
+        const oldSpec = parseOpenApiSpec(latestVersion.content);
+        const newSpec = parseOpenApiSpec(normalized);
+        const changes = diffSpecs(oldSpec, newSpec);
+        const graceViolations = checkGracePeriod(changes);
+        const { compatReport: report } = classifyChanges(
+          changes,
+          graceViolations,
+          previousVersion
+        );
+        const allowedRules = /* @__PURE__ */ new Set([
+          "endpoint-removed",
+          "param-removed",
+          "request-body-property-removed",
+          "response-property-removed"
+        ]);
+        const blockedBreakingChanges = report.breakingChanges.filter(
+          (b) => !allowedRules.has(b.rule)
+        );
+        if (!options?.force && blockedBreakingChanges.length > 0) {
+          throw new BreakingChangeError(report);
+        }
+        if (prerelease) {
+          const level = report.classification === "patch" ? "patch" : "minor";
+          semver = this.bumpPreRelease(latestVersion.semver, level);
+        } else if (latestVersion.isPrerelease) {
+          semver = "1.0.0";
+        } else {
+          semver = this.bumpRelease(latestVersion.semver, report.classification);
+        }
+        compatReport = { ...report, suggestedVersion: semver };
+      }
+    }
+    const version = {
+      id: uuid2(),
+      specId: spec.id,
+      semver,
+      content: normalized,
+      checksum,
+      gitRef: options?.gitRef,
+      pushedBy: options?.pushedBy,
+      compatibility: compatReport ?? (isNewSpec ? { previousVersion: "0.0.0", classification: "initial", breakingChanges: [], safeChanges: [] } : void 0),
+      previousVersion,
+      forceReason: options?.force ? options.reason : void 0,
+      isPrerelease: prerelease,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.store.pushSpecVersion(spec, version);
+    const auditAction = options?.force ? "spec.push.force" : "spec.push";
+    await this.store.logAudit(auditAction, options?.pushedBy ?? "unknown", name, semver, {
+      breakingChanges: compatReport?.breakingChanges.length ?? 0,
+      safeChanges: compatReport?.safeChanges.length ?? 0,
+      forced: options?.force ?? false,
+      reason: options?.reason
+    });
+    return { spec, version, compatReport, isNewSpec };
+  }
+  async listSpecs(filters) {
+    const specs2 = await this.store.listSpecs(filters);
+    return Promise.all(
+      specs2.map(async (spec) => {
+        const latestVersion = await this.store.getLatestVersion(spec.name);
+        return { ...spec, latestVersion: latestVersion ?? void 0 };
+      })
+    );
+  }
+  async getSpec(name) {
+    const spec = await this.store.getSpec(name);
+    if (!spec) return null;
+    const latestVersion = await this.store.getLatestVersion(name);
+    return { spec, latestVersion: latestVersion ?? void 0 };
+  }
+  async listVersions(name, options) {
+    return this.store.listVersions(name, options);
+  }
+  async getVersion(name, semver) {
+    return this.store.getSpecVersion(name, semver);
+  }
+  async getCompatReport(name, semver) {
+    return this.store.getCompatReport(name, semver);
+  }
+  async compareVersions(name, from, to) {
+    const spec = await this.store.getSpec(name);
+    if (!spec) return null;
+    const all = await this.store.listVersions(name, { limit: 1e4, offset: 0 });
+    const fromVersion = all.versions.find((v) => v.semver === from);
+    const toVersion = all.versions.find((v) => v.semver === to);
+    if (!fromVersion || !toVersion) return null;
+    const sorted = [...all.versions].sort((a, b) => {
+      const aParts = a.semver.split(".").map(Number);
+      const bParts = b.semver.split(".").map(Number);
+      for (let i = 0; i < 3; i++) {
+        if (aParts[i] !== bParts[i]) return aParts[i] - bParts[i];
+      }
+      return 0;
+    });
+    const fromIndex = sorted.findIndex((v) => v.semver === from);
+    const toIndex = sorted.findIndex((v) => v.semver === to);
+    const start = Math.min(fromIndex, toIndex);
+    const end = Math.max(fromIndex, toIndex);
+    const steps = sorted.slice(start + 1, end + 1).map((v) => {
+      const report = v.compatibility;
+      if (!report) {
+        return {
+          version: v.semver,
+          previousVersion: v.previousVersion ?? "0.0.0",
+          classification: "initial",
+          breakingChanges: [],
+          safeChanges: []
+        };
+      }
+      return {
+        version: v.semver,
+        previousVersion: report.previousVersion,
+        classification: report.classification,
+        breakingChanges: report.breakingChanges,
+        safeChanges: report.safeChanges
+      };
+    });
+    return { from: sorted[start].semver, to: sorted[end].semver, steps };
+  }
+  async deleteSpec(name, actor) {
+    const deleted = await this.store.deleteSpec(name);
+    if (deleted) {
+      await this.store.logAudit("spec.delete", actor ?? "unknown", name, void 0, {});
+    }
+    return deleted;
+  }
+  bumpRelease(current, classification) {
+    const parts = current.split(".").map(Number);
+    if (parts.length !== 3) return "1.0.0";
+    const [major, minor, patch] = parts;
+    switch (classification) {
+      case "major":
+        return `${major + 1}.0.0`;
+      case "minor":
+        return `${major}.${minor + 1}.0`;
+      case "patch":
+        return `${major}.${minor}.${patch + 1}`;
+      default:
+        return `${major}.${minor + 1}.0`;
+    }
+  }
+  bumpPreRelease(current, level) {
+    const parts = current.split(".").map(Number);
+    if (parts.length !== 3) return "0.1.0";
+    const [major, minor, patch] = parts;
+    switch (level) {
+      case "minor":
+        return `${major}.${minor + 1}.0`;
+      case "patch":
+        return `${major}.${minor}.${patch + 1}`;
+    }
+  }
+};
+
+// src/registry/routes/push.ts
+var pushRoute = new Hono().post("/", async (c) => {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "bad_request", message: "Request body must be valid JSON", statusCode: 400 }, 400);
+  }
+  if (!body.content || typeof body.content !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: content", statusCode: 400 }, 400);
+  }
+  if (!body.name || typeof body.name !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: name", statusCode: 400 }, 400);
+  }
+  if (body.force && !body.reason) {
+    return c.json({
+      error: "bad_request",
+      message: "reason is required when force is true",
+      statusCode: 400
+    }, 400);
+  }
+  const store = c.get("store");
+  const service = new RegistryService(store);
+  try {
+    const result = await service.pushSpec(body.content, body.name, {
+      type: body.type,
+      description: body.description,
+      owner: body.owner,
+      sourceRepo: body.sourceRepo,
+      tags: Array.isArray(body.tags) ? body.tags : void 0,
+      gitRef: body.gitRef,
+      pushedBy: body.pushedBy,
+      prerelease: body.prerelease,
+      force: body.force,
+      reason: body.reason
+    });
+    return c.json({ data: result }, 201);
+  } catch (err) {
+    if (err instanceof BreakingChangeError) {
+      return c.json({
+        error: "breaking_change",
+        message: "Breaking changes detected. Use force: true with a reason to override.",
+        statusCode: 409,
+        compatReport: err.compatReport
+      }, 409);
+    }
+    if (err instanceof PrereleaseConstraintError) {
+      return c.json({
+        error: "prerelease_constraint",
+        message: err.message,
+        statusCode: 422
+      }, 422);
+    }
+    console.error("Push spec error:", err);
+    return c.json({
+      error: "internal_error",
+      message: err instanceof Error ? err.message : "An unexpected error occurred",
+      statusCode: 500
+    }, 500);
+  }
+});
+
+// src/registry/routes/validate.ts
+import { Hono as Hono2 } from "hono";
+
+// src/registry/parser/openapi/validate.ts
+import yaml3 from "js-yaml";
+import SwaggerParser from "@apidevtools/swagger-parser";
+async function validateOpenApiSpec(content) {
+  let obj;
+  try {
+    obj = yaml3.load(content);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [`YAML/JSON parse error: ${err instanceof Error ? err.message : String(err)}`],
+      warnings: []
+    };
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return { valid: false, errors: ["Spec content is not a valid YAML/JSON object"], warnings: [] };
+  }
+  try {
+    await SwaggerParser.validate(obj);
+    return { valid: true, errors: [], warnings: [] };
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [err instanceof Error ? err.message : String(err)],
+      warnings: []
+    };
+  }
+}
+
+// src/registry/routes/validate.ts
+var validateRoute = new Hono2().post("/:name/validate", async (c) => {
+  const name = c.req.param("name");
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "bad_request", message: "Request body must be valid JSON", statusCode: 400 }, 400);
+  }
+  if (!body.content || typeof body.content !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: content", statusCode: 400 }, 400);
+  }
+  const { valid, errors, warnings } = await validateOpenApiSpec(body.content);
+  if (!valid) {
+    return c.json({ data: { valid, errors, warnings } });
+  }
+  const store = c.get("store");
+  const service = new RegistryService(store);
+  const result = await service.getSpec(name);
+  if (!result) {
+    return c.json({ error: "not_found", message: `Spec "${name}" not found`, statusCode: 404 }, 404);
+  }
+  if (!result.latestVersion) {
+    return c.json({ data: { valid: true, errors: [], warnings: [] } });
+  }
+  try {
+    const oldSpec = parseOpenApiSpec(result.latestVersion.content);
+    const newSpec = parseOpenApiSpec(body.content);
+    const changes = diffSpecs(oldSpec, newSpec);
+    const graceViolations = checkGracePeriod(changes);
+    const { compatReport } = classifyChanges(changes, graceViolations, result.latestVersion.semver);
+    const allowedRules = /* @__PURE__ */ new Set([
+      "endpoint-removed",
+      "param-removed",
+      "request-body-property-removed",
+      "response-property-removed"
+    ]);
+    const blockedChanges = compatReport.breakingChanges.filter(
+      (b) => !allowedRules.has(b.rule)
+    );
+    const hasBlocked = blockedChanges.length > 0;
+    return c.json({
+      data: {
+        compatReport,
+        errors: hasBlocked ? blockedChanges.map((b) => b.description) : [],
+        valid: !hasBlocked,
+        warnings
+      }
+    });
+  } catch (err) {
+    return c.json({
+      data: {
+        errors: [err instanceof Error ? err.message : "Compat analysis failed"],
+        valid: false,
+        warnings
+      }
+    });
+  }
+});
+
+// src/registry/routes/list.ts
+import { Hono as Hono3 } from "hono";
+var listRoute = new Hono3().get("/", async (c) => {
+  const store = c.get("store");
+  const service = new RegistryService(store);
+  const type = c.req.query("type");
+  const owner = c.req.query("owner");
+  const tags = c.req.query("tags")?.split(",");
+  const specs2 = await service.listSpecs({ type, owner, tags });
+  return c.json({ data: specs2 });
+});
+
+// src/registry/routes/get-spec.ts
+import { Hono as Hono4 } from "hono";
+function withoutContent({ content: _, ...rest }) {
+  return rest;
+}
+var getSpecRoute = new Hono4().get("/:name", async (c) => {
+  const name = c.req.param("name");
+  const store = c.get("store");
+  const service = new RegistryService(store);
+  const result = await service.getSpec(name);
+  if (!result) {
+    return c.json({ error: "not_found", message: `Spec "${name}" not found`, statusCode: 404 }, 404);
+  }
+  const { spec, latestVersion } = result;
+  return c.json({
+    data: {
+      latestVersion: latestVersion ? withoutContent(latestVersion) : void 0,
+      spec
+    }
+  });
+});
+
+// src/registry/routes/delete-spec.ts
+import { Hono as Hono5 } from "hono";
+var deleteSpecRoute = new Hono5().delete(
+  "/:name",
+  async (c) => {
+    const name = c.req.param("name");
+    const store = c.get("store");
+    const service = new RegistryService(store);
+    const deleted = await service.deleteSpec(name);
+    if (!deleted) {
+      return c.json({ error: "not_found", message: `Spec "${name}" not found`, statusCode: 404 }, 404);
+    }
+    return new Response(null, { status: 204 });
+  }
+);
+
+// src/registry/routes/versions.ts
+import { Hono as Hono6 } from "hono";
+function withoutContent2({ content: _, ...rest }) {
+  return rest;
+}
+var versionsRoute = new Hono6().get(
+  "/:name/versions",
+  async (c) => {
+    const name = c.req.param("name");
+    const store = c.get("store");
+    const service = new RegistryService(store);
+    const spec = await service.getSpec(name);
+    if (!spec) {
+      return c.json({ error: "not_found", message: `Spec "${name}" not found`, statusCode: 404 }, 404);
+    }
+    const rawLimit = parseInt(c.req.query("limit") ?? "10", 10);
+    const rawOffset = parseInt(c.req.query("offset") ?? "0", 10);
+    const limit = Math.min(Math.max(isNaN(rawLimit) ? 10 : rawLimit, 1), 25);
+    const offset = Math.max(isNaN(rawOffset) ? 0 : rawOffset, 0);
+    const { versions, total } = await service.listVersions(name, { limit, offset });
+    return c.json({
+      data: versions.map(withoutContent2),
+      pagination: {
+        hasMore: offset + limit < total,
+        limit,
+        offset,
+        total
+      }
+    });
+  }
+);
+
+// src/registry/routes/get-version.ts
+import { Hono as Hono7 } from "hono";
+function withoutContent3({ content: _, ...rest }) {
+  return rest;
+}
+var getVersionRoute = new Hono7().get(
+  "/:name/versions/:semver",
+  async (c) => {
+    const name = c.req.param("name");
+    const semver = c.req.param("semver");
+    const store = c.get("store");
+    const service = new RegistryService(store);
+    const version = await service.getVersion(name, semver);
+    if (!version) {
+      return c.json({ error: "not_found", message: `Version ${semver} not found for spec "${name}"`, statusCode: 404 }, 404);
+    }
+    return c.json({ data: withoutContent3(version) });
+  }
+);
+
+// src/registry/routes/compat-report.ts
+import { Hono as Hono8 } from "hono";
+var compatReportRoute = new Hono8().get(
+  "/:name/compat/:semver",
+  async (c) => {
+    const name = c.req.param("name");
+    const semver = c.req.param("semver");
+    const store = c.get("store");
+    const service = new RegistryService(store);
+    const report = await service.getCompatReport(name, semver);
+    if (!report) {
+      return c.json({ error: "not_found", message: `Compat report not found for ${name}@${semver}`, statusCode: 404 }, 404);
+    }
+    return c.json({ data: report });
+  }
+);
+
+// src/registry/routes/compare-versions.ts
+import { Hono as Hono9 } from "hono";
+var compareVersionsRoute = new Hono9().get(
+  "/:name/compare",
+  async (c) => {
+    const name = c.req.param("name");
+    const from = c.req.query("from");
+    const to = c.req.query("to");
+    const store = c.get("store");
+    const service = new RegistryService(store);
+    if (!from || !to) {
+      return c.json(
+        {
+          error: "bad_request",
+          message: "Query parameters 'from' and 'to' are required",
+          statusCode: 400
+        },
+        400
+      );
+    }
+    const result = await service.compareVersions(name, from, to);
+    if (!result) {
+      return c.json(
+        {
+          error: "not_found",
+          message: `Spec or version not found for ${name}`,
+          statusCode: 404
+        },
+        404
+      );
+    }
+    return c.json({ data: result });
+  }
+);
+
+// src/registry/routes/serve-spec.ts
+import { Hono as Hono10 } from "hono";
+import yaml4 from "js-yaml";
+var CONTENT_TYPES = {
+  openapi: {
+    json: "application/vnd.oai.openapi+json",
+    yaml: "application/vnd.oai.openapi+yaml"
+  },
+  asyncapi: {
+    json: "application/vnd.aai.asyncapi+json",
+    yaml: "application/vnd.aai.asyncapi+yaml"
+  }
+};
+async function serveSpec(c, name, semver, format) {
+  const store = c.get("store");
+  const service = new RegistryService(store);
+  let content;
+  let specType;
+  let resolvedSemver;
+  if (semver) {
+    const version = await service.getVersion(name, semver);
+    if (!version) {
+      return c.json({ error: "not_found", message: `Version ${semver} not found for spec "${name}"`, statusCode: 404 }, 404);
+    }
+    content = version.content;
+    resolvedSemver = semver;
+    const result = await service.getSpec(name);
+    specType = result?.spec.type ?? "openapi";
+  } else {
+    const result = await service.getSpec(name);
+    if (!result || !result.latestVersion) {
+      return c.json({ error: "not_found", message: `Spec "${name}" not found`, statusCode: 404 }, 404);
+    }
+    content = result.latestVersion.content;
+    resolvedSemver = result.latestVersion.semver;
+    specType = result.spec.type;
+  }
+  const parsed = yaml4.load(content);
+  const contentType = CONTENT_TYPES[specType]?.[format] ?? CONTENT_TYPES.openapi[format];
+  const headers = {
+    "Content-Type": contentType
+  };
+  if (resolvedSemver) {
+    headers["Grapity-Resolved-Version"] = resolvedSemver;
+  }
+  if (format === "yaml") {
+    return new Response(yaml4.dump(parsed), { headers });
+  }
+  return new Response(JSON.stringify(parsed), { headers });
+}
+var serveSpecRoute = new Hono10().get(
+  "/:name/spec.json",
+  (c) => serveSpec(c, c.req.param("name"), void 0, "json")
+).get(
+  "/:name/spec.yaml",
+  (c) => serveSpec(c, c.req.param("name"), void 0, "yaml")
+).get(
+  "/:name/versions/:semver/spec.json",
+  (c) => serveSpec(c, c.req.param("name"), c.req.param("semver"), "json")
+).get(
+  "/:name/versions/:semver/spec.yaml",
+  (c) => serveSpec(c, c.req.param("name"), c.req.param("semver"), "yaml")
+);
+
+// src/registry/routes/health.ts
+import { Hono as Hono11 } from "hono";
+var healthRoute = new Hono11().get("/", async (c) => {
+  return c.json({
+    status: "ok",
+    version: "0.0.1",
+    uptime: process.uptime()
+  });
+});
+
+// src/registry/routes/welcome.ts
+import { Hono as Hono12 } from "hono";
+function buildPage(port, mode) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Registry | grapity</title>
+<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Cdefs%3E%3ClinearGradient id='g' x1='0%25' y1='0%25' x2='100%25' y2='100%25'%3E%3Cstop offset='0%25' stop-color='%236366f1'/%3E%3Cstop offset='100%25' stop-color='%2306b6d4'/%3E%3C/linearGradient%3E%3C/defs%3E%3Crect width='32' height='32' rx='6' fill='%230a0a0f'/%3E%3Cpath d='M7 24 L16 6 L25 24 L21 24 L16 14 L11 24 Z' fill='url(%23g)'/%3E%3Ccircle cx='16' cy='24' r='2.5' fill='url(%23g)'/%3E%3C/svg%3E">
+<link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@500;600;700&family=IBM+Plex+Mono:wght@400;500&family=IBM+Plex+Sans:wght@400;500;600&display=swap" rel="stylesheet">
+<style>
+html { overflow-y: scroll; }
+:root {
+  --bg: #07070e;
+  --surface: #0c0c15;
+  --card: #0e0e18;
+  --border: #181828;
+  --indigo: #6366f1;
+  --cyan: #06b6d4;
+  --green: #22d3a5;
+  --red: #f43f5e;
+  --text: #ddddf5;
+  --muted: #44445e;
+  --mono: 'IBM Plex Mono', monospace;
+  --sans: 'IBM Plex Sans', sans-serif;
+}
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body {
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--sans);
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 48px 24px;
+}
+
+/* \u2500\u2500 RGB CHROMATIC GLITCH \u2500\u2500 */
+@keyframes rgb-split {
+  0%,100%   { transform: translate(0,0); opacity:1; }
+  8%  { transform: translate(-3px, 0); opacity:0.85; }
+  9%  { transform: translate(0,0); opacity:1; }
+  22% { transform: translate(2px,-1px); opacity:0.9; }
+  23% { transform: translate(0,0); }
+  60% { transform: translate(-2px,1px); }
+  61% { transform: translate(3px,0); opacity:0.8; }
+  62% { transform: translate(0,0); opacity:1; }
+  85% { transform: translate(1px,-1px); }
+  86% { transform: translate(0,0); }
+}
+.layer-r { fill: #f43f5e; mix-blend-mode: screen; animation: rgb-split 2.5s ease-in-out infinite; }
+.layer-g { fill: url(#lgr); mix-blend-mode: normal; }
+.layer-b { fill: #06b6d4; mix-blend-mode: screen; animation: rgb-split 2.5s ease-in-out infinite reverse; animation-delay: 0.05s; }
+
+/* \u2500\u2500 LAYOUT \u2500\u2500 */
+.hero {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 28px;
+  text-align: center;
+  max-width: 720px;
+  width: 100%;
+}
+.hero > svg {
+  margin-bottom: -24px;
+}
+
+.wordmark {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 10px;
+}
+
+.wordmark h1 {
+  font-family: 'Space Grotesk', sans-serif;
+  font-size: 32px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+}
+.wordmark h1 .brand {
+  color: var(--text);
+}
+.wordmark h1 .product {
+  color: var(--muted);
+}
+
+.wordmark .subtitle {
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--muted);
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+}
+
+/* \u2500\u2500 STATUS BADGE \u2500\u2500 */
+.status-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 8px 16px;
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--muted);
+}
+@keyframes pulse-dot {
+  0%,100% { opacity:1; }
+  50% { opacity:0.3; }
+}
+.status-dot {
+  width: 6px; height: 6px;
+  border-radius: 50%;
+  background: var(--green);
+  animation: pulse-dot 2s ease-in-out infinite;
+  flex-shrink: 0;
+}
+.status-row span { color: var(--text); }
+.status-row .sep { color: var(--border); }
+
+/* \u2500\u2500 TABS \u2500\u2500 */
+.tabs {
+  display: flex;
+  gap: 4px;
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 4px;
+  width: 100%;
+  max-width: 520px;
+}
+.tab {
+  flex: 1;
+  padding: 8px 12px;
+  border: none;
+  background: transparent;
+  color: var(--muted);
+  font-family: var(--mono);
+  font-size: 13px;
+  cursor: pointer;
+  border-radius: 6px;
+  transition: color 0.15s, background 0.15s;
+}
+.tab:hover { color: var(--text); }
+.tab.active {
+  background: #6366f120;
+  color: var(--text);
+}
+
+/* \u2500\u2500 PANELS \u2500\u2500 */
+.panel {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.panel.hidden { display: none; }
+
+.endpoints {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.endpoint {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 16px;
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 7px;
+  font-family: var(--mono);
+  font-size: 13px;
+  text-decoration: none;
+  color: var(--text);
+  transition: border-color 0.15s, background 0.15s;
+}
+.endpoint:hover { border-color: #6366f133; background: #0f0f1e; }
+
+.method {
+  font-size: 12px;
+  font-weight: 600;
+  letter-spacing: 0.05em;
+  padding: 2px 8px;
+  border-radius: 4px;
+  min-width: 42px;
+  text-align: center;
+  border: 1px solid;
+}
+.GET    { background: #3b82f620; color: #3b82f6; border-color: #3b82f630; }
+.POST   { background: #22d3a520; color: #22d3a5; border-color: #22d3a530; }
+.PUT    { background: #f59e0b20; color: #f59e0b; border-color: #f59e0b30; }
+.DELETE { background: #f43f5e20; color: #f43f5e; border-color: #f43f5e30; }
+.PATCH  { background: #a855f720; color: #a855f7; border-color: #a855f730; }
+
+.path { flex: 1; color: var(--text); }
+.desc { color: var(--muted); font-size: 12px; }
+
+/* \u2500\u2500 LINKS \u2500\u2500 */
+.links {
+  display: flex;
+  align-items: center;
+  gap: 20px;
+}
+.link {
+  font-family: var(--mono);
+  font-size: 12px;
+  color: var(--muted);
+  text-decoration: none;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  transition: color 0.15s;
+}
+.link:hover { color: var(--text); }
+.link-dot { width: 3px; height: 3px; border-radius: 50%; background: var(--border); }
+</style>
+</head>
+<body>
+<div class="hero">
+
+  <!-- LOGO -->
+  <svg viewBox="0 0 32 32" width="80" height="80" xmlns="http://www.w3.org/2000/svg">
+    <defs>
+      <linearGradient id="lgr" x1="0%" y1="0%" x2="100%" y2="100%">
+        <stop offset="0%" stop-color="#6366f1"/>
+        <stop offset="100%" stop-color="#06b6d4"/>
+      </linearGradient>
+    </defs>
+    <rect width="32" height="32" rx="6" fill="#07070e"/>
+    <path class="layer-r" d="M7 24 L16 6 L25 24 L21 24 L16 14 L11 24 Z"/>
+    <circle class="layer-r" cx="16" cy="24" r="2.5"/>
+    <path class="layer-g" d="M7 24 L16 6 L25 24 L21 24 L16 14 L11 24 Z"/>
+    <circle class="layer-g" cx="16" cy="24" r="2.5"/>
+    <path class="layer-b" d="M7 24 L16 6 L25 24 L21 24 L16 14 L11 24 Z"/>
+    <circle class="layer-b" cx="16" cy="24" r="2.5"/>
+  </svg>
+
+  <!-- WORDMARK -->
+  <div class="wordmark">
+    <h1><span class="brand">grapity</span> <span class="product">Registry</span></h1>
+    <span class="subtitle">API contract and gateway config server</span>
+  </div>
+
+  <!-- STATUS -->
+  <div class="status-row">
+    <span class="status-dot"></span>
+    running on <span>localhost:${port}</span>
+    <span class="sep">|</span>
+    mode: <span>${mode}</span>
+    <span class="sep">|</span>
+    <a href="/v1/health" style="color:var(--cyan);text-decoration:none;">health \u2197</a>
+  </div>
+
+  <!-- TABS -->
+  <div class="tabs">
+    <button class="tab active" onclick="switchTab('specs')">specs</button>
+    <button class="tab" onclick="switchTab('gateway')">gateway configs</button>
+    <button class="tab" onclick="switchTab('logs')">gateway logs</button>
+  </div>
+
+  <!-- SPECS PANEL -->
+  <div id="panel-specs" class="panel">
+    <div class="endpoints">
+      <div class="endpoint">
+        <span class="method POST">POST</span>
+        <span class="path">/v1/specs</span>
+        <span class="desc">push a spec version</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs</span>
+        <span class="desc">list all specs</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs/:name</span>
+        <span class="desc">get spec metadata</span>
+      </div>
+      <div class="endpoint">
+        <span class="method DELETE">DELETE</span>
+        <span class="path">/v1/specs/:name</span>
+        <span class="desc">delete spec and all versions</span>
+      </div>
+      <div class="endpoint">
+        <span class="method POST">POST</span>
+        <span class="path">/v1/specs/:name/validate</span>
+        <span class="desc">validate against latest</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs/:name/versions</span>
+        <span class="desc">list versions</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs/:name/versions/:semver</span>
+        <span class="desc">get specific version</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs/:name/spec.{yaml|json}</span>
+        <span class="desc">fetch raw spec</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs/:name/versions/:semver/spec.{yaml|json}</span>
+        <span class="desc">version-specific spec</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/specs/:name/compat/:semver</span>
+        <span class="desc">compatibility report</span>
+      </div>
+    </div>
+  </div>
+
+  <!-- GATEWAY CONFIGS PANEL -->
+  <div id="panel-gateway" class="panel hidden">
+    <div class="endpoints">
+      <div class="endpoint">
+        <span class="method POST">POST</span>
+        <span class="path">/v1/gateway-configs</span>
+        <span class="desc">push a gateway config</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-configs</span>
+        <span class="desc">list all gateway configs</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-configs/:name</span>
+        <span class="desc">get gateway config metadata</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-configs/:name/versions</span>
+        <span class="desc">list versions</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-configs/:name/versions/:version</span>
+        <span class="desc">get specific version</span>
+      </div>
+    </div>
+  </div>
+
+  <!-- GATEWAY LOGS PANEL -->
+  <div id="panel-logs" class="panel hidden">
+    <div class="endpoints">
+      <div class="endpoint">
+        <span class="method POST">POST</span>
+        <span class="path">/v1/gateway-logs/ingest/:provider/:environment</span>
+        <span class="desc">ingest a gateway log</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-logs</span>
+        <span class="desc">query logs</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-logs/stats</span>
+        <span class="desc">endpoint usage stats</span>
+      </div>
+      <div class="endpoint">
+        <span class="method GET">GET</span>
+        <span class="path">/v1/gateway-logs/:id</span>
+        <span class="desc">get a single log entry</span>
+      </div>
+    </div>
+  </div>
+
+  <!-- LINKS -->
+  <div class="links">
+    <a class="link" href="https://github.com/grapitydev" target="_blank" rel="noopener">
+      <svg viewBox="0 0 16 16" width="13" height="13" fill="currentColor"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0016 8c0-4.42-3.58-8-8-8z"/></svg>
+      grapitydev
+    </a>
+    <span class="link-dot"></span>
+    <a class="link" href="https://grapity.dev" target="_blank" rel="noopener">
+      <svg viewBox="0 0 16 16" width="13" height="13" fill="currentColor"><path d="M8 0a8 8 0 100 16A8 8 0 008 0zm5.68 5.33h-2.3c-.25-1.1-.63-2.06-1.1-2.8a6.4 6.4 0 013.4 2.8zM8 1.37c.64.8 1.14 1.85 1.44 3.03h-2.88C6.86 3.22 7.36 2.17 8 1.37zm-3.28.16c-.47.74-.85 1.7-1.1 2.8h-2.3a6.4 6.4 0 013.4-2.8zM1.34 6.67h2.65c-.07.43-.1.87-.1 1.33 0 .46.03.9.1 1.33H1.34A6.43 6.43 0 011 8c0-.46.12-.91.34-1.33zm.98 4h2.3c.25 1.1.63 2.06 1.1 2.8a6.4 6.4 0 01-3.4-2.8zM8 14.63c-.64-.8-1.14-1.85-1.44-3.03h2.88c-.3 1.18-.8 2.23-1.44 3.03zm3.28-.16c.47-.74.85-1.7 1.1-2.8h2.3a6.4 6.4 0 01-3.4 2.8zm1.39-4.14c.07-.43.1-.87.1-1.33 0-.46-.03-.9-.1-1.33h2.65c.22.42.34.87.34 1.33a6.43 6.43 0 01-.34 1.33h-2.65zm-.66-4h-2.32A9.84 9.84 0 008 1.6c0-.09.01-.17.01-.26.87.38 1.65.95 2.28 1.67.34.42.64.9.88 1.46zm-3.65 0H6.04c.24-.56.54-1.04.88-1.46A6.38 6.38 0 019.15 9 9.84 9.84 0 009.08 6.33zM6.67 9H9.33A8.4 8.4 0 019.44 10.4H6.56C6.58 9.94 6.62 9.47 6.67 9z"/></svg>
+      grapity.dev
+    </a>
+    <span class="link-dot"></span>
+    <a class="link" href="https://grapity.dev/docs/platform/registry/overview" target="_blank" rel="noopener">
+      docs \u2197
+    </a>
+  </div>
+
+</div>
+
+<script>
+function switchTab(tab) {
+  document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+  document.querySelectorAll('.panel').forEach(p => p.classList.add('hidden'));
+  const tabIndex = tab === 'specs' ? 1 : tab === 'gateway' ? 2 : 3;
+  document.querySelector('.tab:nth-child(' + tabIndex + ')').classList.add('active');
+  document.getElementById('panel-' + tab).classList.remove('hidden');
+}
+</script>
+
+</body>
+</html>`;
+}
+var welcomeRoute = new Hono12().get("/", (c) => {
+  const config = c.get("config");
+  const mode = config.database === "sqlite" ? "local" : "remote";
+  return c.html(buildPage(config.port, mode));
+});
+
+// src/registry/routes/push-gateway-config.ts
+import { Hono as Hono13 } from "hono";
+
+// src/registry/services/gateway.ts
+import { v4 as uuid3 } from "uuid";
+import yaml5 from "js-yaml";
+var UnsupportedProviderError = class extends Error {
+  constructor(provider) {
+    super(`Unsupported provider: "${provider}". Only "kong" is supported.`);
+    this.name = "UnsupportedProviderError";
+  }
+};
+var SpecNotFoundError = class extends Error {
+  constructor(name, semver) {
+    super(`Spec "${name}@${semver}" not found`);
+    this.name = "SpecNotFoundError";
+  }
+};
+var RouteNotFoundError = class extends Error {
+  constructor(path2, methods) {
+    super(`Route ${methods.join(",")} ${path2} not found in spec`);
+    this.name = "RouteNotFoundError";
+  }
+};
+var NoEnvironmentsError = class extends Error {
+  constructor() {
+    super("At least one environment must be defined");
+    this.name = "NoEnvironmentsError";
+  }
+};
+var NameExistsError = class extends Error {
+  constructor(name) {
+    super(`Gateway config "${name}" already exists`);
+    this.name = "NameExistsError";
+  }
+};
+var SUPPORTED_PROVIDERS = ["kong"];
+var GatewayService = class {
+  constructor(gatewayStore, specStore) {
+    this.gatewayStore = gatewayStore;
+    this.specStore = specStore;
+  }
+  gatewayStore;
+  specStore;
+  async pushGatewayConfig(data) {
+    if (!SUPPORTED_PROVIDERS.includes(data.provider)) {
+      throw new UnsupportedProviderError(data.provider);
+    }
+    const specVersion = await this.specStore.getSpecVersion(data.specName, data.specSemver);
+    if (!specVersion) {
+      throw new SpecNotFoundError(data.specName, data.specSemver);
+    }
+    const envKeys = Object.keys(data.environments);
+    if (envKeys.length === 0) {
+      throw new NoEnvironmentsError();
+    }
+    const parsedSpec = yaml5.load(specVersion.content);
+    const specPaths = parsedSpec?.paths ?? {};
+    for (const route of data.routes) {
+      const specPathItem = specPaths[route.path];
+      if (!specPathItem) {
+        throw new RouteNotFoundError(route.path, route.methods);
+      }
+      for (const method of route.methods) {
+        const lowerMethod = method.toLowerCase();
+        if (!specPathItem[lowerMethod]) {
+          throw new RouteNotFoundError(route.path, [method]);
+        }
+      }
+    }
+    const existingConfig = await this.gatewayStore.getGatewayConfig(data.name);
+    const config = {
+      id: existingConfig?.id ?? uuid3(),
+      name: data.name,
+      provider: data.provider,
+      specName: data.specName,
+      specSemver: data.specSemver,
+      createdAt: existingConfig?.createdAt ?? /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const environments = envKeys.map((name) => ({
+      name,
+      ...data.environments[name]
+    }));
+    const version = {
+      id: uuid3(),
+      gatewayConfigId: config.id,
+      routes: data.routes,
+      environments,
+      callerIdentification: data.callerIdentification,
+      content: data.content,
+      checksum: computeChecksum(data.content),
+      pushedBy: data.pushedBy,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.gatewayStore.pushGatewayConfigVersion(config, version);
+    return { config, version };
+  }
+  async listGatewayConfigs() {
+    return this.gatewayStore.listGatewayConfigs();
+  }
+  async getGatewayConfig(name) {
+    return this.gatewayStore.getGatewayConfig(name);
+  }
+  async listGatewayConfigVersions(name) {
+    return this.gatewayStore.listGatewayConfigVersions(name);
+  }
+  async getGatewayConfigVersion(name, versionId) {
+    return this.gatewayStore.getGatewayConfigVersion(name, versionId);
+  }
+};
+
+// src/registry/routes/push-gateway-config.ts
+var pushGatewayConfigRoute = new Hono13().post("/", async (c) => {
+  let body;
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json({ error: "bad_request", message: "Request body must be valid JSON", statusCode: 400 }, 400);
+  }
+  if (!body.name || typeof body.name !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: name", statusCode: 400 }, 400);
+  }
+  if (!body.provider || typeof body.provider !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: provider", statusCode: 400 }, 400);
+  }
+  if (!body.specName || typeof body.specName !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: specName", statusCode: 400 }, 400);
+  }
+  if (!body.specSemver || typeof body.specSemver !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: specSemver", statusCode: 400 }, 400);
+  }
+  if (!body.content || typeof body.content !== "string") {
+    return c.json({ error: "bad_request", message: "Missing required field: content", statusCode: 400 }, 400);
+  }
+  const store = c.get("store");
+  const service = new GatewayService(store, store);
+  try {
+    const result = await service.pushGatewayConfig({
+      name: body.name,
+      provider: body.provider,
+      specName: body.specName,
+      specSemver: body.specSemver,
+      routes: Array.isArray(body.routes) ? body.routes : [],
+      environments: body.environments ?? {},
+      callerIdentification: body.callerIdentification,
+      content: body.content,
+      pushedBy: body.pushedBy
+    });
+    return c.json({ data: result }, 201);
+  } catch (err) {
+    if (err instanceof UnsupportedProviderError) {
+      return c.json({ error: "unsupported_provider", message: err.message, statusCode: 422 }, 422);
+    }
+    if (err instanceof SpecNotFoundError) {
+      return c.json({ error: "spec_not_found", message: err.message, statusCode: 422 }, 422);
+    }
+    if (err instanceof RouteNotFoundError) {
+      return c.json({ error: "route_not_found", message: err.message, statusCode: 422 }, 422);
+    }
+    if (err instanceof NoEnvironmentsError) {
+      return c.json({ error: "no_environments", message: err.message, statusCode: 422 }, 422);
+    }
+    if (err instanceof NameExistsError) {
+      return c.json({ error: "name_exists", message: err.message, statusCode: 409 }, 409);
+    }
+    console.error("Push gateway config error:", err);
+    return c.json({
+      error: "internal_error",
+      message: err instanceof Error ? err.message : "An unexpected error occurred",
+      statusCode: 500
+    }, 500);
+  }
+});
+
+// src/registry/routes/list-gateway-configs.ts
+import { Hono as Hono14 } from "hono";
+var listGatewayConfigsRoute = new Hono14().get("/", async (c) => {
+  const store = c.get("store");
+  const service = new GatewayService(store, store);
+  const configs = await service.listGatewayConfigs();
+  return c.json({ data: configs });
+});
+
+// src/registry/routes/get-gateway-config.ts
+import { Hono as Hono15 } from "hono";
+var getGatewayConfigRoute = new Hono15().get("/:name", async (c) => {
+  const name = c.req.param("name");
+  const store = c.get("store");
+  const service = new GatewayService(store, store);
+  const config = await service.getGatewayConfig(name);
+  if (!config) {
+    return c.json({ error: "not_found", message: `Gateway config "${name}" not found`, statusCode: 404 }, 404);
+  }
+  return c.json({ data: config });
+});
+
+// src/registry/routes/gateway-config-versions.ts
+import { Hono as Hono16 } from "hono";
+function withoutContent4({ content: _, ...rest }) {
+  return rest;
+}
+var gatewayConfigVersionsRoute = new Hono16().get(
+  "/:name/versions",
+  async (c) => {
+    const name = c.req.param("name");
+    const store = c.get("store");
+    const service = new GatewayService(store, store);
+    const versions = await service.listGatewayConfigVersions(name);
+    return c.json({ data: versions.map(withoutContent4) });
+  }
+);
+
+// src/registry/routes/get-gateway-config-version.ts
+import { Hono as Hono17 } from "hono";
+var getGatewayConfigVersionRoute = new Hono17().get(
+  "/:name/versions/:version",
+  async (c) => {
+    const name = c.req.param("name");
+    const versionId = c.req.param("version");
+    const store = c.get("store");
+    const service = new GatewayService(store, store);
+    const version = await service.getGatewayConfigVersion(name, versionId);
+    if (!version) {
+      return c.json({ error: "not_found", message: `Version ${versionId} not found for gateway config "${name}"`, statusCode: 404 }, 404);
+    }
+    return c.json({ data: version });
+  }
+);
+
+// src/registry/routes/ingest-gateway-log.ts
+import { Hono as Hono18 } from "hono";
+
+// src/registry/services/gateway-log.ts
+import { v4 as uuid4 } from "uuid";
+var DEFAULT_CALLER_RULES = [
+  { source: "kong.consumer.id", confidence: "high" },
+  { source: "header.x-consumer-id", confidence: "medium" },
+  { source: "header.x-client-id", confidence: "medium" },
+  { source: "ip+ua", confidence: "low" }
+];
+function extractCallerIdentity(payload, rules) {
+  for (const rule of rules) {
+    const id = resolveCallerId(payload, rule.source);
+    if (id) {
+      return { callerId: id, callerSource: rule.source, callerConfidence: rule.confidence };
+    }
+  }
+  return { callerConfidence: "anonymous" };
+}
+function resolveCallerId(payload, source) {
+  if (source === "kong.consumer.id") {
+    return payload.consumer?.id;
+  }
+  if (source.startsWith("header.")) {
+    const headerName = source.slice("header.".length);
+    const headers = payload.request?.headers ?? {};
+    const value = headers[headerName] ?? headers[headerName.toLowerCase()];
+    if (value) {
+      return Array.isArray(value) ? value[0] : value;
+    }
+  }
+  if (source === "ip+ua") {
+    const ip = payload.client_ip ?? payload.tries?.[0]?.ip;
+    const ua = payload.request?.headers?.["user-agent"] ?? payload.request?.headers?.["User-Agent"];
+    if (ip && ua) {
+      return `${ip}::${Array.isArray(ua) ? ua[0] : ua}`;
+    }
+    if (ip) {
+      return ip;
+    }
+  }
+  if (source === "ip") {
+    return payload.client_ip ?? payload.tries?.[0]?.ip;
+  }
+  return void 0;
+}
+function extractRoutePath(payload) {
+  const routePaths = payload.route?.paths;
+  if (routePaths && routePaths.length > 0) {
+    return routePaths[0];
+  }
+  return void 0;
+}
+var GatewayLogService = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async ingestLog(provider, environment, payload) {
+    const kongPayload = payload;
+    const gatewayConfigName = kongPayload.service?.name;
+    if (!gatewayConfigName) {
+      throw new Error("Missing service.name in gateway log payload");
+    }
+    const configVersion = await this.store.getLatestGatewayConfigVersion(gatewayConfigName);
+    const rules = configVersion?.callerIdentification?.rules ?? DEFAULT_CALLER_RULES;
+    const caller = extractCallerIdentity(kongPayload, rules);
+    const routePath = extractRoutePath(kongPayload);
+    const log = {
+      id: uuid4(),
+      provider,
+      gatewayConfigName,
+      environment,
+      method: kongPayload.request?.method?.toUpperCase() ?? "UNKNOWN",
+      path: kongPayload.request?.uri ?? "/",
+      routePath,
+      status: kongPayload.response?.status ?? 0,
+      callerId: caller.callerId,
+      callerSource: caller.callerSource,
+      callerConfidence: caller.callerConfidence,
+      occurredAt: kongPayload.started_at ? new Date(kongPayload.started_at) : /* @__PURE__ */ new Date(),
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.store.recordGatewayLog(log);
+  }
+  async listLogs(filters) {
+    return this.store.listGatewayLogs(filters);
+  }
+  async getLog(id) {
+    return this.store.getGatewayLog(id);
+  }
+  async getStats(filters) {
+    return this.store.getGatewayLogStats(filters);
+  }
+};
+
+// src/registry/routes/ingest-gateway-log.ts
+var ingestGatewayLogRoute = new Hono18().post("/ingest/:provider/:environment", async (c) => {
+  const store = c.get("store");
+  const service = new GatewayLogService(store);
+  const provider = c.req.param("provider");
+  const environment = c.req.param("environment");
+  try {
+    const payload = await c.req.json();
+    await service.ingestLog(provider, environment, payload);
+    return c.json({ status: "ok" }, 201);
+  } catch (err) {
+    console.error("Gateway log ingest error:", err);
+    return c.json({
+      error: "bad_request",
+      message: err instanceof Error ? err.message : "Invalid log payload",
+      statusCode: 400
+    }, 400);
+  }
+});
+
+// src/registry/routes/list-gateway-logs.ts
+import { Hono as Hono19 } from "hono";
+var listGatewayLogsRoute = new Hono19().get("/", async (c) => {
+  const store = c.get("store");
+  const service = new GatewayLogService(store);
+  const filters = {
+    gatewayConfigName: c.req.query("gatewayConfig") ?? void 0,
+    environment: c.req.query("environment") ?? void 0,
+    path: c.req.query("path") ?? void 0,
+    method: c.req.query("method") ?? void 0,
+    status: c.req.query("status") ? parseInt(c.req.query("status"), 10) : void 0,
+    from: c.req.query("from") ? new Date(c.req.query("from")) : void 0,
+    to: c.req.query("to") ? new Date(c.req.query("to")) : void 0,
+    limit: c.req.query("limit") ? parseInt(c.req.query("limit"), 10) : void 0,
+    offset: c.req.query("offset") ? parseInt(c.req.query("offset"), 10) : void 0
+  };
+  const result = await service.listLogs(filters);
+  return c.json({
+    data: result.logs,
+    pagination: {
+      total: result.total,
+      limit: filters.limit ?? 50,
+      offset: filters.offset ?? 0,
+      hasMore: (filters.offset ?? 0) + (filters.limit ?? 50) < result.total
+    }
+  });
+});
+
+// src/registry/routes/get-gateway-log.ts
+import { Hono as Hono20 } from "hono";
+var getGatewayLogRoute = new Hono20().get("/:id", async (c) => {
+  const store = c.get("store");
+  const service = new GatewayLogService(store);
+  const id = c.req.param("id");
+  const log = await service.getLog(id);
+  if (!log) {
+    return c.json({ error: "not_found", message: "Log not found", statusCode: 404 }, 404);
+  }
+  return c.json({ data: log });
+});
+
+// src/registry/routes/gateway-log-stats.ts
+import { Hono as Hono21 } from "hono";
+var gatewayLogStatsRoute = new Hono21().get("/stats", async (c) => {
+  const store = c.get("store");
+  const service = new GatewayLogService(store);
+  const filters = {
+    gatewayConfigName: c.req.query("gatewayConfig") ?? void 0,
+    environment: c.req.query("environment") ?? void 0,
+    from: c.req.query("from") ? new Date(c.req.query("from")) : void 0,
+    to: c.req.query("to") ? new Date(c.req.query("to")) : void 0
+  };
+  const stats = await service.getStats(filters);
+  return c.json({
+    data: stats.map((s) => ({
+      gatewayConfigName: s.gatewayConfigName,
+      environment: s.environment,
+      method: s.method,
+      routePath: s.routePath,
+      lastSeenAt: s.lastSeenAt.toISOString(),
+      totalCalls: s.totalCalls,
+      uniqueCallerIds: s.uniqueCallerIds
+    }))
+  });
+});
+
+// src/registry/server.ts
+function createApp(config, store) {
+  const app = new Hono22();
+  app.use("*", logger());
+  app.use("*", cors());
+  app.use("*", prettyJSON());
+  app.use("*", async (c, next) => {
+    c.set("store", store);
+    c.set("config", config);
+    await next();
+  });
+  app.route("/v1/specs", pushRoute);
+  app.route("/v1/specs", validateRoute);
+  app.route("/v1/specs", listRoute);
+  app.route("/v1/specs", getSpecRoute);
+  app.route("/v1/specs", deleteSpecRoute);
+  app.route("/v1/specs", versionsRoute);
+  app.route("/v1/specs", getVersionRoute);
+  app.route("/v1/specs", serveSpecRoute);
+  app.route("/v1/specs", compatReportRoute);
+  app.route("/v1/specs", compareVersionsRoute);
+  app.route("/v1/gateway-configs", pushGatewayConfigRoute);
+  app.route("/v1/gateway-configs", listGatewayConfigsRoute);
+  app.route("/v1/gateway-configs", getGatewayConfigRoute);
+  app.route("/v1/gateway-configs", gatewayConfigVersionsRoute);
+  app.route("/v1/gateway-configs", getGatewayConfigVersionRoute);
+  app.route("/v1/gateway-logs", ingestGatewayLogRoute);
+  app.route("/v1/gateway-logs", listGatewayLogsRoute);
+  app.route("/v1/gateway-logs", gatewayLogStatsRoute);
+  app.route("/v1/gateway-logs", getGatewayLogRoute);
+  app.route("/v1/health", healthRoute);
+  app.route("/", welcomeRoute);
+  return app;
+}
+
+// src/registry/config.ts
+var defaultConfig = {
+  port: 3750,
+  database: "sqlite",
+  sqlitePath: void 0,
+  gracePeriodDays: 30
+};
+
+// src/registry/storage/sqlite.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { sql, eq, and, desc } from "drizzle-orm";
+
+// src/registry/storage/schema.ts
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
+var specs = sqliteTable("specs", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+  type: text("type", { enum: ["openapi", "asyncapi"] }).notNull(),
+  description: text("description"),
+  owner: text("owner"),
+  sourceRepo: text("source_repo"),
+  tags: text("tags", { mode: "json" }).$type().default([]),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var specVersions = sqliteTable("spec_versions", {
+  id: text("id").primaryKey(),
+  specId: text("spec_id").notNull().references(() => specs.id),
+  semver: text("semver").notNull(),
+  content: text("content").notNull(),
+  checksum: text("checksum").notNull(),
+  gitRef: text("git_ref"),
+  pushedBy: text("pushed_by"),
+  compatibility: text("compatibility", { mode: "json" }).$type(),
+  previousVersion: text("previous_version"),
+  forceReason: text("force_reason"),
+  isPrerelease: integer("is_prerelease", { mode: "boolean" }).notNull().default(false),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_spec_versions_spec_id").on(table.specId),
+  index("idx_spec_versions_semver").on(table.specId, table.semver)
+]);
+var auditLog = sqliteTable("audit_log", {
+  id: text("id").primaryKey(),
+  action: text("action", { enum: ["spec.push", "spec.push.force", "spec.delete"] }).notNull(),
+  actor: text("actor").notNull(),
+  specName: text("spec_name").notNull(),
+  version: text("version"),
+  details: text("details", { mode: "json" }).$type(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_audit_log_spec_name").on(table.specName),
+  index("idx_audit_log_created_at").on(table.createdAt)
+]);
+var gatewayConfigs = sqliteTable("gateway_configs", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+  provider: text("provider", { enum: ["kong"] }).notNull(),
+  specName: text("spec_name").notNull(),
+  specSemver: text("spec_semver").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var gatewayConfigVersions = sqliteTable("gateway_config_versions", {
+  id: text("id").primaryKey(),
+  gatewayConfigId: text("gateway_config_id").notNull().references(() => gatewayConfigs.id),
+  routes: text("routes", { mode: "json" }).$type().notNull(),
+  environments: text("environments", { mode: "json" }).$type().notNull(),
+  callerIdentification: text("caller_identification", { mode: "json" }).$type(),
+  content: text("content").notNull(),
+  checksum: text("checksum").notNull(),
+  pushedBy: text("pushed_by"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_gateway_config_versions_config_id").on(table.gatewayConfigId)
+]);
+var httpLogs = sqliteTable("http_logs", {
+  id: text("id").primaryKey(),
+  provider: text("provider").notNull(),
+  gatewayConfigName: text("gateway_config_name").notNull(),
+  environment: text("environment").notNull(),
+  method: text("method").notNull(),
+  path: text("path").notNull(),
+  routePath: text("route_path"),
+  status: integer("status").notNull(),
+  callerId: text("caller_id"),
+  callerSource: text("caller_source"),
+  callerConfidence: text("caller_confidence").notNull(),
+  occurredAt: integer("occurred_at", { mode: "timestamp" }).notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_http_logs_config_env").on(table.gatewayConfigName, table.environment),
+  index("idx_http_logs_occurred_at").on(table.occurredAt),
+  index("idx_http_logs_caller").on(table.gatewayConfigName, table.environment, table.callerId)
+]);
+var provisions = sqliteTable("provisions", {
+  id: text("id").primaryKey(),
+  gatewayConfigName: text("gateway_config_name").notNull(),
+  gatewayConfigVersion: text("gateway_config_version").notNull(),
+  environment: text("environment").notNull(),
+  provider: text("provider", { enum: ["kong"] }).notNull(),
+  synced: integer("synced", { mode: "boolean" }).notNull().default(false),
+  actor: text("actor").notNull(),
+  details: text("details", { mode: "json" }).$type(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+}, (table) => [
+  index("idx_provisions_config_name").on(table.gatewayConfigName),
+  index("idx_provisions_created_at").on(table.createdAt)
+]);
+
+// src/registry/storage/sqlite.ts
+import { v4 as uuid5 } from "uuid";
+
+// src/registry/paths.ts
+var SQLITE_MIGRATIONS_FOLDER = new URL(
+  "../../drizzle/migrations/sqlite",
+  import.meta.url
+).pathname;
+var PG_MIGRATIONS_FOLDER = new URL(
+  "../../drizzle/migrations/pg",
+  import.meta.url
+).pathname;
+
+// src/registry/storage/sqlite.ts
+var MIGRATIONS_FOLDER = SQLITE_MIGRATIONS_FOLDER;
+var SQLiteSpecStore = class {
+  db;
+  constructor(dbPath) {
+    const sqlite = new Database(dbPath);
+    this.db = drizzle(sqlite);
+  }
+  async migrate() {
+    await migrate(this.db, {
+      migrationsFolder: MIGRATIONS_FOLDER
+    });
+  }
+  async getSpec(name) {
+    const rows = await this.db.select().from(specs).where(eq(specs.name, name)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapSpecRow(rows[0]);
+  }
+  async getSpecVersion(name, semver) {
+    const spec = await this.getSpec(name);
+    if (!spec) return null;
+    const rows = await this.db.select().from(specVersions).where(and(eq(specVersions.specId, spec.id), eq(specVersions.semver, semver))).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapVersionRow(rows[0]);
+  }
+  async getLatestVersion(name) {
+    const spec = await this.getSpec(name);
+    if (!spec) return null;
+    const rows = await this.db.select().from(specVersions).where(eq(specVersions.specId, spec.id)).orderBy(desc(specVersions.createdAt), desc(sql`rowid`)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapVersionRow(rows[0]);
+  }
+  async listSpecs(filters) {
+    const conditions = [];
+    if (filters?.type) conditions.push(eq(specs.type, filters.type));
+    if (filters?.owner) conditions.push(eq(specs.owner, filters.owner));
+    let rows = conditions.length > 0 ? await this.db.select().from(specs).where(and(...conditions)) : await this.db.select().from(specs);
+    if (filters?.tags && filters.tags.length > 0) {
+      rows = rows.filter((row) => {
+        const rowTags = row.tags ?? [];
+        return filters.tags.every((tag) => rowTags.includes(tag));
+      });
+    }
+    return rows.map((r) => this.mapSpecRow(r));
+  }
+  async listVersions(name, options) {
+    const spec = await this.getSpec(name);
+    if (!spec) return { versions: [], total: 0 };
+    const limit = options?.limit ?? 10;
+    const offset = options?.offset ?? 0;
+    const [countRow] = await this.db.select({ count: sql`count(*)` }).from(specVersions).where(eq(specVersions.specId, spec.id));
+    const total = Number(countRow?.count ?? 0);
+    const rows = await this.db.select().from(specVersions).where(eq(specVersions.specId, spec.id)).orderBy(desc(specVersions.createdAt), desc(sql`rowid`)).limit(limit).offset(offset);
+    return { versions: rows.map((r) => this.mapVersionRow(r)), total };
+  }
+  async pushSpecVersion(spec, version) {
+    const existingSpec = await this.getSpec(spec.name);
+    if (!existingSpec) {
+      await this.db.insert(specs).values({
+        id: spec.id,
+        name: spec.name,
+        type: spec.type,
+        description: spec.description ?? null,
+        owner: spec.owner ?? null,
+        sourceRepo: spec.sourceRepo ?? null,
+        tags: spec.tags ?? [],
+        createdAt: spec.createdAt,
+        updatedAt: spec.updatedAt
+      });
+    } else {
+      await this.db.update(specs).set({ updatedAt: /* @__PURE__ */ new Date() }).where(eq(specs.id, existingSpec.id));
+    }
+    const specId = existingSpec?.id ?? spec.id;
+    await this.db.insert(specVersions).values({
+      id: version.id,
+      specId,
+      semver: version.semver,
+      content: version.content,
+      checksum: version.checksum,
+      gitRef: version.gitRef ?? null,
+      pushedBy: version.pushedBy ?? null,
+      compatibility: version.compatibility ?? null,
+      previousVersion: version.previousVersion ?? null,
+      forceReason: version.forceReason ?? null,
+      isPrerelease: version.isPrerelease,
+      createdAt: version.createdAt
+    });
+    return version;
+  }
+  async deleteSpec(name) {
+    const existingSpec = await this.getSpec(name);
+    if (!existingSpec) return false;
+    await this.db.delete(specVersions).where(eq(specVersions.specId, existingSpec.id));
+    await this.db.delete(specs).where(eq(specs.id, existingSpec.id));
+    return true;
+  }
+  async getCompatReport(name, semver) {
+    const version = await this.getSpecVersion(name, semver);
+    return version?.compatibility ?? null;
+  }
+  async logAudit(action, actor, specName, version, details) {
+    await this.db.insert(auditLog).values({
+      id: uuid5(),
+      action,
+      actor,
+      specName,
+      version: version ?? null,
+      details: details ?? null,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  mapSpecRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      type: row.type,
+      description: row.description ?? void 0,
+      owner: row.owner ?? void 0,
+      sourceRepo: row.sourceRepo ?? void 0,
+      tags: row.tags ?? [],
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  mapVersionRow(row) {
+    return {
+      id: row.id,
+      specId: row.specId,
+      semver: row.semver,
+      content: row.content,
+      checksum: row.checksum,
+      gitRef: row.gitRef ?? void 0,
+      pushedBy: row.pushedBy ?? void 0,
+      compatibility: row.compatibility ?? void 0,
+      previousVersion: row.previousVersion ?? void 0,
+      forceReason: row.forceReason ?? void 0,
+      isPrerelease: row.isPrerelease,
+      createdAt: row.createdAt
+    };
+  }
+  // GatewayConfigStore implementation
+  async getGatewayConfig(name) {
+    const rows = await this.db.select().from(gatewayConfigs).where(eq(gatewayConfigs.name, name)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapGatewayConfigRow(rows[0]);
+  }
+  async listGatewayConfigs() {
+    const rows = await this.db.select().from(gatewayConfigs);
+    return rows.map((r) => this.mapGatewayConfigRow(r));
+  }
+  async getGatewayConfigVersion(name, versionId) {
+    const config = await this.getGatewayConfig(name);
+    if (!config) return null;
+    const rows = await this.db.select().from(gatewayConfigVersions).where(and(eq(gatewayConfigVersions.gatewayConfigId, config.id), eq(gatewayConfigVersions.id, versionId))).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapGatewayConfigVersionRow(rows[0]);
+  }
+  async getLatestGatewayConfigVersion(name) {
+    const config = await this.getGatewayConfig(name);
+    if (!config) return null;
+    const rows = await this.db.select().from(gatewayConfigVersions).where(eq(gatewayConfigVersions.gatewayConfigId, config.id)).orderBy(desc(gatewayConfigVersions.createdAt), desc(sql`rowid`)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapGatewayConfigVersionRow(rows[0]);
+  }
+  async listGatewayConfigVersions(name) {
+    const config = await this.getGatewayConfig(name);
+    if (!config) return [];
+    const rows = await this.db.select().from(gatewayConfigVersions).where(eq(gatewayConfigVersions.gatewayConfigId, config.id)).orderBy(desc(gatewayConfigVersions.createdAt), desc(sql`rowid`)).limit(5);
+    return rows.map((r) => this.mapGatewayConfigVersionRow(r));
+  }
+  async pushGatewayConfigVersion(config, version) {
+    const existingConfig = await this.getGatewayConfig(config.name);
+    if (!existingConfig) {
+      await this.db.insert(gatewayConfigs).values({
+        id: config.id,
+        name: config.name,
+        provider: config.provider,
+        specName: config.specName,
+        specSemver: config.specSemver,
+        createdAt: config.createdAt,
+        updatedAt: config.updatedAt
+      });
+    } else {
+      await this.db.update(gatewayConfigs).set({ updatedAt: /* @__PURE__ */ new Date(), specSemver: config.specSemver }).where(eq(gatewayConfigs.id, existingConfig.id));
+    }
+    const configId = existingConfig?.id ?? config.id;
+    await this.db.insert(gatewayConfigVersions).values({
+      id: version.id,
+      gatewayConfigId: configId,
+      routes: version.routes,
+      environments: version.environments,
+      callerIdentification: version.callerIdentification ?? null,
+      content: version.content,
+      checksum: version.checksum,
+      pushedBy: version.pushedBy ?? null,
+      createdAt: version.createdAt
+    });
+    const versions = await this.db.select().from(gatewayConfigVersions).where(eq(gatewayConfigVersions.gatewayConfigId, configId)).orderBy(desc(gatewayConfigVersions.createdAt), desc(sql`rowid`));
+    if (versions.length > 5) {
+      const toDelete = versions.slice(5);
+      for (const v of toDelete) {
+        await this.db.delete(gatewayConfigVersions).where(eq(gatewayConfigVersions.id, v.id));
+      }
+    }
+    return version;
+  }
+  async recordProvision(provision) {
+    await this.db.insert(provisions).values({
+      id: provision.id,
+      gatewayConfigName: provision.gatewayConfigName,
+      gatewayConfigVersion: provision.gatewayConfigVersion,
+      environment: provision.environment,
+      provider: provision.provider,
+      synced: provision.synced,
+      actor: provision.actor,
+      details: provision.details ?? null,
+      createdAt: provision.createdAt
+    });
+  }
+  async listProvisions(gatewayConfigName) {
+    const rows = gatewayConfigName ? await this.db.select().from(provisions).where(eq(provisions.gatewayConfigName, gatewayConfigName)).orderBy(desc(provisions.createdAt)) : await this.db.select().from(provisions).orderBy(desc(provisions.createdAt));
+    return rows.map((r) => ({
+      id: r.id,
+      gatewayConfigName: r.gatewayConfigName,
+      gatewayConfigVersion: r.gatewayConfigVersion,
+      environment: r.environment,
+      provider: r.provider,
+      synced: r.synced,
+      actor: r.actor,
+      details: r.details ?? void 0,
+      createdAt: r.createdAt
+    }));
+  }
+  mapGatewayConfigRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      provider: row.provider,
+      specName: row.specName,
+      specSemver: row.specSemver,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  mapGatewayConfigVersionRow(row) {
+    return {
+      id: row.id,
+      gatewayConfigId: row.gatewayConfigId,
+      routes: row.routes,
+      environments: row.environments,
+      callerIdentification: row.callerIdentification ?? void 0,
+      content: row.content,
+      checksum: row.checksum,
+      pushedBy: row.pushedBy ?? void 0,
+      createdAt: row.createdAt
+    };
+  }
+  async recordGatewayLog(log) {
+    await this.db.insert(httpLogs).values({
+      id: log.id,
+      provider: log.provider,
+      gatewayConfigName: log.gatewayConfigName,
+      environment: log.environment,
+      method: log.method,
+      path: log.path,
+      routePath: log.routePath ?? null,
+      status: log.status,
+      callerId: log.callerId ?? null,
+      callerSource: log.callerSource ?? null,
+      callerConfidence: log.callerConfidence,
+      occurredAt: log.occurredAt,
+      createdAt: log.createdAt
+    });
+  }
+  async listGatewayLogs(filters) {
+    const limit = filters.limit ?? 50;
+    const offset = filters.offset ?? 0;
+    let query = this.db.select().from(httpLogs);
+    const conditions = [];
+    if (filters.gatewayConfigName) {
+      conditions.push(eq(httpLogs.gatewayConfigName, filters.gatewayConfigName));
+    }
+    if (filters.environment) {
+      conditions.push(eq(httpLogs.environment, filters.environment));
+    }
+    if (filters.path) {
+      conditions.push(eq(httpLogs.path, filters.path));
+    }
+    if (filters.method) {
+      conditions.push(eq(httpLogs.method, filters.method));
+    }
+    if (filters.status !== void 0) {
+      conditions.push(eq(httpLogs.status, filters.status));
+    }
+    if (filters.from) {
+      conditions.push(sql`${httpLogs.occurredAt} >= ${filters.from.getTime()}`);
+    }
+    if (filters.to) {
+      conditions.push(sql`${httpLogs.occurredAt} <= ${filters.to.getTime()}`);
+    }
+    if (conditions.length > 0) {
+      query = query.where(and(...conditions));
+    }
+    const countResult = await this.db.select({ count: sql`count(*)` }).from(httpLogs).where(conditions.length > 0 ? and(...conditions) : void 0);
+    const total = countResult[0]?.count ?? 0;
+    const rows = await query.orderBy(desc(httpLogs.occurredAt)).limit(limit).offset(offset);
+    return {
+      logs: rows.map((r) => ({
+        id: r.id,
+        provider: r.provider,
+        gatewayConfigName: r.gatewayConfigName,
+        environment: r.environment,
+        method: r.method,
+        path: r.path,
+        routePath: r.routePath ?? void 0,
+        status: r.status,
+        callerId: r.callerId ?? void 0,
+        callerSource: r.callerSource ?? void 0,
+        callerConfidence: r.callerConfidence,
+        occurredAt: r.occurredAt,
+        createdAt: r.createdAt
+      })),
+      total
+    };
+  }
+  async getGatewayLog(id) {
+    const rows = await this.db.select().from(httpLogs).where(eq(httpLogs.id, id)).limit(1);
+    if (rows.length === 0) return null;
+    const r = rows[0];
+    return {
+      id: r.id,
+      provider: r.provider,
+      gatewayConfigName: r.gatewayConfigName,
+      environment: r.environment,
+      method: r.method,
+      path: r.path,
+      routePath: r.routePath ?? void 0,
+      status: r.status,
+      callerId: r.callerId ?? void 0,
+      callerSource: r.callerSource ?? void 0,
+      callerConfidence: r.callerConfidence,
+      occurredAt: r.occurredAt,
+      createdAt: r.createdAt
+    };
+  }
+  async getGatewayLogStats(_filters) {
+    const conditions = [];
+    if (_filters.gatewayConfigName) {
+      conditions.push(eq(httpLogs.gatewayConfigName, _filters.gatewayConfigName));
+    }
+    if (_filters.environment) {
+      conditions.push(eq(httpLogs.environment, _filters.environment));
+    }
+    if (_filters.from) {
+      conditions.push(sql`${httpLogs.occurredAt} >= ${_filters.from.getTime()}`);
+    }
+    if (_filters.to) {
+      conditions.push(sql`${httpLogs.occurredAt} <= ${_filters.to.getTime()}`);
+    }
+    const whereClause = conditions.length > 0 ? and(...conditions) : void 0;
+    const rows = await this.db.select({
+      gatewayConfigName: httpLogs.gatewayConfigName,
+      environment: httpLogs.environment,
+      method: httpLogs.method,
+      routePath: httpLogs.routePath,
+      lastSeenAt: sql`max(${httpLogs.occurredAt})`,
+      totalCalls: sql`count(*)`,
+      uniqueCallerIds: sql`count(distinct ${httpLogs.callerId})`
+    }).from(httpLogs).where(whereClause).groupBy(httpLogs.gatewayConfigName, httpLogs.environment, httpLogs.method, httpLogs.routePath);
+    return rows.map((r) => ({
+      gatewayConfigName: r.gatewayConfigName,
+      environment: r.environment,
+      method: r.method,
+      routePath: r.routePath ?? "/",
+      lastSeenAt: new Date(r.lastSeenAt),
+      totalCalls: r.totalCalls,
+      uniqueCallerIds: r.uniqueCallerIds
+    }));
+  }
+  async deleteGatewayLogsOlderThan(days) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    await this.db.delete(httpLogs).where(sql`${httpLogs.occurredAt} < ${cutoff.getTime()}`);
+  }
+};
+
+// src/registry/serve.ts
+async function startServer(userConfig) {
+  const config = { ...defaultConfig, ...userConfig };
+  if (!config.sqlitePath && config.database === "sqlite") {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
+    config.sqlitePath = path.join(homeDir, ".grapity", "registry.db");
+  }
+  if (config.database === "sqlite" && config.sqlitePath) {
+    const dir = path.dirname(config.sqlitePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  const store = new SQLiteSpecStore(config.sqlitePath);
+  await store.migrate();
+  const app = createApp(config, store);
+  serve({
+    fetch: app.fetch,
+    port: config.port
+  });
+  return app;
+}
+if (process.argv[1] === new URL(import.meta.url).pathname) {
+  startServer();
+}
+export {
+  startServer
+};