@ai-matrx/content-ir 0.8.0 → 0.10.0

package/dist/convert.cjs

@@ -0,0 +1,1680 @@
+'use strict';
+
+// core/kind-schema.types.ts
+var KIND_KEY = "__kind";
+function scalarArrayItemType(type) {
+  if (type === "number[]") return "number";
+  if (type === "boolean[]") return "boolean";
+  return "string";
+}
+
+// utils/text-case-converter.ts
+var DEFAULT_WORD_REPLACEMENTS = {
+  // Acronyms & initialisms
+  "api": "API",
+  "apis": "APIs",
+  "ui": "UI",
+  "ux": "UX",
+  "id": "ID",
+  "ids": "IDs",
+  "qr": "QR",
+  "ssr": "SSR",
+  "csr": "CSR",
+  "ssg": "SSG",
+  "isr": "ISR",
+  "spa": "SPA",
+  "pwa": "PWA",
+  "sdk": "SDK",
+  "sdks": "SDKs",
+  "cli": "CLI",
+  "tty": "TTY",
+  "repl": "REPL",
+  "ci": "CI",
+  "cd": "CD",
+  "cpu": "CPU",
+  "cpus": "CPUs",
+  "gpu": "GPU",
+  "gpus": "GPUs",
+  "ram": "RAM",
+  "rom": "ROM",
+  "ssd": "SSD",
+  "ssds": "SSDs",
+  "hdd": "HDD",
+  "hdds": "HDDs",
+  "kpi": "KPI",
+  "kpis": "KPIs",
+  "sla": "SLA",
+  "slas": "SLAs",
+  "slo": "SLO",
+  "slos": "SLOs",
+  "sli": "SLI",
+  "slis": "SLIs",
+  "dom": "DOM",
+  // Web, formats, protocols
+  "url": "URL",
+  "urls": "URLs",
+  "uri": "URI",
+  "uris": "URIs",
+  "http": "HTTP",
+  "https": "HTTPS",
+  "html": "HTML",
+  "css": "CSS",
+  "json": "JSON",
+  "yaml": "YAML",
+  "yml": "YML",
+  "toml": "TOML",
+  "csv": "CSV",
+  "pdf": "PDF",
+  "tsv": "TSV",
+  "jpg": "JPG",
+  "jpeg": "JPEG",
+  "png": "PNG",
+  "gif": "GIF",
+  "webp": "WebP",
+  "heic": "HEIC",
+  "heif": "HEIF",
+  "bmp": "BMP",
+  "tiff": "TIFF",
+  "ico": "ICO",
+  "xml": "XML",
+  "sql": "SQL",
+  "db": "DB",
+  "dbs": "DBs",
+  "nosql": "NoSQL",
+  "graphql": "GraphQL",
+  "grpc": "gRPC",
+  "rest": "REST",
+  "restful": "RESTful",
+  "websocket": "WebSocket",
+  "websockets": "WebSockets",
+  "webrtc": "WebRTC",
+  // Networking
+  "ip": "IP",
+  "ipv4": "IPv4",
+  "ipv6": "IPv6",
+  "dns": "DNS",
+  "dhcp": "DHCP",
+  "nat": "NAT",
+  "tcp": "TCP",
+  "udp": "UDP",
+  "icmp": "ICMP",
+  "ttl": "TTL",
+  "lan": "LAN",
+  "wan": "WAN",
+  "vlan": "VLAN",
+  "cdn": "CDN",
+  "ftp": "FTP",
+  "ssh": "SSH",
+  "tls": "TLS",
+  "ssl": "SSL",
+  // Security & crypto
+  "jwt": "JWT",
+  "jws": "JWS",
+  "jwe": "JWE",
+  "hmac": "HMAC",
+  "rsa": "RSA",
+  "ecdsa": "ECDSA",
+  "aes": "AES",
+  "pbkdf2": "PBKDF2",
+  "argon2": "Argon2",
+  "scrypt": "scrypt",
+  "totp": "TOTP",
+  "hotp": "HOTP",
+  "mfa": "MFA",
+  "2fa": "2FA",
+  "csrf": "CSRF",
+  "xss": "XSS",
+  "ssrf": "SSRF",
+  "rce": "RCE",
+  "dos": "DoS",
+  "ddos": "DDoS",
+  "mitm": "MITM",
+  "csp": "CSP",
+  "cors": "CORS",
+  "pii": "PII",
+  "phi": "PHI",
+  "gdpr": "GDPR",
+  "ccpa": "CCPA",
+  "hipaa": "HIPAA",
+  "rfc": "RFC",
+  // Platforms, langs, tools (single-token)
+  "javascript": "JavaScript",
+  "typescript": "TypeScript",
+  "jsx": "JSX",
+  "tsx": "TSX",
+  "node": "Node",
+  // (used when tokenized alone)
+  "deno": "Deno",
+  "bun": "Bun",
+  "react": "React",
+  "nextjs": "Next.js",
+  // if your tokenizer drops dots, keep this
+  "nodejs": "Node.js",
+  "postgresql": "PostgreSQL",
+  "postgres": "Postgres",
+  "mysql": "MySQL",
+  "sqlite": "SQLite",
+  "redis": "Redis",
+  "supabase": "Supabase",
+  "docker": "Docker",
+  "kubernetes": "Kubernetes",
+  "k8s": "Kubernetes",
+  "helm": "Helm",
+  "npm": "npm",
+  "pnpm": "pnpm",
+  "yarn": "Yarn",
+  "eslint": "ESLint",
+  "prettier": "Prettier",
+  "vite": "Vite",
+  "webpack": "Webpack",
+  "babel": "Babel",
+  // OS & vendors
+  "macos": "macOS",
+  "ios": "iOS",
+  "ipados": "iPadOS",
+  "watchos": "watchOS",
+  "tvos": "tvOS",
+  "windows": "Windows",
+  "linux": "Linux",
+  "ubuntu": "Ubuntu",
+  "github": "GitHub",
+  "gitlab": "GitLab",
+  "bitbucket": "Bitbucket",
+  // Data & analytics
+  "etl": "ETL",
+  "elt": "ELT",
+  "olap": "OLAP",
+  "oltp": "OLTP",
+  "bi": "BI",
+  // Time & locales
+  "utc": "UTC",
+  "gmt": "GMT",
+  "pst": "PST",
+  "pdt": "PDT",
+  "pt": "PT",
+  // Common “small words” to keep lowercase (unless first/last word)
+  "or": "or",
+  "and": "and",
+  "the": "the",
+  "of": "of",
+  "in": "in",
+  "to": "to",
+  "with": "with",
+  "as": "as",
+  "by": "by",
+  "for": "for",
+  "on": "on",
+  "at": "at",
+  "up": "up",
+  "a": "a",
+  "an": "an",
+  "is": "is",
+  "are": "are",
+  "was": "was",
+  "were": "were",
+  "be": "be",
+  "but": "but",
+  "nor": "nor",
+  "so": "so",
+  "yet": "yet",
+  "per": "per",
+  "via": "via",
+  // Latin abbreviations (tokenized as words in some pipelines)
+  "eg": "e.g.",
+  "ie": "i.e.",
+  "etc": "etc.",
+  "aka": "aka",
+  "vs": "vs.",
+  "v": "v.",
+  // Client abbreviations
+  "CIC": "CIC",
+  "AGR": "AGR",
+  "AGER": "AGER",
+  "DD": "DD",
+  "TS": "TS",
+  "TM": "TM",
+  "arman": "Arman"
+};
+var DEFAULT_OPTIONS = {
+  textCase: "title",
+  wordReplacements: DEFAULT_WORD_REPLACEMENTS,
+  trim: true
+};
+function formatText(text, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!text) return "";
+  let normalized = text.replace(/_/g, " ").replace(/-/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ");
+  if (opts.trim) {
+    normalized = normalized.trim();
+  }
+  let caseTransformed = normalized;
+  switch (opts.textCase) {
+    case "title":
+      caseTransformed = normalized.replace(
+        /\w\S*/g,
+        (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+      );
+      break;
+    case "sentence":
+      if (normalized.length > 0) {
+        caseTransformed = normalized.charAt(0).toUpperCase() + normalized.slice(1).toLowerCase();
+      }
+      break;
+    case "lower":
+      caseTransformed = normalized.toLowerCase();
+      break;
+    case "upper":
+      caseTransformed = normalized.toUpperCase();
+      break;
+  }
+  let result = caseTransformed;
+  if (opts.wordReplacements) {
+    Object.entries(opts.wordReplacements).forEach(([key, value]) => {
+      const regex = new RegExp(`\\b${key}\\b`, "gi");
+      result = result.replace(regex, value);
+    });
+  }
+  return result;
+}
+
+// core/schema-structure.ts
+function formatBlockLabel(key) {
+  return formatText(key, { textCase: "title" });
+}
+
+// convert/openai-schema-converter.ts
+function requiredNullableFlags(required, nullable) {
+  return {
+    ...required ? { required: true } : {},
+    ...nullable ? { nullable: true } : {}
+  };
+}
+var METADATA_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "title",
+  "default",
+  "examples",
+  "format",
+  "minimum",
+  "maximum",
+  "multipleOf",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "pattern",
+  "const",
+  "$schema",
+  "$id",
+  "deprecated",
+  "readOnly",
+  "writeOnly"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function fieldSchemaSummary(field) {
+  if (field.type === "enum") {
+    return `enum(${field.values.join("|")}${field.open ? "|+any" : ""})${field.required ? "*" : ""}`;
+  }
+  if (field.type === "array") {
+    return `array<${field.itemKinds.join("|")}>${field.required ? "*" : ""}`;
+  }
+  if (field.type === "inline_object") {
+    return `inline{${Object.keys(field.fields).join(",")}}${field.required ? "*" : ""}`;
+  }
+  if (field.type === "object") {
+    return `object:${field.kind}${field.required ? "*" : ""}`;
+  }
+  if (field.type === "union") {
+    const members = [...field.scalars, ...field.kinds ?? []];
+    return `union(${members.join("|")})${field.required ? "*" : ""}`;
+  }
+  if (field.type === "record") {
+    return `record(${field.values})${field.required ? "*" : ""}`;
+  }
+  return `${field.type}${field.required ? "*" : ""}${field.nullable ? "?" : ""}`;
+}
+function resolvePrimaryType(node) {
+  const raw = node.type;
+  if (typeof raw === "string") {
+    const t = raw === "integer" ? "number" : raw;
+    return { type: t, nullable: false, members: [t] };
+  }
+  if (Array.isArray(raw)) {
+    const types = raw.filter((t) => typeof t === "string");
+    const nullable = types.includes("null");
+    const members = [
+      ...new Set(
+        types.filter((t) => t !== "null").map((t) => t === "integer" ? "number" : t)
+      )
+    ];
+    const primary = members[0] ?? (nullable && types.length === 1 ? "null" : null);
+    return { type: primary ?? null, nullable, members };
+  }
+  if (node.enum) return { type: "string", nullable: false, members: ["string"] };
+  if (node.properties)
+    return { type: "object", nullable: false, members: ["object"] };
+  if (node.items)
+    return { type: "array", nullable: false, members: ["array"] };
+  return { type: null, nullable: false, members: [] };
+}
+function carriedMetadataKeys(field) {
+  if (field === null) return /* @__PURE__ */ new Set();
+  const carried = /* @__PURE__ */ new Set(["description", "default"]);
+  if (field.type === "number") {
+    carried.add("minimum");
+    carried.add("maximum");
+    carried.add("multipleOf");
+  }
+  return carried;
+}
+function collectDropped(node, path, carriedField = null) {
+  const carried = carriedMetadataKeys(carriedField);
+  const dropped = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (METADATA_KEYS.has(key) && !carried.has(key)) {
+      dropped[key] = value;
+    }
+  }
+  if (Object.keys(dropped).length > 0) {
+    return [{ path, dropped }];
+  }
+  return [];
+}
+function attachNodeMetadata(node, field) {
+  let out = field;
+  if (typeof node.description === "string" && out.description === void 0) {
+    out = { ...out, description: node.description };
+  }
+  if (node.default !== void 0 && out.default === void 0) {
+    out = { ...out, default: node.default };
+  }
+  if (out.type === "number") {
+    const bounds = {};
+    if (typeof node.minimum === "number" && out.min === void 0) {
+      bounds.min = node.minimum;
+    }
+    if (typeof node.maximum === "number" && out.max === void 0) {
+      bounds.max = node.maximum;
+    }
+    if (typeof node.multipleOf === "number" && out.step === void 0) {
+      bounds.step = node.multipleOf;
+    }
+    if (Object.keys(bounds).length > 0) out = { ...out, ...bounds };
+  }
+  return out;
+}
+function synthesizeItemKindSlug(schemaName, fieldName) {
+  const base = fieldName.endsWith("ies") ? `${fieldName.slice(0, -3)}y` : fieldName.endsWith("s") ? fieldName.slice(0, -1) : fieldName;
+  return `${schemaName}_${base}`;
+}
+function makeKindJsonSchemaProperty(kindSlug, strict) {
+  const base = {
+    type: "string",
+    description: "Block discriminator for render pipeline."
+  };
+  if (strict) {
+    return { ...base, const: kindSlug };
+  }
+  return { ...base, enum: [kindSlug] };
+}
+function injectKindIntoObjectSchema(objectSchema, kindSlug, strict) {
+  const clone = deepClone(objectSchema);
+  const properties = isRecord(clone.properties) ? { ...clone.properties } : {};
+  properties[KIND_KEY] = makeKindJsonSchemaProperty(kindSlug, strict);
+  const required = Array.isArray(clone.required) ? clone.required.filter((k) => typeof k === "string") : [];
+  const nextRequired = required.includes(KIND_KEY) ? required : [KIND_KEY, ...required];
+  return {
+    ...clone,
+    properties,
+    required: nextRequired,
+    ...strict ? { additionalProperties: false } : {}
+  };
+}
+function injectKindsIntoRootSchema(rootSchema, rootKindSlug, arrayBindings, strict) {
+  let updated = injectKindIntoObjectSchema(rootSchema, rootKindSlug, strict);
+  if (!isRecord(updated.properties)) {
+    return updated;
+  }
+  const properties = { ...updated.properties };
+  for (const binding of arrayBindings) {
+    const fieldNode = properties[binding.arrayField];
+    if (!isRecord(fieldNode)) continue;
+    const items = fieldNode.items;
+    const itemNode = Array.isArray(items) ? items[0] : items;
+    if (!isRecord(itemNode)) continue;
+    const updatedItem = injectKindIntoObjectSchema(
+      itemNode,
+      binding.itemKindSlug,
+      strict
+    );
+    properties[binding.arrayField] = {
+      ...fieldNode,
+      items: updatedItem
+    };
+  }
+  return { ...updated, properties };
+}
+function buildAgentSchemaWithRenderBlockSupport(input, rootKindSlug, arrayBindings, strict) {
+  if (!isRecord(input)) return null;
+  const normalized = normalizeAiSchemaInput(input);
+  if (!normalized.rootSchema) return null;
+  if (normalized.rootSchema.type !== "object" && !isRecord(normalized.rootSchema.properties)) {
+    return deepClone(input);
+  }
+  const updatedRoot = injectKindsIntoRootSchema(
+    normalized.rootSchema,
+    rootKindSlug,
+    arrayBindings,
+    strict
+  );
+  if (isRecord(input.schema) && typeof input.name === "string") {
+    return {
+      ...deepClone(input),
+      schema: updatedRoot
+    };
+  }
+  if (isRecord(input.json_schema)) {
+    const inner = buildAgentSchemaWithRenderBlockSupport(
+      input.json_schema,
+      rootKindSlug,
+      arrayBindings,
+      strict
+    );
+    return inner ? { ...deepClone(input), json_schema: inner } : null;
+  }
+  if (typeof input.name === "string") {
+    return {
+      ...deepClone(input),
+      schema: updatedRoot
+    };
+  }
+  return updatedRoot;
+}
+function resolveRef(ref, ctx) {
+  if (ref === "#" || ref === "#/") {
+    return { slug: ctx.schemaName, node: ctx.rootSchema };
+  }
+  const match = /^#\/(?:\$defs|definitions)\/(.+)$/.exec(ref);
+  if (!match) return null;
+  const name = decodeURIComponent(
+    (match[1] ?? "").replace(/~1/g, "/").replace(/~0/g, "~")
+  );
+  const node = ctx.defs[name];
+  if (!isRecord(node)) return null;
+  const declared = isRecord(node.properties) ? readBlockKindFromProperties(node.properties) : null;
+  return { slug: declared ?? name, node };
+}
+function refToObjectField(resolved, path, ctx) {
+  if (ctx.refsInProgress.has(resolved.slug)) return;
+  ctx.refsInProgress.add(resolved.slug);
+  try {
+    registerDeclaredKindDraft(resolved.slug, resolved.node, path, ctx);
+  } finally {
+    ctx.refsInProgress.delete(resolved.slug);
+  }
+}
+function isAnyValueSchema(node) {
+  return node.type === void 0 && node.enum === void 0 && node.const === void 0 && node.properties === void 0 && node.items === void 0 && node.additionalProperties === void 0 && node.anyOf === void 0 && node.oneOf === void 0 && node.allOf === void 0 && node.$ref === void 0;
+}
+function registerDeclaredKindDraft(declaredKind, objectNode, path, ctx) {
+  if (ctx.blockSchemas.some((draft) => draft.slug === declaredKind)) return;
+  if (!isRecord(objectNode.properties)) return;
+  const memberRequired = new Set(
+    Array.isArray(objectNode.required) ? objectNode.required.filter((k) => typeof k === "string") : []
+  );
+  const fields = {};
+  for (const [propName, propNode] of Object.entries(objectNode.properties)) {
+    if (!isRecord(propNode)) continue;
+    if (propName === KIND_KEY) continue;
+    fields[propName] = convertFieldOrWiden(
+      propName,
+      propNode,
+      memberRequired.has(propName),
+      `${path}.${propName}`,
+      ctx
+    );
+  }
+  ctx.blockSchemas.push({
+    slug: declaredKind,
+    label: formatBlockLabel(declaredKind),
+    fields
+  });
+}
+function convertFieldOrWiden(fieldName, node, required, path, ctx) {
+  const before = ctx.problems.length;
+  const converted = convertProperty(fieldName, node, required, path, ctx);
+  if (converted) return converted;
+  for (let i = before; i < ctx.problems.length; i++) {
+    const problem = ctx.problems[i];
+    if (problem && problem.severity === "error") problem.severity = "warning";
+  }
+  ctx.problems.push({
+    severity: "warning",
+    path,
+    message: `Field "${fieldName}" has no exact field type \u2014 carried as any JSON value (json) rather than dropped from the kind.`
+  });
+  return { ...requiredNullableFlags(required), type: "json" };
+}
+function convertProperty(fieldName, node, required, path, ctx) {
+  const core = convertPropertyCore(fieldName, node, required, path, ctx);
+  const field = core === null ? null : attachNodeMetadata(node, core);
+  ctx.droppedMetadata.push(...collectDropped(node, path, field));
+  return field;
+}
+function convertPropertyCore(fieldName, node, required, path, ctx) {
+  if (typeof node.$ref === "string") {
+    const resolved = resolveRef(node.$ref, ctx);
+    if (!resolved) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: `Unresolvable $ref ("${node.$ref}") \u2014 only "#", "#/$defs/<name>" and "#/definitions/<name>" are supported.`
+      });
+      return null;
+    }
+    refToObjectField(resolved, path, ctx);
+    return {
+      ...requiredNullableFlags(required),
+      type: "object",
+      kind: resolved.slug
+    };
+  }
+  if (Array.isArray(node.anyOf) || Array.isArray(node.oneOf)) {
+    const variants = node.anyOf ?? node.oneOf;
+    const scalarTypes = /* @__PURE__ */ new Set();
+    const enumVariantSets = [];
+    const memberKinds = [];
+    const anonymousObjects = [];
+    let sawNull = false;
+    let unsupported = false;
+    for (const variant of variants) {
+      if (!isRecord(variant)) {
+        unsupported = true;
+        continue;
+      }
+      if (typeof variant.$ref === "string") {
+        const resolvedVariant = resolveRef(variant.$ref, ctx);
+        if (!resolvedVariant) {
+          ctx.problems.push({
+            severity: "error",
+            path,
+            message: `Unresolvable $ref inside anyOf/oneOf ("${variant.$ref}").`
+          });
+          unsupported = true;
+          continue;
+        }
+        refToObjectField(resolvedVariant, path, ctx);
+        memberKinds.push(resolvedVariant.slug);
+        continue;
+      }
+      const { type: type2, nullable: nullable2 } = resolvePrimaryType(variant);
+      if (nullable2) sawNull = true;
+      if (type2 === "null") {
+        sawNull = true;
+        continue;
+      }
+      if (type2 === "string" && Array.isArray(variant.enum)) {
+        enumVariantSets.push(
+          variant.enum.filter((v) => typeof v === "string")
+        );
+        continue;
+      }
+      if (type2 === "string" || type2 === "number" || type2 === "boolean") {
+        scalarTypes.add(type2);
+        continue;
+      }
+      if (type2 === "object" && isRecord(variant.properties)) {
+        const declared = readBlockKindFromProperties(variant.properties);
+        if (declared) {
+          memberKinds.push(declared);
+          registerDeclaredKindDraft(declared, variant, `${path}<${declared}>`, ctx);
+        } else {
+          anonymousObjects.push(variant);
+        }
+        continue;
+      }
+      unsupported = true;
+    }
+    if (unsupported) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "anyOf/oneOf with unsupported variants cannot be converted automatically."
+      });
+      return null;
+    }
+    if (enumVariantSets.length > 0 && anonymousObjects.length === 0 && memberKinds.length === 0 && [...scalarTypes].every((s) => s === "string")) {
+      const values = [...new Set(enumVariantSets.flat())];
+      const open = scalarTypes.has("string");
+      return {
+        ...requiredNullableFlags(required, sawNull),
+        type: "enum",
+        values,
+        ...open ? { open: true } : {}
+      };
+    }
+    if (enumVariantSets.length > 0) {
+      ctx.problems.push({
+        severity: "warning",
+        path,
+        message: "anyOf/oneOf mixes an enum variant with non-string members \u2014 enum widened to string within the union."
+      });
+      scalarTypes.add("string");
+    }
+    if (anonymousObjects.length === 1 && scalarTypes.size === 0 && memberKinds.length === 0) {
+      const [sole] = anonymousObjects;
+      const converted = sole ? convertProperty(fieldName, sole, required, path, ctx) : null;
+      if (!converted) return null;
+      return sawNull ? { ...converted, nullable: true } : converted;
+    }
+    if (anonymousObjects.length > 0) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "anyOf/oneOf mixing anonymous objects with other variants cannot be converted \u2014 declare __kind on each object variant."
+      });
+      return null;
+    }
+    if (scalarTypes.size === 1 && memberKinds.length === 0) {
+      const [scalar] = [...scalarTypes];
+      if (scalar) {
+        return { ...requiredNullableFlags(required, sawNull), type: scalar };
+      }
+    }
+    if (scalarTypes.size > 0 || memberKinds.length > 0) {
+      ctx.problems.push({
+        severity: "warning",
+        path,
+        message: `Converted anyOf/oneOf to union of: ${[
+          ...scalarTypes,
+          ...memberKinds
+        ].join(", ")}.`
+      });
+      return {
+        ...requiredNullableFlags(required, sawNull),
+        type: "union",
+        scalars: [...scalarTypes],
+        ...memberKinds.length > 0 ? { kinds: memberKinds } : {}
+      };
+    }
+    ctx.problems.push({
+      severity: "warning",
+      path,
+      message: "anyOf/oneOf carried only null variants \u2014 widened to json (any value)."
+    });
+    return { ...requiredNullableFlags(required), type: "json" };
+  }
+  if (Array.isArray(node.allOf)) {
+    ctx.problems.push({
+      severity: "warning",
+      path,
+      message: "allOf merged using first object branch only."
+    });
+    const objectBranch = node.allOf.find(
+      (b) => b.properties
+    );
+    if (objectBranch) {
+      return convertProperty(fieldName, objectBranch, required, path, ctx);
+    }
+  }
+  if (isAnyValueSchema(node)) {
+    ctx.problems.push({
+      severity: "info",
+      path,
+      message: `Typeless schema at "${path || "(root)"}" \u2014 any JSON value (json).`
+    });
+    return { ...requiredNullableFlags(required), type: "json" };
+  }
+  const { type, nullable, members } = resolvePrimaryType(node);
+  if (members.length > 1) {
+    const objectish = members.some((m) => m === "object" || m === "array");
+    if (objectish) {
+      ctx.problems.push({
+        severity: "info",
+        path,
+        message: `Union of [${members.join(", ")}] at "${path || "(root)"}" spans objects/arrays \u2014 carried as any JSON value (json).`
+      });
+      return { ...requiredNullableFlags(required), type: "json" };
+    }
+    const scalars = members.filter(
+      (m) => m === "string" || m === "number" || m === "boolean"
+    );
+    if (scalars.length === members.length && scalars.length > 1) {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "union",
+        scalars
+      };
+    }
+    ctx.problems.push({
+      severity: "warning",
+      path,
+      message: `Union of [${members.join(", ")}] at "${path || "(root)"}" has no exact field type \u2014 carried as any JSON value (json) rather than narrowed to "${type}".`
+    });
+    return { ...requiredNullableFlags(required), type: "json" };
+  }
+  if (type === "string") {
+    if (Array.isArray(node.enum)) {
+      const values = node.enum.filter(
+        (v) => typeof v === "string"
+      );
+      if (values.length !== node.enum.length) {
+        ctx.problems.push({
+          severity: "warning",
+          path,
+          message: "Enum contains non-string values; non-strings dropped."
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "enum",
+        values
+      };
+    }
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "string"
+    };
+  }
+  if (type === "number") {
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "number"
+    };
+  }
+  if (type === "boolean") {
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "boolean"
+    };
+  }
+  if (type === "array") {
+    const items = node.items;
+    if (!items) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "Array field is missing items schema."
+      });
+      return null;
+    }
+    const itemNode = Array.isArray(items) ? items[0] : items;
+    if (!isRecord(itemNode)) {
+      ctx.problems.push({
+        severity: "error",
+        path,
+        message: "Array items schema must be an object."
+      });
+      return null;
+    }
+    if (typeof itemNode.$ref === "string") {
+      const resolvedItem = resolveRef(itemNode.$ref, ctx);
+      if (!resolvedItem) {
+        ctx.problems.push({
+          severity: "error",
+          path: `${path}[]`,
+          message: `Unresolvable $ref in array items ("${itemNode.$ref}").`
+        });
+        return null;
+      }
+      refToObjectField(resolvedItem, `${path}[]`, ctx);
+      ctx.arrayBindings.push({
+        arrayField: fieldName,
+        itemKindSlug: resolvedItem.slug
+      });
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "array",
+        itemKinds: [resolvedItem.slug]
+      };
+    }
+    if (isAnyValueSchema(itemNode)) {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "json[]"
+      };
+    }
+    const itemVariants = Array.isArray(itemNode.anyOf) ? itemNode.anyOf : Array.isArray(itemNode.oneOf) ? itemNode.oneOf : null;
+    if (itemVariants) {
+      const itemEnumSets = [];
+      let itemPlainString = false;
+      let itemsAllString = true;
+      for (const variant of itemVariants) {
+        if (!isRecord(variant) || resolvePrimaryType(variant).type !== "string") {
+          itemsAllString = false;
+          break;
+        }
+        if (Array.isArray(variant.enum)) {
+          itemEnumSets.push(
+            variant.enum.filter((v) => typeof v === "string")
+          );
+        } else {
+          itemPlainString = true;
+        }
+      }
+      if (itemsAllString && itemEnumSets.length > 0) {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "string[]",
+          values: [...new Set(itemEnumSets.flat())],
+          ...itemPlainString ? { open: true } : {}
+        };
+      }
+      const itemKinds = [];
+      for (const variant of itemVariants) {
+        if (isRecord(variant) && typeof variant.$ref === "string") {
+          const resolvedVariant = resolveRef(variant.$ref, ctx);
+          if (!resolvedVariant) {
+            ctx.problems.push({
+              severity: "error",
+              path: `${path}[]`,
+              message: `Unresolvable $ref in array items anyOf ("${variant.$ref}").`
+            });
+            return null;
+          }
+          itemKinds.push(resolvedVariant.slug);
+          refToObjectField(resolvedVariant, `${path}[]<${resolvedVariant.slug}>`, ctx);
+          ctx.arrayBindings.push({
+            arrayField: fieldName,
+            itemKindSlug: resolvedVariant.slug
+          });
+          continue;
+        }
+        if (!isRecord(variant) || !isRecord(variant.properties)) {
+          ctx.problems.push({
+            severity: "error",
+            path: `${path}[]`,
+            message: "Array items anyOf/oneOf variants must be inline objects declaring __kind, or $refs to defs."
+          });
+          return null;
+        }
+        const declared = readBlockKindFromProperties(variant.properties);
+        if (!declared) {
+          ctx.problems.push({
+            severity: "error",
+            path: `${path}[]`,
+            message: "Array items anyOf/oneOf variant is missing a __kind const/enum declaration."
+          });
+          return null;
+        }
+        itemKinds.push(declared);
+        registerDeclaredKindDraft(declared, variant, `${path}[]<${declared}>`, ctx);
+        ctx.arrayBindings.push({ arrayField: fieldName, itemKindSlug: declared });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "array",
+        itemKinds
+      };
+    }
+    const itemType = resolvePrimaryType(itemNode).type;
+    if (itemType === "string") {
+      if (Array.isArray(itemNode.enum)) {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "string[]",
+          values: itemNode.enum.filter(
+            (v) => typeof v === "string"
+          )
+        };
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "string[]"
+      };
+    }
+    if (itemType === "number") {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "number[]"
+      };
+    }
+    if (itemType === "boolean") {
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "boolean[]"
+      };
+    }
+    if (itemType === "object" && isRecord(itemNode.properties)) {
+      const declaredItemKind = readBlockKindFromProperties(itemNode.properties);
+      const itemKindSlug = declaredItemKind ?? synthesizeItemKindSlug(ctx.schemaName, fieldName);
+      const itemRequired = new Set(
+        Array.isArray(itemNode.required) ? itemNode.required.filter((k) => typeof k === "string") : []
+      );
+      const itemFields = {};
+      for (const [propName, propNode] of Object.entries(itemNode.properties)) {
+        if (!isRecord(propNode)) continue;
+        if (propName === KIND_KEY) continue;
+        itemFields[propName] = convertFieldOrWiden(
+          propName,
+          propNode,
+          itemRequired.has(propName),
+          `${path}[].${propName}`,
+          ctx
+        );
+      }
+      const alreadyHasBlockKind = propNameIsBlockKind(itemNode.properties) || itemRequired.has(KIND_KEY);
+      ctx.arrayBindings.push({
+        arrayField: fieldName,
+        itemKindSlug
+      });
+      if (!ctx.blockSchemas.some((draft) => draft.slug === itemKindSlug)) {
+        ctx.blockSchemas.push({
+          slug: itemKindSlug,
+          label: declaredItemKind ? formatBlockLabel(itemKindSlug) : formatBlockLabel(`${ctx.schemaName}_${fieldName}_item`),
+          fields: itemFields
+        });
+      }
+      if (!alreadyHasBlockKind) {
+        ctx.problems.push({
+          severity: "warning",
+          path: `${path}[]`,
+          message: `Array "${fieldName}" items need __kind:"${itemKindSlug}" at runtime (OPTION 1: server injects, OPTION 2: use agent schema with __kind).`
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "array",
+        itemKinds: [itemKindSlug]
+      };
+    }
+    ctx.problems.push({
+      severity: "error",
+      path,
+      message: `Unsupported array items type "${itemType ?? "unknown"}".`
+    });
+    return null;
+  }
+  if (type === "object") {
+    const ap = node.additionalProperties;
+    const apIsOpen = ap === true || isRecord(ap) && isAnyValueSchema(ap);
+    if (isRecord(node.properties)) {
+      const nestedRequired = new Set(
+        Array.isArray(node.required) ? node.required.filter((k) => typeof k === "string") : []
+      );
+      const nestedFields = {};
+      for (const [propName, propNode] of Object.entries(node.properties)) {
+        if (!isRecord(propNode)) continue;
+        if (propName === KIND_KEY) continue;
+        nestedFields[propName] = convertFieldOrWiden(
+          propName,
+          propNode,
+          nestedRequired.has(propName),
+          `${path}.${propName}`,
+          ctx
+        );
+      }
+      const referencedKind = readBlockKindFromProperties(node.properties);
+      if (referencedKind) {
+        if (!ctx.refsInProgress.has(referencedKind)) {
+          ctx.refsInProgress.add(referencedKind);
+          try {
+            registerDeclaredKindDraft(referencedKind, node, path, ctx);
+          } finally {
+            ctx.refsInProgress.delete(referencedKind);
+          }
+        }
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "object",
+          kind: referencedKind
+        };
+      }
+      if (Object.keys(nestedFields).length === 0 && !apIsOpen && isRecord(ap) && KIND_KEY in node.properties) {
+        const apType = resolvePrimaryType(ap).type;
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "record",
+          values: apType === "string" || apType === "number" || apType === "boolean" ? apType : "json"
+        };
+      }
+      let open = apIsOpen;
+      if (!apIsOpen && isRecord(ap)) {
+        ctx.problems.push({
+          severity: "warning",
+          path,
+          message: "Typed additionalProperties alongside declared properties is not representable \u2014 treated as an OPEN object (extra values unconstrained)."
+        });
+        open = true;
+      } else if (ap === false) {
+        ctx.droppedMetadata.push({
+          path,
+          dropped: { additionalProperties: false }
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "inline_object",
+        fields: nestedFields,
+        ...open ? { open: true } : {}
+      };
+    }
+    if (apIsOpen || ap === void 0) {
+      if (ap === void 0) {
+        ctx.problems.push({
+          severity: "info",
+          path,
+          message: `Bare object schema at "${path || "(root)"}" \u2014 record of any JSON values.`
+        });
+      }
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "record",
+        values: "json"
+      };
+    }
+    if (isRecord(ap)) {
+      const apType = resolvePrimaryType(ap).type;
+      if (apType === "string" || apType === "number" || apType === "boolean") {
+        return {
+          ...requiredNullableFlags(required, nullable),
+          type: "record",
+          values: apType
+        };
+      }
+      ctx.problems.push({
+        severity: "warning",
+        path,
+        message: `Record value schema at "${path}" is not scalar \u2014 widened to record of any JSON values.`
+      });
+      return {
+        ...requiredNullableFlags(required, nullable),
+        type: "record",
+        values: "json"
+      };
+    }
+    return {
+      ...requiredNullableFlags(required, nullable),
+      type: "inline_object",
+      fields: {}
+    };
+  }
+  ctx.problems.push({
+    severity: "error",
+    path,
+    message: `Unsupported or missing JSON Schema type at "${path}".`
+  });
+  return null;
+}
+function propNameIsBlockKind(properties) {
+  return KIND_KEY in properties;
+}
+function readBlockKindFromProperties(properties) {
+  const kindProp = properties[KIND_KEY];
+  if (!isRecord(kindProp)) return null;
+  if (typeof kindProp.const === "string") return kindProp.const;
+  if (Array.isArray(kindProp.enum) && typeof kindProp.enum[0] === "string") {
+    return kindProp.enum[0];
+  }
+  return null;
+}
+function normalizeAiSchemaInput(input) {
+  const parseErrors = [];
+  if (!isRecord(input)) {
+    return {
+      name: null,
+      strict: null,
+      rootSchema: null,
+      parseErrors: ["Input must be a JSON object."]
+    };
+  }
+  if (isRecord(input.json_schema)) {
+    return normalizeAiSchemaInput(input.json_schema);
+  }
+  if (isRecord(input.schema) && typeof input.name === "string") {
+    return {
+      name: input.name,
+      strict: typeof input.strict === "boolean" ? input.strict : null,
+      rootSchema: input.schema,
+      parseErrors: []
+    };
+  }
+  if (typeof input.type === "string" || Array.isArray(input.type) || input.properties || input.items) {
+    const name = typeof input.name === "string" ? input.name : typeof input.title === "string" ? input.title : null;
+    return {
+      name,
+      strict: typeof input.strict === "boolean" ? input.strict : null,
+      rootSchema: input,
+      parseErrors: []
+    };
+  }
+  parseErrors.push(
+    "Expected OpenAI output_schema shape { name, schema } or a root JSON Schema object."
+  );
+  return { name: null, strict: null, rootSchema: null, parseErrors };
+}
+function convertAiSchemaToBlockFields(schemaName, rootSchema, strict) {
+  const rawDefs = isRecord(rootSchema.$defs) ? rootSchema.$defs : isRecord(rootSchema.definitions) ? rootSchema.definitions : {};
+  const defs = {};
+  for (const [name, node] of Object.entries(rawDefs)) {
+    if (isRecord(node)) defs[name] = node;
+  }
+  const ctx = {
+    schemaName,
+    strict,
+    problems: [],
+    droppedMetadata: [],
+    blockSchemas: [],
+    arrayBindings: [],
+    defs,
+    rootSchema,
+    refsInProgress: /* @__PURE__ */ new Set()
+  };
+  ctx.droppedMetadata.push(...collectDropped(rootSchema, ""));
+  const rootAp = rootSchema.additionalProperties;
+  const rootIsOpen = rootAp === true || isRecord(rootAp) && isAnyValueSchema(rootAp);
+  const properties = rootSchema.properties;
+  if (!isRecord(properties) || rootIsOpen) {
+    const rootField = convertProperty("$root", rootSchema, false, "$root", ctx);
+    if (!rootField) {
+      ctx.problems.push({
+        severity: "error",
+        path: "",
+        message: "Root schema could not be converted (see problems above) \u2014 expected an object with properties, a scalar/array/json root, or an open object."
+      });
+      return emptyConversionResult(schemaName, strict, ctx);
+    }
+    ctx.blockSchemas.unshift({
+      slug: schemaName,
+      label: formatBlockLabel(schemaName),
+      fields: {},
+      root: rootField
+    });
+    return {
+      schemaName,
+      strict,
+      blockSchemas: ctx.blockSchemas,
+      problems: ctx.problems,
+      droppedMetadata: ctx.droppedMetadata
+    };
+  }
+  const required = new Set(
+    Array.isArray(rootSchema.required) ? rootSchema.required.filter((k) => typeof k === "string") : []
+  );
+  const convertedFields = {};
+  for (const [fieldName, fieldNode] of Object.entries(properties)) {
+    if (!isRecord(fieldNode)) continue;
+    if (fieldName === KIND_KEY) continue;
+    convertedFields[fieldName] = convertFieldOrWiden(
+      fieldName,
+      fieldNode,
+      required.has(fieldName),
+      fieldName,
+      ctx
+    );
+  }
+  const rootHasKind = propNameIsBlockKind(properties) || required.has(KIND_KEY);
+  if (!rootHasKind) {
+    ctx.problems.push({
+      severity: "warning",
+      path: "",
+      message: `Root object needs __kind:"${schemaName}" at runtime (OPTION 1: server injects, OPTION 2: use agent schema with __kind).`
+    });
+  }
+  const rootDraft = {
+    slug: schemaName,
+    label: formatBlockLabel(schemaName),
+    fields: convertedFields
+  };
+  ctx.blockSchemas.unshift(rootDraft);
+  if (typeof rootSchema.additionalProperties === "boolean") {
+    ctx.droppedMetadata.push({
+      path: "",
+      dropped: { additionalProperties: rootSchema.additionalProperties }
+    });
+  }
+  if (strict) {
+    ctx.droppedMetadata.push({
+      path: "",
+      dropped: { strict }
+    });
+  }
+  return {
+    schemaName,
+    strict,
+    blockSchemas: ctx.blockSchemas,
+    problems: ctx.problems,
+    droppedMetadata: ctx.droppedMetadata
+  };
+}
+function emptyConversionResult(schemaName, strict, ctx) {
+  return {
+    schemaName,
+    strict,
+    blockSchemas: ctx.blockSchemas,
+    problems: ctx.problems,
+    droppedMetadata: ctx.droppedMetadata
+  };
+}
+function compareFieldSchemas(aiField, blockField, fieldName) {
+  const aiPresent = aiField !== void 0;
+  const blockPresent = blockField !== void 0;
+  const aiSummary = aiField ? fieldSchemaSummary(aiField) : null;
+  const blockSummary = blockField ? fieldSchemaSummary(blockField) : null;
+  if (aiPresent && blockPresent) {
+    if (aiSummary === blockSummary) {
+      return {
+        field: fieldName,
+        aiPresent,
+        blockPresent,
+        aiSummary,
+        blockSummary,
+        status: "match"
+      };
+    }
+    const aiRicher = aiField?.type === "enum" && blockField?.type === "string" || aiField?.type === "inline_object" && blockField?.type !== "inline_object";
+    const blockRicher = blockField?.type === "enum" && aiField?.type === "string" || blockField?.required && !aiField?.required;
+    return {
+      field: fieldName,
+      aiPresent,
+      blockPresent,
+      aiSummary,
+      blockSummary,
+      status: aiRicher ? "ai_richer" : blockRicher ? "block_richer" : "type_mismatch",
+      ...aiSummary !== blockSummary && {
+        detail: `${aiSummary} vs ${blockSummary}`
+      }
+    };
+  }
+  if (aiPresent) {
+    return {
+      field: fieldName,
+      aiPresent,
+      blockPresent,
+      aiSummary,
+      blockSummary,
+      status: "ai_only"
+    };
+  }
+  return {
+    field: fieldName,
+    aiPresent,
+    blockPresent,
+    aiSummary,
+    blockSummary,
+    status: "block_only"
+  };
+}
+function compareWithExistingKindSchema(convertedFields, existing) {
+  if (!existing) return [];
+  const allFields = /* @__PURE__ */ new Set([
+    ...Object.keys(convertedFields),
+    ...Object.keys(existing.fields)
+  ]);
+  return [...allFields].sort().map(
+    (field) => compareFieldSchemas(
+      convertedFields[field],
+      existing.fields[field],
+      field
+    )
+  );
+}
+function runSchemaConversion(input, existingSchemas) {
+  const normalized = normalizeAiSchemaInput(input);
+  if (!normalized.rootSchema || !normalized.name) {
+    return {
+      schemaName: normalized.name,
+      strict: normalized.strict,
+      blockSchemas: [],
+      agentSchemaWithKinds: null,
+      problems: [],
+      droppedMetadata: [],
+      comparisons: [],
+      parseErrors: normalized.parseErrors.length ? normalized.parseErrors : ["Schema name and root schema are required."]
+    };
+  }
+  const strict = normalized.strict ?? false;
+  const core = convertAiSchemaToBlockFields(
+    normalized.name,
+    normalized.rootSchema,
+    strict
+  );
+  const existing = existingSchemas[normalized.name] ?? null;
+  const rootDraft = core.blockSchemas[0];
+  const comparisons = rootDraft ? compareWithExistingKindSchema(rootDraft.fields, existing) : [];
+  const problems = [...core.problems];
+  if (!existing) {
+    problems.push({
+      severity: "info",
+      path: "",
+      message: `No existing block schema with slug "${normalized.name}".`
+    });
+  }
+  const agentSchemaWithKinds = buildAgentSchemaWithRenderBlockSupport(
+    input,
+    normalized.name,
+    collectArrayBindingsFromDrafts(core.blockSchemas, normalized.name),
+    strict
+  );
+  return {
+    ...core,
+    agentSchemaWithKinds,
+    comparisons,
+    problems,
+    parseErrors: []
+  };
+}
+function collectArrayBindingsFromDrafts(drafts, rootSlug) {
+  const root = drafts.find((d) => d.slug === rootSlug);
+  if (!root) return [];
+  const bindings = [];
+  for (const [fieldName, field] of Object.entries(root.fields)) {
+    if (field.type !== "array") continue;
+    for (const itemKind of field.itemKinds) {
+      bindings.push({ arrayField: fieldName, itemKindSlug: itemKind });
+    }
+  }
+  return bindings;
+}
+function validateBlockSchemaSavePlan(blockSchemas, existingSlugs, hasConversionErrors) {
+  const errors = [];
+  const normalizedExisting = new Set(
+    existingSlugs.map((s) => s.trim().toLowerCase())
+  );
+  const batchSlugs = /* @__PURE__ */ new Set();
+  const itemKindRefs = [];
+  for (const draft of blockSchemas) {
+    const slug = draft.slug.trim();
+    const normalized = slug.toLowerCase();
+    if (!slug) {
+      errors.push("Every block schema must have a non-empty slug.");
+      continue;
+    }
+    if (batchSlugs.has(normalized)) {
+      errors.push(`Duplicate slug in conversion batch: "${slug}".`);
+    }
+    batchSlugs.add(normalized);
+  }
+  const entries = blockSchemas.map((draft) => {
+    const existsInDb = normalizedExisting.has(draft.slug.trim().toLowerCase());
+    return {
+      draft,
+      existsInDb,
+      willSave: !existsInDb
+    };
+  });
+  for (const draft of blockSchemas) {
+    for (const [fieldName, field] of Object.entries(draft.fields)) {
+      if (field.type !== "array") continue;
+      for (const itemKind of field.itemKinds) {
+        const inBatch = batchSlugs.has(itemKind.trim().toLowerCase());
+        const inDb = normalizedExisting.has(itemKind.trim().toLowerCase());
+        const satisfied = inBatch || inDb;
+        itemKindRefs.push({
+          parentSlug: draft.slug,
+          field: fieldName,
+          itemKind,
+          satisfied,
+          source: inBatch ? "batch" : inDb ? "database" : "missing"
+        });
+        if (!satisfied) {
+          errors.push(
+            `"${draft.slug}".${fieldName} references itemKind "${itemKind}" \u2014 not in this batch and not in DB.`
+          );
+        }
+      }
+    }
+  }
+  const newCount = entries.filter((e) => e.willSave).length;
+  if (newCount === 0 && blockSchemas.length > 0) {
+    errors.push("All block schema slugs already exist in the database.");
+  }
+  if (hasConversionErrors) {
+    errors.push("Resolve conversion errors before saving.");
+  }
+  return {
+    entries,
+    itemKindRefs,
+    newCount,
+    canSave: errors.length === 0 && newCount > 0,
+    errors
+  };
+}
+function fieldsToDbPayload(fields) {
+  return JSON.parse(JSON.stringify(fields));
+}
+function isDuplicateBlockSlug(slug, entries) {
+  const normalized = slug.trim().toLowerCase();
+  return entries.some((e) => e.slug.trim().toLowerCase() === normalized);
+}
+
+// convert/kind-to-json-schema.ts
+function collectReferencedKinds(fields) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (kind) => {
+    if (!seen.has(kind)) {
+      seen.add(kind);
+      out.push(kind);
+    }
+  };
+  const visit = (field) => {
+    if (field.type === "object") {
+      add(field.kind);
+    } else if (field.type === "array") {
+      field.itemKinds.forEach(add);
+    } else if (field.type === "union") {
+      (field.kinds ?? []).forEach(add);
+    } else if (field.type === "inline_object") {
+      Object.values(field.fields).forEach(visit);
+    }
+  };
+  Object.values(fields).forEach(visit);
+  return out;
+}
+function collectSchemaReferencedKinds(schema) {
+  if (!schema.root) return collectReferencedKinds(schema.fields);
+  return collectReferencedKinds({ [ROOT_REF_FIELD]: schema.root });
+}
+var ROOT_REF_FIELD = "__root";
+function kindSchemaToJsonSchema(kind, resolve, options = {}) {
+  const strict = options.strict ?? false;
+  const injectKind = options.injectKind ?? true;
+  const rootSchema = resolve(kind);
+  if (!rootSchema) return null;
+  const visited = /* @__PURE__ */ new Set([kind]);
+  const defsOrder = [];
+  const resolvedDefs = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  const queue = collectSchemaReferencedKinds(rootSchema);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (visited.has(next)) continue;
+    visited.add(next);
+    defsOrder.push(next);
+    const schema = resolve(next);
+    if (!schema) {
+      unresolved.push(next);
+      continue;
+    }
+    resolvedDefs.set(next, schema);
+    queue.push(...collectSchemaReferencedKinds(schema));
+  }
+  const refFor = (slug) => slug === kind ? { $ref: "#" } : { $ref: `#/$defs/${slug}` };
+  const withNull = (type, nullable) => nullable ? [type, "null"] : type;
+  function fieldToJsonSchema(field) {
+    const node = fieldToJsonSchemaCore(field);
+    if (field.description !== void 0) node.description = field.description;
+    if (field.default !== void 0) node.default = field.default;
+    return node;
+  }
+  function fieldToJsonSchemaCore(field) {
+    switch (field.type) {
+      case "string":
+      case "boolean":
+        return { type: withNull(field.type, field.nullable) };
+      case "number":
+        return {
+          type: withNull("number", field.nullable),
+          ...!strict && field.min !== void 0 ? { minimum: field.min } : {},
+          ...!strict && field.max !== void 0 ? { maximum: field.max } : {},
+          ...!strict && field.step !== void 0 ? { multipleOf: field.step } : {}
+        };
+      case "json":
+        return {};
+      case "string[]": {
+        const items = field.values === void 0 ? { type: "string" } : field.open ? {
+          anyOf: [
+            { type: "string", enum: [...field.values] },
+            { type: "string" }
+          ]
+        } : { type: "string", enum: [...field.values] };
+        return { type: withNull("array", field.nullable), items };
+      }
+      case "number[]":
+      case "boolean[]":
+        return {
+          type: withNull("array", field.nullable),
+          items: { type: scalarArrayItemType(field.type) }
+        };
+      case "json[]":
+        return {
+          type: withNull("array", field.nullable),
+          items: {}
+        };
+      case "enum": {
+        if (!field.open) {
+          return {
+            type: withNull("string", field.nullable),
+            enum: [...field.values]
+          };
+        }
+        const variants = [
+          { type: "string", enum: [...field.values] },
+          { type: "string" }
+        ];
+        if (field.nullable) variants.push({ type: "null" });
+        return { anyOf: variants };
+      }
+      case "union": {
+        const variants = field.scalars.map((scalar) => ({
+          type: scalar
+        }));
+        for (const memberKind of field.kinds ?? []) {
+          variants.push(refFor(memberKind));
+        }
+        if (field.nullable) variants.push({ type: "null" });
+        return { anyOf: variants };
+      }
+      case "record":
+        return {
+          type: withNull("object", field.nullable),
+          additionalProperties: field.values === "json" ? true : { type: field.values }
+        };
+      case "inline_object": {
+        const properties = {};
+        const required = [];
+        for (const [name, child] of Object.entries(field.fields)) {
+          properties[name] = fieldToJsonSchema(child);
+          if (child.required) required.push(name);
+        }
+        return {
+          type: withNull("object", field.nullable),
+          properties,
+          required,
+          ...field.open ? { additionalProperties: true } : strict ? { additionalProperties: false } : {}
+        };
+      }
+      case "object":
+        return field.nullable ? { anyOf: [refFor(field.kind), { type: "null" }] } : refFor(field.kind);
+      case "array": {
+        const [soleItemKind] = field.itemKinds;
+        const items = field.itemKinds.length === 1 && soleItemKind !== void 0 ? refFor(soleItemKind) : { anyOf: field.itemKinds.map(refFor) };
+        return { type: withNull("array", field.nullable), items };
+      }
+    }
+  }
+  function kindObjectSchema(schema) {
+    if (schema.root) {
+      return fieldToJsonSchema(schema.root);
+    }
+    const properties = {};
+    const required = [];
+    for (const [name, field] of Object.entries(schema.fields)) {
+      properties[name] = fieldToJsonSchema(field);
+      if (field.required) required.push(name);
+    }
+    const node = {
+      type: "object",
+      properties,
+      required,
+      ...strict ? { additionalProperties: false } : {}
+    };
+    return injectKind ? injectKindIntoObjectSchema(node, schema.kind, strict) : node;
+  }
+  function unresolvedStub(slug) {
+    const node = {
+      type: "object",
+      description: `Unresolved kind "${slug}" \u2014 schema not available at export time.`
+    };
+    return injectKind ? injectKindIntoObjectSchema(node, slug, false) : node;
+  }
+  const rootNode = kindObjectSchema(rootSchema);
+  if (defsOrder.length === 0) {
+    return { name: kind, schema: rootNode, strict, unresolved };
+  }
+  const defs = {};
+  for (const slug of defsOrder) {
+    const schema = resolvedDefs.get(slug);
+    defs[slug] = schema ? kindObjectSchema(schema) : unresolvedStub(slug);
+  }
+  return { name: kind, schema: { ...rootNode, $defs: defs }, strict, unresolved };
+}
+
+// convert/json-schema-to-kind.ts
+function kindSchemaFromJsonSchema(kind, jsonSchema) {
+  if (jsonSchema === null || jsonSchema === void 0) {
+    return { schema: null, children: {}, problems: [] };
+  }
+  const normalized = normalizeAiSchemaInput(jsonSchema);
+  const rootSchema = normalized.rootSchema ?? (typeof jsonSchema === "object" && !Array.isArray(jsonSchema) ? jsonSchema : null);
+  if (!rootSchema) {
+    return {
+      schema: null,
+      children: {},
+      problems: [
+        {
+          severity: "error",
+          path: "",
+          message: `Kind "${kind}": emitted_json_schema is not a JSON object.`
+        }
+      ]
+    };
+  }
+  const converted = convertAiSchemaToBlockFields(kind, rootSchema, false);
+  let schema = null;
+  const children = {};
+  for (const draft of converted.blockSchemas) {
+    const asKindSchema = {
+      kind: draft.slug,
+      fields: draft.fields,
+      ...draft.root ? { root: draft.root } : {}
+    };
+    if (draft.slug === kind) schema = asKindSchema;
+    else children[draft.slug] = asKindSchema;
+  }
+  return { schema, children, problems: converted.problems };
+}
+
+exports.buildAgentSchemaWithRenderBlockSupport = buildAgentSchemaWithRenderBlockSupport;
+exports.collectReferencedKinds = collectReferencedKinds;
+exports.collectSchemaReferencedKinds = collectSchemaReferencedKinds;
+exports.compareWithExistingKindSchema = compareWithExistingKindSchema;
+exports.convertAiSchemaToBlockFields = convertAiSchemaToBlockFields;
+exports.fieldsToDbPayload = fieldsToDbPayload;
+exports.injectKindIntoObjectSchema = injectKindIntoObjectSchema;
+exports.isDuplicateBlockSlug = isDuplicateBlockSlug;
+exports.kindSchemaFromJsonSchema = kindSchemaFromJsonSchema;
+exports.kindSchemaToJsonSchema = kindSchemaToJsonSchema;
+exports.normalizeAiSchemaInput = normalizeAiSchemaInput;
+exports.runSchemaConversion = runSchemaConversion;
+exports.validateBlockSchemaSavePlan = validateBlockSchemaSavePlan;
+//# sourceMappingURL=convert.cjs.map
+//# sourceMappingURL=convert.cjs.map