formhell 0.1.5

package/dist/index.mjs

@@ -0,0 +1,4408 @@
+// src/index.ts
+import "./styles-UY6N5SPU.css";
+
+// src/components/SchemaForm.tsx
+import { useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+
+// src/utils/defaultData.ts
+function createDefaultValueFromSchema(schema, options, isRequiredField = true) {
+  const defaultsMode = options?.defaults ?? "all";
+  const shouldUseSchemaDefault = defaultsMode === "all" || isRequiredField;
+  if (shouldUseSchemaDefault && schema.default !== void 0) {
+    return schema.default;
+  }
+  const type = getPrimaryType(schema);
+  switch (type) {
+    case "object": {
+      const result = {};
+      const required = new Set(schema.required ?? []);
+      const properties = schema.properties ?? {};
+      for (const [key, childSchema] of Object.entries(properties)) {
+        const childIsRequired = required.has(key);
+        const shouldIncludeField = childIsRequired || defaultsMode === "all" && childSchema.default !== void 0;
+        if (shouldIncludeField) {
+          result[key] = createDefaultValueFromSchema(childSchema, options, childIsRequired);
+        }
+      }
+      return result;
+    }
+    case "array":
+      return [];
+    case "boolean":
+      return false;
+    case "number":
+    case "integer":
+      return void 0;
+    case "null":
+      return null;
+    case "string":
+      return schema.enum?.[0] ?? "";
+    default:
+      return void 0;
+  }
+}
+function getPrimaryType(schema) {
+  if (Array.isArray(schema.type)) {
+    return schema.type[0];
+  }
+  return schema.type;
+}
+
+// src/utils/jsonPointer.ts
+function escapeJsonPointerToken(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapeJsonPointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function toPointerTokens(pointer) {
+  const normalized = pointer.startsWith("#") ? pointer.slice(1) : pointer;
+  if (!normalized) {
+    return [];
+  }
+  if (!normalized.startsWith("/")) {
+    throw new Error(`Invalid JSON pointer: ${pointer}`);
+  }
+  return normalized.split("/").slice(1).map(unescapeJsonPointerToken);
+}
+function joinPointer(basePointer, token) {
+  const escaped = escapeJsonPointerToken(token);
+  if (!basePointer) {
+    return `/${escaped}`;
+  }
+  return `${basePointer}/${escaped}`;
+}
+function getValueAtPointer(source, pointer) {
+  const tokens = toPointerTokens(pointer);
+  let current = source;
+  for (const token of tokens) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    current = current[token];
+  }
+  return current;
+}
+function setValueAtPointer(source, pointer, value) {
+  const tokens = toPointerTokens(pointer);
+  if (tokens.length === 0) {
+    return value;
+  }
+  const root = deepClone(source);
+  let current = root;
+  for (let index = 0; index < tokens.length - 1; index += 1) {
+    const token = tokens[index];
+    const nextToken = tokens[index + 1];
+    if (current[token] === void 0 || current[token] === null) {
+      current[token] = isArrayIndexToken(nextToken) ? [] : {};
+    }
+    current = current[token];
+  }
+  const leafToken = tokens[tokens.length - 1];
+  current[leafToken] = value;
+  return root;
+}
+function isArrayIndexToken(token) {
+  return /^\d+$/.test(token);
+}
+function deepClone(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/utils/refResolver.ts
+import { getByPointer } from "json-pointer-relational";
+import { bundle } from "@hyperjump/json-schema/bundle";
+import { hasSchema, registerSchema, unregisterSchema } from "@hyperjump/json-schema/draft-2020-12";
+var MissingPeerSchemaError = class extends Error {
+  constructor(ref) {
+    super(`Could not find referenced peer schema for: ${ref}`);
+    this.name = "MissingPeerSchemaError";
+    this.ref = ref;
+  }
+};
+var generatedSchemaCounter = 0;
+var DEFAULT_DIALECT_URI = "https://json-schema.org/draft/2020-12/schema";
+async function resolveSchemaRefs(schema, peerSchemas) {
+  const cloned = deepClone2(schema);
+  const peerCandidates = toSchemaCandidates(peerSchemas);
+  const missingRef = findFirstMissingExternalRef(cloned, peerCandidates);
+  if (missingRef) {
+    throw new MissingPeerSchemaError(missingRef);
+  }
+  const bundled = await bundleWithRegisteredSchemas(cloned, peerCandidates);
+  const bundledCandidates = collectSchemaCandidates(bundled);
+  const candidates = mergeCandidates(peerCandidates, bundledCandidates);
+  const visiting = /* @__PURE__ */ new Set();
+  return resolveNode(bundled, bundled, candidates, visiting);
+}
+function resolveNode(node, currentSchemaRoot, candidates, visiting) {
+  if (Array.isArray(node)) {
+    return node.map((entry) => resolveNode(entry, currentSchemaRoot, candidates, visiting));
+  }
+  if (!isObject(node)) {
+    return node;
+  }
+  if (typeof node.$ref === "string") {
+    const resolved = resolveRefNode(node, currentSchemaRoot, candidates, visiting);
+    return resolveNode(resolved.value, resolved.currentSchemaRoot, candidates, visiting);
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    result[key] = resolveNode(value, currentSchemaRoot, candidates, visiting);
+  }
+  return result;
+}
+function resolveRefNode(node, currentSchemaRoot, candidates, visiting) {
+  const ref = node.$ref;
+  const externalReference = isExternalReference(ref);
+  const recursionKey = `${currentSchemaRoot.$id ?? "local"}::${ref}`;
+  if (visiting.has(recursionKey)) {
+    throw new Error(`Infinite recursion detected while resolving reference: ${ref}`);
+  }
+  visiting.add(recursionKey);
+  let targetSchema = currentSchemaRoot;
+  let resultJsonPointer = ref;
+  if (externalReference) {
+    const matched = findBestCandidate(ref, candidates);
+    if (!matched) {
+      throw new MissingPeerSchemaError(ref);
+    }
+    targetSchema = matched.schema;
+    resultJsonPointer = ref.slice(matched.identifier.length);
+    if (!resultJsonPointer) {
+      resultJsonPointer = "#";
+    }
+  }
+  const resolvedValue = getByPointer(resultJsonPointer, targetSchema);
+  if (!isObject(resolvedValue)) {
+    throw new Error(`Could not resolve JSON pointer: ${resultJsonPointer}`);
+  }
+  const { $ref: _omitRef, ...rest } = node;
+  const merged = {
+    ...deepClone2(resolvedValue),
+    ...rest
+  };
+  if (externalReference && resultJsonPointer === "#") {
+    delete merged.$id;
+  }
+  visiting.delete(recursionKey);
+  return { value: merged, currentSchemaRoot: targetSchema };
+}
+function isExternalReference(ref) {
+  return !(ref.startsWith("#") || ref.startsWith("/"));
+}
+function findFirstMissingExternalRef(rootSchema, candidates) {
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [rootSchema, ...candidates.map((candidate) => candidate.schema)];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!isObject(current)) {
+      continue;
+    }
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (typeof current.$ref === "string" && isExternalReference(current.$ref)) {
+      if (!findBestCandidate(current.$ref, candidates)) {
+        return current.$ref;
+      }
+    }
+    for (const value of Object.values(current)) {
+      if (Array.isArray(value)) {
+        for (const entry of value) {
+          stack.push(entry);
+        }
+      } else {
+        stack.push(value);
+      }
+    }
+  }
+  return null;
+}
+async function bundleWithRegisteredSchemas(schema, candidates) {
+  const rootUri = typeof schema.$id === "string" && schema.$id.length > 0 ? schema.$id : `urn:formhell:bundled-schema:${generatedSchemaCounter++}`;
+  const registeredUris = /* @__PURE__ */ new Set();
+  registerSchemaWithOverwrite(asHyperjumpSchema(schema), rootUri);
+  registeredUris.add(rootUri);
+  for (const candidate of candidates) {
+    const candidateUri = normalizeCandidateRegistrationUri(candidate);
+    if (registeredUris.has(candidateUri)) {
+      continue;
+    }
+    registerSchemaWithOverwrite(asHyperjumpSchema(candidate.schema), candidateUri);
+    registeredUris.add(candidateUri);
+  }
+  const bundled = await bundle(rootUri);
+  if (!isObject(bundled)) {
+    throw new Error("Bundling did not produce a valid schema document.");
+  }
+  return bundled;
+}
+function normalizeCandidateRegistrationUri(candidate) {
+  if (typeof candidate.schema.$id === "string" && candidate.schema.$id.length > 0) {
+    return candidate.schema.$id;
+  }
+  return stripFragment(candidate.identifier);
+}
+function stripFragment(uri) {
+  const hashIndex = uri.indexOf("#");
+  if (hashIndex === -1) {
+    return uri;
+  }
+  return uri.slice(0, hashIndex);
+}
+function asHyperjumpSchema(schema) {
+  return schema;
+}
+function registerSchemaWithOverwrite(schema, uri) {
+  if (hasSchema(uri)) {
+    unregisterSchema(uri);
+  }
+  registerSchema(schema, uri, DEFAULT_DIALECT_URI);
+}
+function collectSchemaCandidates(schema) {
+  const collected = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [schema];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!isObject(current)) {
+      continue;
+    }
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (typeof current.$id === "string" && current.$id.length > 0) {
+      collected.set(current.$id, {
+        identifier: current.$id,
+        schema: current
+      });
+    }
+    for (const value of Object.values(current)) {
+      if (Array.isArray(value)) {
+        for (const entry of value) {
+          stack.push(entry);
+        }
+      } else {
+        stack.push(value);
+      }
+    }
+  }
+  return Array.from(collected.values());
+}
+function mergeCandidates(...candidateGroups) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const group of candidateGroups) {
+    for (const candidate of group) {
+      merged.set(candidate.identifier, candidate);
+    }
+  }
+  return Array.from(merged.values());
+}
+function findBestCandidate(ref, candidates) {
+  const matches = candidates.filter((candidate) => ref.startsWith(candidate.identifier));
+  matches.sort((a, b) => b.identifier.length - a.identifier.length);
+  return matches[0];
+}
+function toSchemaCandidates(peerSchemas) {
+  if (!peerSchemas) {
+    return [];
+  }
+  if (Array.isArray(peerSchemas)) {
+    return peerSchemas.filter((schema) => typeof schema.$id === "string" && schema.$id.length > 0).map((schema) => ({ identifier: schema.$id, schema }));
+  }
+  return Object.entries(peerSchemas).map(([identifier, schema]) => ({ identifier, schema }));
+}
+function deepClone2(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/utils/schemaValidation.ts
+import Ajv from "ajv";
+import Ajv2019 from "ajv/dist/2019";
+import Ajv2020 from "ajv/dist/2020";
+var AJV_SUPPORTED_FORMATS = [
+  "date",
+  "time",
+  "date-time",
+  "duration",
+  "uri",
+  "uri-reference",
+  "uri-template",
+  "url",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "regex",
+  "uuid",
+  "json-pointer",
+  "json-pointer-uri-fragment",
+  "relative-json-pointer"
+];
+var AJV_OPTIONS = {
+  allErrors: true,
+  strict: false,
+  validateSchema: true
+};
+function createAjvForSchema(schema) {
+  const schemaUri = schema.$schema ?? "";
+  if (schemaUri.includes("2020-12")) {
+    return new Ajv2020(AJV_OPTIONS);
+  }
+  if (schemaUri.includes("2019-09")) {
+    return new Ajv2019(AJV_OPTIONS);
+  }
+  return new Ajv(AJV_OPTIONS);
+}
+function validateSchemaOrThrow(schema, label) {
+  const ajv = createAjvForSchema(schema);
+  const valid = ajv.validateSchema(schema);
+  if (!valid) {
+    const errors = ajv.errorsText(ajv.errors, { separator: "; " });
+    throw new Error(`${label} is not a valid JSON Schema. ${errors}`.trim());
+  }
+}
+function validatePeerSchemasOrThrow(peerSchemas) {
+  if (!peerSchemas) {
+    return;
+  }
+  if (Array.isArray(peerSchemas)) {
+    peerSchemas.forEach((schema, index) => {
+      validateSchemaOrThrow(schema, `peerSchemas[${index}]`);
+    });
+    return;
+  }
+  for (const [key, schema] of Object.entries(peerSchemas)) {
+    validateSchemaOrThrow(schema, `peerSchemas.${key}`);
+  }
+}
+function validateDataOrThrow(data, schema) {
+  const ajv = createAjvForSchema(schema);
+  const validate = ajv.compile(schema);
+  const valid = validate(data);
+  if (!valid) {
+    const errors = ajv.errorsText(validate.errors, { separator: "; " });
+    throw new Error(`Provided data does not match schema. ${errors}`.trim());
+  }
+}
+
+// src/components/SchemaFieldRenderer.tsx
+import { useEffect, useState } from "react";
+
+// src/components/fields/SchemaFormArray.tsx
+import { useRef } from "react";
+
+// src/components/fields/FieldShell.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function FieldShell({ label, required, controls, children }) {
+  return /* @__PURE__ */ jsxs("div", { className: "raf-field", children: [
+    /* @__PURE__ */ jsxs("div", { className: "raf-field-label-row", children: [
+      /* @__PURE__ */ jsxs("label", { className: "raf-field-label", children: [
+        label,
+        required ? /* @__PURE__ */ jsx("span", { className: "raf-field-required", children: "*" }) : null
+      ] }),
+      !required ? /* @__PURE__ */ jsx("span", { className: "raf-field-optional", children: "Optional" }) : null
+    ] }),
+    controls ? /* @__PURE__ */ jsx("div", { className: "raf-button-row", children: controls }) : null,
+    children
+  ] });
+}
+
+// src/components/fields/SchemaFormArray.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function SchemaFormArray({
+  label,
+  required,
+  pointer,
+  schema,
+  value,
+  disabled,
+  controls,
+  canAddItem,
+  canRemoveItems,
+  onChange,
+  renderItem,
+  createDefaultItem
+}) {
+  const items = Array.isArray(value) ? value : [];
+  const hasUserModifiedRef = useRef(false);
+  const lastSignatureRef = useRef(null);
+  const maxItems = typeof schema.maxItems === "number" ? schema.maxItems : void 0;
+  const initialItemCount = getInitialItemCount(schema.minItems, maxItems);
+  const schemaSignature = `${pointer}|${String(schema.minItems ?? "")}|${String(schema.maxItems ?? "")}|${JSON.stringify(schema.items ?? null)}|${JSON.stringify(schema.prefixItems ?? null)}`;
+  if (schemaSignature !== lastSignatureRef.current) {
+    hasUserModifiedRef.current = false;
+    lastSignatureRef.current = schemaSignature;
+  }
+  const renderedItems = items.length === 0 && !hasUserModifiedRef.current ? Array.from({ length: initialItemCount }, () => createDefaultItem()) : items;
+  const showAddItem = !disabled && canAddItem !== false && renderedItems.length < (maxItems ?? Number.POSITIVE_INFINITY);
+  return /* @__PURE__ */ jsx2(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsxs2("div", { children: [
+    renderedItems.map((item, index) => {
+      const itemPointer = `${pointer}/${index}`;
+      return /* @__PURE__ */ jsxs2("div", { className: "raf-array-item", children: [
+        renderItem(index, itemPointer, item),
+        canRemoveItems === false ? null : /* @__PURE__ */ jsx2("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx2(
+          "button",
+          {
+            className: "raf-button raf-button-danger",
+            type: "button",
+            disabled,
+            onClick: () => {
+              hasUserModifiedRef.current = true;
+              const next = [...renderedItems];
+              next.splice(index, 1);
+              onChange(next);
+            },
+            children: "Remove"
+          }
+        ) })
+      ] }, itemPointer);
+    }),
+    showAddItem ? /* @__PURE__ */ jsx2(
+      "button",
+      {
+        className: "raf-button raf-button-primary",
+        type: "button",
+        onClick: () => {
+          hasUserModifiedRef.current = true;
+          const next = [...renderedItems, createDefaultItem()];
+          onChange(next);
+        },
+        children: "Add Item"
+      }
+    ) : null
+  ] }) });
+}
+function getInitialItemCount(minItems, maxItems) {
+  const desiredCount = typeof minItems === "number" && minItems > 1 ? Math.floor(minItems) : 1;
+  if (maxItems === void 0) {
+    return desiredCount;
+  }
+  return Math.max(0, Math.min(desiredCount, maxItems));
+}
+
+// src/components/fields/SchemaFormBoolean.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function SchemaFormBoolean({ label, required, value, disabled, controls, onChange }) {
+  return /* @__PURE__ */ jsx3(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsxs3("label", { className: "raf-checkbox-row", children: [
+    /* @__PURE__ */ jsx3(
+      "input",
+      {
+        className: "raf-checkbox",
+        type: "checkbox",
+        checked: Boolean(value),
+        disabled,
+        onChange: (event) => onChange(event.target.checked)
+      }
+    ),
+    /* @__PURE__ */ jsx3("span", { children: value ? "True" : "False" })
+  ] }) });
+}
+
+// src/components/fields/SchemaFormInteger.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function SchemaFormInteger({ label, required, value, disabled, controls, onChange }) {
+  return /* @__PURE__ */ jsx4(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsx4(
+    "input",
+    {
+      className: "raf-input",
+      type: "number",
+      step: 1,
+      value: value ?? "",
+      disabled,
+      onChange: (event) => {
+        const nextValue = event.target.value;
+        onChange(nextValue === "" ? void 0 : Math.trunc(Number(nextValue)));
+      }
+    }
+  ) });
+}
+
+// src/components/fields/SchemaFormNull.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function SchemaFormNull({ label, required, controls }) {
+  return /* @__PURE__ */ jsx5(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsx5("div", { className: "raf-muted", children: "Value is always null." }) });
+}
+
+// src/components/fields/SchemaFormNumber.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function SchemaFormNumber({ label, required, value, disabled, controls, onChange }) {
+  return /* @__PURE__ */ jsx6(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsx6(
+    "input",
+    {
+      className: "raf-input",
+      type: "number",
+      value: value ?? "",
+      disabled,
+      onChange: (event) => {
+        const nextValue = event.target.value;
+        onChange(nextValue === "" ? void 0 : Number(nextValue));
+      }
+    }
+  ) });
+}
+
+// src/components/fields/SchemaFormObject.tsx
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+function SchemaFormObject({ label, required, disabled, controls, children }) {
+  return /* @__PURE__ */ jsxs4("details", { className: "raf-object", open: true, children: [
+    /* @__PURE__ */ jsxs4("summary", { className: "raf-object-summary", children: [
+      label,
+      required ? /* @__PURE__ */ jsx7("span", { className: "raf-field-required", children: "*" }) : null
+    ] }),
+    /* @__PURE__ */ jsxs4("div", { className: "raf-object-content", "aria-disabled": disabled, children: [
+      controls ? /* @__PURE__ */ jsx7("div", { className: "raf-button-row", children: controls }) : null,
+      children
+    ] })
+  ] });
+}
+
+// src/components/fields/SchemaFormSelect.tsx
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+function SchemaFormSelect({ label, required, schema, value, disabled, controls, onChange }) {
+  const options = Array.isArray(schema.enum) ? schema.enum : [];
+  const selectedValue = encodeEnumValue(value);
+  return /* @__PURE__ */ jsx8(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsxs5(
+    "select",
+    {
+      className: "raf-select",
+      value: selectedValue,
+      disabled,
+      onChange: (event) => onChange(decodeEnumValue(event.target.value)),
+      children: [
+        !required ? /* @__PURE__ */ jsx8("option", { value: "", children: "Select..." }) : null,
+        options.map((option) => /* @__PURE__ */ jsx8("option", { value: encodeEnumValue(option), children: String(option) }, encodeEnumValue(option)))
+      ]
+    }
+  ) });
+}
+function encodeEnumValue(value) {
+  if (value === void 0) {
+    return "";
+  }
+  return JSON.stringify(value);
+}
+function decodeEnumValue(value) {
+  if (value === "") {
+    return "";
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/components/fields/SchemaFormString.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function SchemaFormString({ label, required, value, disabled, controls, onChange }) {
+  return /* @__PURE__ */ jsx9(FieldShell, { label, required, controls, children: /* @__PURE__ */ jsx9(
+    "input",
+    {
+      className: "raf-input",
+      type: "text",
+      value: value ?? "",
+      disabled,
+      onChange: (event) => onChange(event.target.value)
+    }
+  ) });
+}
+
+// src/components/SchemaFieldRenderer.tsx
+import { Fragment, jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+function SchemaFieldRenderer(props) {
+  const { schema, label, required, pointer, schemaPointer, value, onChange, widgets, controls } = props;
+  const hasConstValue = Object.prototype.hasOwnProperty.call(schema, "const");
+  const lockedValue = hasConstValue ? schema.const : value;
+  const isConstLocked = hasConstValue;
+  const schemaTypes = resolveTypes(schema);
+  const type = resolveType(schema);
+  const hasTypeChoices = schemaTypes.length > 1;
+  const hasEnum = Array.isArray(schema.enum) && schema.enum.length > 0;
+  const inferredType = inferValueType(lockedValue, schemaTypes);
+  const [selectedType, setSelectedType] = useState(() => inferredType ?? schemaTypes[0]);
+  const activeType = selectedType && schemaTypes.includes(selectedType) ? selectedType : inferredType ?? schemaTypes[0];
+  const tupleItems = activeType === "array" ? Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : void 0 : void 0;
+  const singleItemsSchema = activeType === "array" && !Array.isArray(schema.items) && isObject2(schema.items) ? schema.items : void 0;
+  const itemSchemas = activeType === "array" ? tupleItems ?? (singleItemsSchema ? [singleItemsSchema] : void 0) : void 0;
+  const maxItems = activeType === "array" && typeof schema.maxItems === "number" ? schema.maxItems : void 0;
+  useEffect(() => {
+    if (selectedType && schemaTypes.includes(selectedType) && !inferredType) {
+      return;
+    }
+    if (inferredType && inferredType !== selectedType) {
+      setSelectedType(inferredType);
+      return;
+    }
+    if (selectedType && !schemaTypes.includes(selectedType)) {
+      setSelectedType(inferredType ?? schemaTypes[0]);
+    }
+  }, [inferredType, schemaTypes, selectedType]);
+  const typeChooser = hasTypeChoices && !hasEnum ? /* @__PURE__ */ jsxs6("div", { className: "raf-button-row", "aria-label": `${label} type chooser`, children: [
+    schemaTypes.filter((choice) => choice !== "null").map((choice) => /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        disabled: isConstLocked,
+        "aria-pressed": activeType === choice,
+        onClick: () => {
+          setSelectedType(choice);
+          onChange(pointer, createDefaultValueForType(choice));
+        },
+        children: choice
+      },
+      choice
+    )),
+    schemaTypes.includes("null") ? /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        disabled: isConstLocked,
+        "aria-pressed": activeType === "null",
+        onClick: () => {
+          setSelectedType("null");
+          onChange(pointer, null);
+        },
+        children: "Insert NULL"
+      }
+    ) : null
+  ] }) : null;
+  const fieldControls = controls && typeChooser ? /* @__PURE__ */ jsxs6(Fragment, { children: [
+    controls,
+    typeChooser
+  ] }) : controls ?? typeChooser;
+  if (activeType === "object") {
+    const ObjectWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Object ?? SchemaFormObject;
+    const objectValue = isObject2(lockedValue) ? lockedValue : {};
+    const requiredKeys = new Set(schema.required ?? []);
+    const properties = schema.properties ?? {};
+    return /* @__PURE__ */ jsx10(
+      ObjectWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: objectValue,
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: (next) => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, next);
+        },
+        children: Object.entries(properties).map(([propertyName, propertySchema]) => {
+          const childPointer = joinPointer(pointer, propertyName);
+          const childSchemaPointer = joinPointer(joinPointer(schemaPointer, "properties"), propertyName);
+          const childValue = objectValue[propertyName];
+          return /* @__PURE__ */ jsx10(
+            SchemaFieldRenderer,
+            {
+              schema: propertySchema,
+              label: propertySchema.title ?? propertyName,
+              required: requiredKeys.has(propertyName),
+              pointer: childPointer,
+              schemaPointer: childSchemaPointer,
+              value: childValue,
+              onChange,
+              widgets
+            },
+            childPointer
+          );
+        })
+      }
+    );
+  }
+  if (activeType === "array") {
+    const ArrayWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Array ?? SchemaFormArray;
+    const arrayValue = Array.isArray(lockedValue) ? lockedValue : [];
+    const addLimit = maxItems ?? Number.POSITIVE_INFINITY;
+    const fixedTupleValue = tupleItems ? tupleItems.map(
+      (itemSchema, index) => arrayValue[index] === void 0 ? createDefaultValueFromSchema(itemSchema) : arrayValue[index]
+    ) : arrayValue;
+    const canAddItem = tupleItems ? false : arrayValue.length < addLimit;
+    return /* @__PURE__ */ jsx10(
+      ArrayWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: fixedTupleValue,
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: (next) => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, next);
+        },
+        itemsSchema: singleItemsSchema,
+        itemSchemas,
+        createDefaultItem: () => createDefaultValueForArrayItem(itemSchemas, arrayValue.length),
+        renderItem: (index, itemPointer, itemValue) => /* @__PURE__ */ jsx10(
+          SchemaFieldRenderer,
+          {
+            schema: tupleItems?.[index] ?? singleItemsSchema ?? { type: "string" },
+            label: tupleItems?.[index]?.title?.trim() ? tupleItems[index].title : tupleItems ? `Tuple ${index + 1}` : `Item ${index + 1}`,
+            required: true,
+            pointer: itemPointer,
+            schemaPointer: tupleItems ? joinPointer(joinPointer(schemaPointer, "prefixItems"), String(index)) : joinPointer(schemaPointer, "items"),
+            value: itemValue,
+            onChange,
+            widgets
+          }
+        ),
+        canAddItem,
+        canRemoveItems: !tupleItems
+      }
+    );
+  }
+  if (activeType === "boolean") {
+    const BooleanWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Boolean ?? SchemaFormBoolean;
+    return /* @__PURE__ */ jsx10(
+      BooleanWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: Boolean(lockedValue),
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: (next) => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, next);
+        }
+      }
+    );
+  }
+  if (activeType === "number") {
+    const NumberWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Number ?? SchemaFormNumber;
+    return /* @__PURE__ */ jsx10(
+      NumberWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: typeof lockedValue === "number" ? lockedValue : void 0,
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: (next) => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, next);
+        }
+      }
+    );
+  }
+  if (activeType === "integer") {
+    const IntegerWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Integer ?? SchemaFormInteger;
+    return /* @__PURE__ */ jsx10(
+      IntegerWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: typeof lockedValue === "number" ? lockedValue : void 0,
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: (next) => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, next);
+        }
+      }
+    );
+  }
+  if (activeType === "null") {
+    const NullWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Null ?? SchemaFormNull;
+    return /* @__PURE__ */ jsx10(
+      NullWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: null,
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: () => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, null);
+        }
+      }
+    );
+  }
+  if (hasEnum && (activeType === "string" || hasTypeChoices)) {
+    const SelectWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.Select ?? SchemaFormSelect;
+    return /* @__PURE__ */ jsx10(
+      SelectWidget,
+      {
+        label,
+        required,
+        pointer,
+        schema,
+        value: lockedValue,
+        disabled: isConstLocked,
+        controls: fieldControls,
+        onChange: (next) => {
+          if (isConstLocked) {
+            return;
+          }
+          onChange(pointer, next);
+        }
+      }
+    );
+  }
+  const StringWidget = getSchemaPointerWidget(widgets, schemaPointer) ?? widgets?.String ?? SchemaFormString;
+  return /* @__PURE__ */ jsx10(
+    StringWidget,
+    {
+      label,
+      required,
+      pointer,
+      schema,
+      value: typeof lockedValue === "string" ? lockedValue : "",
+      disabled: isConstLocked,
+      controls: fieldControls,
+      onChange: (next) => {
+        if (isConstLocked) {
+          return;
+        }
+        onChange(pointer, next);
+      }
+    }
+  );
+}
+function getSchemaPointerWidget(widgets, schemaPointer) {
+  if (!widgets) {
+    return void 0;
+  }
+  const candidate = widgets[schemaPointer];
+  if (!candidate) {
+    return void 0;
+  }
+  return candidate;
+}
+function resolveType(schema) {
+  if (Array.isArray(schema.type) && schema.type.length > 0) {
+    return schema.type[0];
+  }
+  if (typeof schema.type === "string") {
+    return schema.type;
+  }
+  if (schema.properties) {
+    return "object";
+  }
+  if (schema.items) {
+    return "array";
+  }
+  return "string";
+}
+function resolveTypes(schema) {
+  if (Array.isArray(schema.type) && schema.type.length > 0) {
+    return schema.type.filter((type) => typeof type === "string");
+  }
+  return [resolveType(schema)];
+}
+function inferValueType(value, schemaTypes) {
+  if (value === null && schemaTypes.includes("null")) {
+    return "null";
+  }
+  if (Array.isArray(value) && schemaTypes.includes("array")) {
+    return "array";
+  }
+  if (isObject2(value) && schemaTypes.includes("object")) {
+    return "object";
+  }
+  if (typeof value === "boolean" && schemaTypes.includes("boolean")) {
+    return "boolean";
+  }
+  if (typeof value === "number") {
+    if (schemaTypes.includes("integer") && Number.isInteger(value)) {
+      return "integer";
+    }
+    if (schemaTypes.includes("number")) {
+      return "number";
+    }
+  }
+  if (typeof value === "string" && schemaTypes.includes("string")) {
+    return "string";
+  }
+  return void 0;
+}
+function createDefaultValueForType(type) {
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+    case "integer":
+      return void 0;
+    case "boolean":
+      return false;
+    case "object":
+      return {};
+    case "array":
+      return [];
+    case "null":
+      return null;
+    default:
+      return void 0;
+  }
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createDefaultValueForArrayItem(itemSchemas, index) {
+  const schema = itemSchemas?.[index] ?? itemSchemas?.[0] ?? itemSchemas?.[itemSchemas.length - 1];
+  return createDefaultValueFromSchema(schema ?? {});
+}
+
+// src/components/SchemaForm.tsx
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+function SchemaForm({ schema, peerSchemas, getSchema, widgets, options, data, onChange }) {
+  const onChangeRef = useRef2(onChange);
+  const [resolvedSchema, setResolvedSchema] = useState2(null);
+  const [resolutionError, setResolutionError] = useState2(null);
+  const [isWaitingForPeerSchemas, setIsWaitingForPeerSchemas] = useState2(false);
+  useEffect2(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  useEffect2(() => {
+    let cancelled = false;
+    const resolveSchema = async () => {
+      try {
+        validateSchemaOrThrow(schema, "schema");
+        validatePeerSchemasOrThrow(peerSchemas);
+        try {
+          const resolved = await resolveSchemaRefs(schema, peerSchemas);
+          if (!cancelled) {
+            setResolvedSchema(resolved);
+            setResolutionError(null);
+            setIsWaitingForPeerSchemas(false);
+          }
+          return;
+        } catch (error) {
+          if (!(error instanceof MissingPeerSchemaError) || !getSchema) {
+            throw error;
+          }
+          if (!cancelled) {
+            setResolvedSchema(null);
+            setResolutionError(null);
+            setIsWaitingForPeerSchemas(true);
+          }
+        }
+        const resolvedWithFallback = await resolveSchemaWithFallback(schema, peerSchemas, getSchema);
+        if (!cancelled) {
+          setResolvedSchema(resolvedWithFallback);
+          setResolutionError(null);
+          setIsWaitingForPeerSchemas(false);
+        }
+      } catch (error) {
+        if (!cancelled) {
+          setResolvedSchema(null);
+          setResolutionError(error instanceof Error ? error : new Error("Schema resolution failed."));
+          setIsWaitingForPeerSchemas(false);
+        }
+      }
+    };
+    void resolveSchema();
+    return () => {
+      cancelled = true;
+    };
+  }, [schema, peerSchemas, getSchema]);
+  const initialData = useMemo(() => {
+    if (!resolvedSchema) {
+      return data ?? {};
+    }
+    if (data !== void 0) {
+      return data;
+    }
+    const fallback = createDefaultValueFromSchema(resolvedSchema, {
+      defaults: options?.defaults ?? "all"
+    });
+    return fallback ?? {};
+  }, [data, options?.defaults, resolvedSchema]);
+  const [formData, setFormData] = useState2(initialData);
+  useEffect2(() => {
+    if (!resolvedSchema) {
+      return;
+    }
+    setFormData(initialData);
+    const validationErrors = getDataValidationErrors(initialData, resolvedSchema);
+    onChangeRef.current?.(initialData, validationErrors, "", void 0, initialData);
+  }, [initialData, resolvedSchema]);
+  const handleFieldChange = (pointer, next) => {
+    if (!resolvedSchema) {
+      return;
+    }
+    const previousValue = getValueAtPointer(formData, pointer);
+    const updated = setValueAtPointer(formData, pointer, next);
+    const validationErrors = getDataValidationErrors(updated, resolvedSchema);
+    setFormData(updated);
+    onChangeRef.current?.(updated, validationErrors, pointer, previousValue, next);
+  };
+  if (resolutionError) {
+    throw resolutionError;
+  }
+  if (isWaitingForPeerSchemas) {
+    return /* @__PURE__ */ jsxs7("div", { className: "raf-loading-state", role: "status", "aria-live": "polite", children: [
+      /* @__PURE__ */ jsx11("span", { className: "raf-loading-spinner", "aria-hidden": "true" }),
+      /* @__PURE__ */ jsx11("span", { children: "Waiting for required peer schema(s)" })
+    ] });
+  }
+  if (!resolvedSchema) {
+    return /* @__PURE__ */ jsx11("div", { className: "raf-muted", children: "Resolving schema references..." });
+  }
+  return /* @__PURE__ */ jsx11("div", { className: "raf-schema-form", children: /* @__PURE__ */ jsx11(
+    SchemaFieldRenderer,
+    {
+      schema: resolvedSchema,
+      label: resolvedSchema.title ?? "Schema Form",
+      required: true,
+      pointer: "",
+      schemaPointer: "",
+      value: formData,
+      onChange: handleFieldChange,
+      widgets
+    }
+  ) });
+}
+function getDataValidationErrors(data, schema) {
+  try {
+    validateDataOrThrow(data, schema);
+    return [];
+  } catch (error) {
+    return [
+      {
+        message: error instanceof Error ? error.message : "Validation error",
+        source: "data"
+      }
+    ];
+  }
+}
+async function resolveSchemaWithFallback(rootSchema, initialPeerSchemas, getSchema) {
+  const attemptedRefs = /* @__PURE__ */ new Set();
+  let currentPeerSchemas = initialPeerSchemas;
+  while (true) {
+    try {
+      return await resolveSchemaRefs(rootSchema, currentPeerSchemas);
+    } catch (error) {
+      if (!(error instanceof MissingPeerSchemaError)) {
+        throw error;
+      }
+      const missingRef = error.ref;
+      if (attemptedRefs.has(missingRef)) {
+        throw new Error(`Could not resolve referenced peer schema for: ${missingRef}`);
+      }
+      attemptedRefs.add(missingRef);
+      let fetchedSchema;
+      try {
+        const maybeSchema = await getSchema(missingRef);
+        if (!maybeSchema) {
+          throw new Error(`getSchema resolved without a schema for: ${missingRef}`);
+        }
+        fetchedSchema = maybeSchema;
+      } catch (fetchError) {
+        const message = fetchError instanceof Error ? fetchError.message : "Unknown schema loading error.";
+        throw new Error(`Failed to load referenced schema for: ${missingRef}. ${message}`);
+      }
+      validateSchemaOrThrow(fetchedSchema, `getSchema(${missingRef})`);
+      currentPeerSchemas = appendPeerSchema(currentPeerSchemas, missingRef, fetchedSchema);
+    }
+  }
+}
+function appendPeerSchema(peerSchemas, requestedRef, schema) {
+  const next = {};
+  if (Array.isArray(peerSchemas)) {
+    for (const item of peerSchemas) {
+      if (typeof item.$id === "string" && item.$id.length > 0) {
+        next[item.$id] = item;
+      }
+    }
+  } else if (peerSchemas) {
+    Object.assign(next, peerSchemas);
+  }
+  next[requestedRef] = schema;
+  const requestedRootId = extractReferenceRootId(requestedRef);
+  if (requestedRootId) {
+    next[requestedRootId] = schema;
+  }
+  if (typeof schema.$id === "string" && schema.$id.length > 0) {
+    next[schema.$id] = schema;
+  }
+  return next;
+}
+function extractReferenceRootId(ref) {
+  const hashIndex = ref.indexOf("#");
+  if (hashIndex === -1) {
+    return ref;
+  }
+  return ref.slice(0, hashIndex);
+}
+
+// src/components/SchemaBuilder.tsx
+import { createContext, useCallback, useContext, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState as useState3 } from "react";
+import parse from "html-react-parser";
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+var FIELD_TYPES = ["string", "number", "integer", "boolean", "object", "array", "null"];
+var DEFAULT_SCHEMA_URI = "https://json-schema.org/draft/2020-12/schema";
+var FieldHelpContext = createContext(null);
+var FIELD_HELP_BASE_CONTENT = {
+  "$id": {
+    summary: "Sets the base URI that identifies this schema.",
+    details: "Use <strong>$id</strong> to assign a stable identifier for the schema resource. Relative references and nested schema identifiers are resolved against this base URI."
+  },
+  "$schema": {
+    summary: "Declares which JSON Schema dialect this schema uses.",
+    details: "Set <strong>$schema</strong> to the meta-schema URI for the draft you target, such as 2020-12. Validators use it to interpret keyword behavior and vocabulary support."
+  },
+  "$ref": {
+    summary: "References another schema and applies it at this location.",
+    details: "Use <strong>$ref</strong> to point to a schema URI or JSON Pointer. Validation of this node is delegated to the referenced schema, allowing reuse and composition."
+  },
+  type: {
+    summary: "Restricts instance values to one or more JSON types.",
+    details: "Set <strong>type</strong> to a single <strong>type</strong> or a list of allowed types. This controls which instances can match and which <strong>type</strong>-specific assertion keywords are meaningful."
+  },
+  title: {
+    summary: "Provides a short human-readable name for the schema.",
+    details: "Use <strong>title</strong> as annotation text for UI labels, documentation, and schema browsing. It does <strong>not</strong> affect assertion or pass/fail validation outcomes."
+  },
+  description: {
+    summary: "Provides longer human-readable documentation for the schema.",
+    details: "Use <strong>description</strong> to explain intent, constraints, and <strong>examples</strong> in prose. It is an annotation keyword and does <strong>not</strong> directly change validation results."
+  },
+  deprecated: {
+    summary: "Marks values as discouraged for future use.",
+    details: "Set <strong>deprecated</strong> to true to signal that this schema location should be phased out. It is metadata for tooling and consumers rather than an assertion failure."
+  },
+  readonly: {
+    summary: "Marks a value as read-only for producers and clients.",
+    details: "<strong>readOnly</strong> is an annotation commonly used by APIs and forms to prevent user edits on output-only fields. It does <strong>not</strong> invalidate JSON instances by itself."
+  },
+  writeonly: {
+    summary: "Marks a value as write-only and not intended for output.",
+    details: "<strong>writeOnly</strong> is an annotation used for sensitive or input-only fields. Tooling may hide these in responses while still accepting them in requests."
+  },
+  examples: {
+    summary: "Supplies sample instance values for this schema location.",
+    details: "Use <strong>examples</strong> as annotation data to illustrate typical values. These samples support docs and UI guidance but are <strong>not</strong> automatically enforced as constraints."
+  },
+  default: {
+    summary: "Provides a suggested default value for consumers.",
+    details: "<strong>default</strong> is an annotation that tools may use to prefill forms or generated objects. Validators do <strong>not</strong> automatically insert or require this value."
+  },
+  const: {
+    summary: "Requires the instance to equal exactly one value.",
+    details: "Use <strong>const</strong> when a field must always be a specific literal value. The instance must match this value exactly, including <strong>type</strong> and structure."
+  },
+  enum: {
+    summary: "Restricts the instance to one of the listed values.",
+    details: "<strong>enum</strong> defines an allowed set of values and the instance must equal one of them. Values can be strings, numbers, booleans, null, objects, or arrays."
+  },
+  minlength: {
+    summary: "Sets the minimum string length in Unicode code points.",
+    details: "<strong>minLength</strong> requires string instances to have at least this many characters. Use it with <strong>maxLength</strong> to bound accepted string sizes."
+  },
+  maxlength: {
+    summary: "Sets the maximum string length in Unicode code points.",
+    details: "<strong>maxLength</strong> requires string instances to be no longer than this value. It applies only when the instance <strong>type</strong> is string."
+  },
+  pattern: {
+    summary: "Requires strings to match a regular expression. (HINT: Don't provide the leading or trailing slashes.)",
+    details: "<strong>pattern</strong> uses an ECMA-262 compatible regular expression. A string is valid when the regex finds a match within the instance text."
+  },
+  format: {
+    summary: "Annotates or optionally asserts semantic string formats.",
+    details: "<strong>format</strong> communicates semantic expectations such as email, uri, or date-time. Depending on validator configuration, it may be informational or enforced."
+  },
+  minimum: {
+    summary: "Sets the inclusive numeric lower bound.",
+    details: "<strong>minimum</strong> requires numbers to be greater than or equal to this value. Use <strong>exclusiveMinimum</strong> when the lower bound should be strict."
+  },
+  maximum: {
+    summary: "Sets the inclusive numeric upper bound.",
+    details: "<strong>maximum</strong> requires numbers to be less than or equal to this value. Use <strong>exclusiveMaximum</strong> when the upper bound should be strict."
+  },
+  multipleof: {
+    summary: "Requires numbers to be a multiple of the given divisor.",
+    details: "<strong>multipleOf</strong> checks exact divisibility by a positive number. It is useful for increments such as currency steps or fixed precision values."
+  },
+  exclusiveminimum: {
+    summary: "Sets a strict numeric lower bound.",
+    details: "<strong>exclusiveMinimum</strong> requires numbers to be strictly greater than this value. Instances equal to the boundary are invalid."
+  },
+  exclusivemaximum: {
+    summary: "Sets a strict numeric upper bound.",
+    details: "<strong>exclusiveMaximum</strong> requires numbers to be strictly less than this value. Instances equal to the boundary are invalid."
+  },
+  properties: {
+    summary: "Defines schemas for named object properties.",
+    details: "<strong>properties</strong> maps property names to subschemas. When an instance has a matching property, that value is validated against the corresponding subschema."
+  },
+  required: {
+    summary: "Lists object properties that must be present.",
+    details: "<strong>required</strong> is an array of property names. Each listed name must appear on the object instance for validation to succeed."
+  },
+  additionalproperties: {
+    summary: "Controls validation of object properties not listed in properties.",
+    details: "<strong>additionalProperties</strong> applies to remaining object members after <strong>properties</strong> and <strong>patternProperties</strong>. Use false to disallow extras or a schema to validate them."
+  },
+  unevaluatedproperties: {
+    summary: "Applies constraints to object properties not yet evaluated.",
+    details: "<strong>unevaluatedProperties</strong> validates leftover object members after all applicable subschemas are considered. It helps enforce closed shapes with composition."
+  },
+  propertynames: {
+    summary: "Validates each object property name as a string.",
+    details: "<strong>propertyNames</strong> applies its subschema to every key name in the object. This is useful for naming rules such as patterns or length limits on keys."
+  },
+  minproperties: {
+    summary: "Sets the minimum number of object properties.",
+    details: "<strong>minProperties</strong> requires objects to contain at least this many <strong>properties</strong>. It is ignored for non-object instances."
+  },
+  maxproperties: {
+    summary: "Sets the maximum number of object properties.",
+    details: "<strong>maxProperties</strong> requires objects to contain no more than this many <strong>properties</strong>. It is ignored for non-object instances."
+  },
+  dependentrequired: {
+    summary: "Requires additional properties when a property is present.",
+    details: "<strong>dependentRequired</strong> maps a property name to a list of peer <strong>properties</strong> that must also exist whenever that property appears."
+  },
+  dependentschemas: {
+    summary: "Applies additional schema rules when a property is present.",
+    details: "<strong>dependentSchemas</strong> maps a property name to a subschema. <strong>If</strong> that property exists in the instance object, the entire object must satisfy the mapped schema."
+  },
+  patternproperties: {
+    summary: "Applies schemas to object properties that match regex keys.",
+    details: "<strong>patternProperties</strong> uses regular-expression keys to target groups of property names. Matching <strong>properties</strong> are validated by the associated subschema."
+  },
+  items: {
+    summary: "Defines the schema for array elements after tuple positions.",
+    details: "In 2020-12, <strong>items</strong> applies to array elements <strong>not</strong> covered by <strong>prefixItems</strong>. Set a schema to validate trailing elements, or false to disallow them."
+  },
+  prefixitems: {
+    summary: "Defines positional schemas for tuple-style arrays.",
+    details: "<strong>prefixItems</strong> is an ordered list of schemas, each applied to the array element at the same index. It models fixed-position tuple structures."
+  },
+  minitems: {
+    summary: "Sets the minimum number of items in an array.",
+    details: "<strong>minItems</strong> requires arrays to contain at least this many elements. It is ignored for non-array instances."
+  },
+  maxitems: {
+    summary: "Sets the maximum number of items in an array.",
+    details: "<strong>maxItems</strong> requires arrays to contain no more than this many elements. It is ignored for non-array instances."
+  },
+  uniqueitems: {
+    summary: "Requires all array items to be pairwise unique.",
+    details: "When <strong>uniqueItems</strong> is true, no two <strong>items</strong> in the array may be deeply equal. It enforces set-like semantics for arrays."
+  },
+  contains: {
+    summary: "Requires at least one array item to match a subschema.",
+    details: "<strong>contains</strong> checks array elements against a subschema and succeeds when enough matches are found. Combine with <strong>minContains</strong> and <strong>maxContains</strong> for match counts."
+  },
+  mincontains: {
+    summary: "Sets the minimum number of contains matches.",
+    details: "<strong>minContains</strong> works with <strong>contains</strong> and requires at least this many matching elements. It is ignored when <strong>contains</strong> is absent."
+  },
+  maxcontains: {
+    summary: "Sets the maximum number of contains matches.",
+    details: "<strong>maxContains</strong> works with <strong>contains</strong> and requires no more than this many matching elements. It is ignored when <strong>contains</strong> is absent."
+  },
+  unevaluateditems: {
+    summary: "Applies constraints to array items not yet evaluated.",
+    details: "<strong>unevaluatedItems</strong> validates leftover array elements after <strong>prefixItems</strong>, <strong>items</strong>, <strong>contains</strong>, and composed schemas are processed."
+  },
+  allof: {
+    summary: "Requires the instance to satisfy every listed subschema.",
+    details: "<strong>allOf</strong> composes schemas with logical AND behavior. The instance is valid only <strong>if</strong> it passes all subschemas in the array."
+  },
+  anyof: {
+    summary: "Requires the instance to satisfy at least one subschema.",
+    details: "<strong>anyOf</strong> composes schemas with logical OR behavior. The instance is valid when one or more listed subschemas validate."
+  },
+  oneof: {
+    summary: "Requires the instance to satisfy exactly one subschema.",
+    details: "<strong>oneOf</strong> succeeds only when exactly one subschema validates. It is useful for mutually exclusive alternatives."
+  },
+  not: {
+    summary: "Requires the instance to fail a given subschema.",
+    details: "<strong>not</strong> inverts schema logic. The instance is valid only when it does <strong>not</strong> validate against the <strong>not</strong> subschema."
+  },
+  if: {
+    summary: "Defines the condition used by conditional schemas.",
+    details: "<strong>if</strong> applies a subschema test. When it passes, <strong>then</strong> is applied; when it fails, <strong>else</strong> is applied, <strong>if</strong> those branches are present."
+  },
+  then: {
+    summary: "Applies extra constraints when if succeeds.",
+    details: "<strong>then</strong> is evaluated only when the <strong>if</strong> subschema validates. Use it to enforce rules that should hold under a matching condition."
+  },
+  else: {
+    summary: "Applies extra constraints when if fails.",
+    details: "<strong>else</strong> is evaluated only when the <strong>if</strong> subschema does <strong>not</strong> validate. Use it as the alternate branch of conditional validation."
+  }
+};
+var FIELD_HELP_LONG_DETAILS = {
+  "$id": "The <strong>$id</strong> keyword establishes the canonical URI for a schema resource, which becomes the base for relative references and nested identifiers. In draft 2020-12, stable and absolute identifiers make schema reuse, bundling, and external referencing significantly more predictable across tools.",
+  "$schema": "The <strong>$schema</strong> keyword declares the dialect and meta-schema that define keyword behavior for this document. Declaring this explicitly helps validators select correct semantics and avoids ambiguity when multiple drafts are supported.",
+  "$ref": "The <strong>$ref</strong> keyword replaces local constraints with the referenced schema target, enabling modular schema design and reuse. In 2020-12, references participate in dynamic resolution rules and should be treated as schema application rather than a textual include.",
+  type: "The <strong>type</strong> keyword constrains instance types and is often the first line of validation structure for a field. In 2020-12, <strong>type</strong> can be a single value or an array of values to express unions, and other assertion keywords should align with the allowed types.",
+  title: "The <strong>title</strong> keyword is an annotation intended for human-facing tools such as documentation and generated forms. While it does <strong>not</strong> influence pass/fail validation, it is important for readability and schema maintainability.",
+  description: "The <strong>description</strong> keyword provides richer human guidance about expected data semantics and usage context. It is annotation-only, so it should be used to improve comprehension without being relied on for enforcement.",
+  deprecated: "The <strong>deprecated</strong> keyword communicates that a field or value path is still accepted but should be phased out. This is particularly useful for compatibility windows and migration planning in APIs and event schemas.",
+  readonly: "The <strong>readOnly</strong> keyword is an annotation that indicates values are intended to be supplied by producers and <strong>not</strong> edited by consumers. It is commonly interpreted by UI and API tooling even though it is <strong>not</strong> a direct validation assertion.",
+  writeonly: "The <strong>writeOnly</strong> keyword is an annotation indicating values are intended for input but should <strong>not</strong> be returned in output contexts. It is often used for secrets, credentials, and transient request-only fields.",
+  examples: "The <strong>examples</strong> keyword provides non-normative sample instances that help humans and tools understand expected values. These <strong>examples</strong> are documentation aids and are <strong>not</strong> <strong>required</strong> to be validated as constraints by implementations.",
+  default: "The <strong>default</strong> keyword suggests a value that may be used when an instance omits the field. Because JSON Schema does <strong>not</strong> mandate <strong>default</strong> assignment behavior, producers should treat it as guidance rather than implicit mutation.",
+  const: "The <strong>const</strong> keyword enforces exact deep-equality with one specific JSON value, including <strong>type</strong> and structure. It is useful when a discriminator or fixed contract token must always remain constant.",
+  enum: "The <strong>enum</strong> keyword constrains the instance to one of a finite set of values compared by JSON deep-equality. This is ideal for controlled vocabularies and closed option sets across both primitive and structured values.",
+  minlength: "The <strong>minLength</strong> keyword applies only to strings and sets a lower bound measured in Unicode code points. It should be paired thoughtfully with <strong>maxLength</strong> when defining bounded text fields.",
+  maxlength: "The <strong>maxLength</strong> keyword applies only to strings and sets an upper bound measured in Unicode code points. This protects payload size and supports UI, storage, and transport constraints.",
+  pattern: "The <strong>pattern</strong> keyword applies an ECMA-262 regular expression to string instances, succeeding when a match is found. Patterns are <strong>not</strong> implicitly anchored, so use explicit anchors when full-string matching is <strong>required</strong>.",
+  format: "The <strong>format</strong> keyword conveys semantic expectations such as email, URI, hostname, or date-time. In 2020-12, <strong>format</strong> behavior depends on implementation configuration and may be annotation-only unless assertions are enabled.",
+  minimum: "The <strong>minimum</strong> keyword sets an inclusive numeric lower bound and applies to number and integer instances. Use this when a boundary value itself is valid and should be accepted.",
+  maximum: "The <strong>maximum</strong> keyword sets an inclusive numeric upper bound and applies to number and integer instances. Use this when the boundary value itself should remain valid.",
+  multipleof: "The <strong>multipleOf</strong> keyword requires numeric values to divide evenly by a positive divisor. This is commonly used to enforce precision steps, measurement increments, and monetary granularity.",
+  exclusiveminimum: "The <strong>exclusiveMinimum</strong> keyword defines a strict numeric boundary where values must be greater than the threshold. It is appropriate when an endpoint must be excluded from valid input.",
+  exclusivemaximum: "The <strong>exclusiveMaximum</strong> keyword defines a strict numeric boundary where values must be less than the threshold. It is useful for open upper intervals and strict cap behavior.",
+  properties: "The <strong>properties</strong> keyword maps specific object member names to subschemas that validate corresponding member values. It only applies when those named members are present and does <strong>not</strong> by itself require their presence.",
+  required: "The <strong>required</strong> keyword lists object property names that must exist on an instance object. Presence is enforced independently from value constraints, which are validated by associated subschemas.",
+  additionalproperties: "The <strong>additionalProperties</strong> keyword controls validation for object members <strong>not</strong> matched by <strong>properties</strong> or <strong>patternProperties</strong>. In strict object designs, setting this to false prevents unrecognized keys from passing.",
+  unevaluatedproperties: "The <strong>unevaluatedProperties</strong> keyword applies after other applicators and targets object members that remain unevaluated. This makes it especially powerful with composition keywords when enforcing closed-world object shapes.",
+  propertynames: "The <strong>propertyNames</strong> keyword validates each object key string against a subschema, independent of corresponding values. It is useful for naming conventions, prefix rules, and machine-generated key constraints.",
+  minproperties: "The <strong>minProperties</strong> keyword sets the <strong>minimum</strong> count of key/value pairs <strong>required</strong> in an object instance. It supports cardinality rules independent from which exact <strong>properties</strong> are <strong>required</strong>.",
+  maxproperties: "The <strong>maxProperties</strong> keyword sets the <strong>maximum</strong> count of key/value pairs permitted in an object instance. This can prevent over-populated objects and constrain dynamic key scenarios.",
+  dependentrequired: "The <strong>dependentRequired</strong> keyword expresses conditional presence dependencies between object <strong>properties</strong>. When one property appears, a configured list of sibling <strong>properties</strong> must also be present.",
+  dependentschemas: "The <strong>dependentSchemas</strong> keyword applies whole-object subschemas when specific trigger <strong>properties</strong> are present. It enables conditional object validation patterns that go beyond simple <strong>required</strong> lists.",
+  patternproperties: "The <strong>patternProperties</strong> keyword assigns subschemas to regex-based key groups, allowing families of similarly named members to share validation rules. Multiple regexes may apply to the same property name.",
+  items: "In draft 2020-12, <strong>items</strong> applies to array positions <strong>not</strong> covered by <strong>prefixItems</strong> and therefore governs trailing elements. This separates tuple-prefix constraints from the schema for remaining array entries.",
+  prefixitems: "The <strong>prefixItems</strong> keyword defines positional schemas for tuple-like arrays where each index has a distinct rule. It is evaluated in order and is foundational for fixed-structure array contracts.",
+  minitems: "The <strong>minItems</strong> keyword sets the <strong>minimum</strong> number of elements <strong>required</strong> in an array instance. It is commonly combined with <strong>contains</strong> or tuple rules to ensure baseline completeness.",
+  maxitems: "The <strong>maxItems</strong> keyword sets the <strong>maximum</strong> number of elements permitted in an array instance. It is useful for preventing oversized arrays and bounding processing cost.",
+  uniqueitems: "When <strong>uniqueItems</strong> is true, every pair of array elements must be unequal under deep JSON comparison. This enforces set-like semantics, including for objects and arrays.",
+  contains: "The <strong>contains</strong> keyword requires array instances to include elements matching a given subschema. In 2020-12, it can be further quantified with <strong>minContains</strong> and <strong>maxContains</strong> to constrain match counts.",
+  mincontains: "The <strong>minContains</strong> keyword defines the <strong>minimum</strong> number of elements that must satisfy the <strong>contains</strong> subschema. It is ignored when <strong>contains</strong> is absent and should be configured alongside <strong>contains</strong>.",
+  maxcontains: "The <strong>maxContains</strong> keyword defines the <strong>maximum</strong> number of elements that may satisfy the <strong>contains</strong> subschema. It is ignored when <strong>contains</strong> is absent and helps bound matching frequency.",
+  unevaluateditems: "The <strong>unevaluatedItems</strong> keyword applies to array elements <strong>not</strong> already evaluated by <strong>prefixItems</strong>, <strong>items</strong>, <strong>contains</strong>, or composed branches. It is valuable for enforcing tight post-composition array contracts.",
+  allof: "The <strong>allOf</strong> keyword requires the instance to satisfy every subschema in the array, equivalent to logical conjunction. It is useful for composing orthogonal constraints into a single effective schema.",
+  anyof: "The <strong>anyOf</strong> keyword requires at least one subschema to validate, equivalent to logical disjunction. It is suitable for permissive alternatives where overlaps are acceptable.",
+  oneof: "The <strong>oneOf</strong> keyword requires exactly one subschema to validate, making it stricter than <strong>anyOf</strong>. It is commonly used for tagged union designs where alternatives should be mutually exclusive.",
+  not: "The <strong>not</strong> keyword inverts validation for its subschema and passes only when the subschema fails. It is useful for exclusion constraints and disallowing problematic shapes.",
+  if: "The <strong>if</strong> keyword defines a predicate subschema used to choose conditional branches. Its result controls whether <strong>then</strong> or <strong>else</strong> is evaluated when those keywords are present.",
+  then: "The <strong>then</strong> keyword is applied only when <strong>if</strong> succeeds, allowing additional constraints in the true branch. It is often paired with discriminators and property dependencies.",
+  else: "The <strong>else</strong> keyword is applied only when <strong>if</strong> fails, providing alternate constraints for the false branch. Together with <strong>if</strong>/<strong>then</strong>, it forms full conditional validation flow in a single schema node."
+};
+var FIELD_HELP_LINKS = {
+  "$id": "https://json-schema.org/draft/2020-12/json-schema-core.html#name-the-id-keyword",
+  "$schema": "https://json-schema.org/draft/2020-12/json-schema-core.html#name-the-schema-keyword",
+  "$ref": "https://json-schema.org/draft/2020-12/json-schema-core.html#name-the-ref-keyword",
+  type: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-type",
+  title: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-title",
+  description: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-description",
+  deprecated: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-deprecated",
+  readonly: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-readonly",
+  writeonly: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-writeonly",
+  examples: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-examples",
+  default: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-default",
+  const: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-const",
+  enum: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-enum",
+  minlength: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-minlength",
+  maxlength: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-maxlength",
+  pattern: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-pattern",
+  format: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-format",
+  minimum: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-minimum",
+  maximum: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-maximum",
+  multipleof: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-multipleof",
+  exclusiveminimum: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-exclusiveminimum",
+  exclusivemaximum: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-exclusivemaximum",
+  properties: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-properties",
+  required: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-required",
+  additionalproperties: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-additionalproperties",
+  unevaluatedproperties: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-unevaluatedproperties",
+  propertynames: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-propertynames",
+  minproperties: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-minproperties",
+  maxproperties: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-maxproperties",
+  dependentrequired: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-dependentrequired",
+  dependentschemas: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-dependentschemas",
+  patternproperties: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-patternproperties",
+  items: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-items",
+  prefixitems: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-prefixitems",
+  minitems: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-minitems",
+  maxitems: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-maxitems",
+  uniqueitems: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-uniqueitems",
+  contains: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-contains",
+  mincontains: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-mincontains",
+  maxcontains: "https://json-schema.org/draft/2020-12/json-schema-validation.html#name-maxcontains",
+  unevaluateditems: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-unevaluateditems",
+  allof: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-allof",
+  anyof: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-anyof",
+  oneof: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-oneof",
+  not: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-not",
+  if: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-if",
+  then: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-then",
+  else: "https://json-schema.org/draft/2020-12/json-schema-core.html#name-else"
+};
+var DEFAULT_HELP_LINK = "https://json-schema.org/draft/2020-12/";
+var FIELD_HELP_CONTENT = Object.fromEntries(
+  Object.entries(FIELD_HELP_BASE_CONTENT).map(([key, value]) => [
+    key,
+    {
+      ...value,
+      longDetails: FIELD_HELP_LONG_DETAILS[key] ?? "This keyword participates in JSON Schema 2020-12 evaluation and should be configured according to the intended assertion and annotation behavior.",
+      link: FIELD_HELP_LINKS[key] ?? DEFAULT_HELP_LINK
+    }
+  ])
+);
+function normalizeHelpKey(value) {
+  return value.trim().toLowerCase().replace(/\(.*?\)/g, "").replace(/\s+/g, "").replace(/[^$a-z0-9]/g, "");
+}
+function resolveHelpDefinition(keywordOrLabel) {
+  const normalized = normalizeHelpKey(keywordOrLabel);
+  if (normalized === "types") {
+    return FIELD_HELP_CONTENT.type;
+  }
+  if (normalized === "min") {
+    return FIELD_HELP_CONTENT.minimum;
+  }
+  if (normalized === "max") {
+    return FIELD_HELP_CONTENT.maximum;
+  }
+  const direct = FIELD_HELP_CONTENT[normalized];
+  if (direct) {
+    return direct;
+  }
+  return {
+    summary: "Defines behavior for this schema field.",
+    details: "This control edits a JSON Schema keyword or related configuration for the current node. Set a value here to shape validation and annotations.",
+    longDetails: "For exact semantics, check the draft 2020-12 specification section for this keyword and confirm whether your validator treats it as an assertion, annotation, or applicator.",
+    link: DEFAULT_HELP_LINK
+  };
+}
+var KEYWORD_DISPLAY_LABELS = {
+  readonly: "readOnly",
+  writeonly: "writeOnly",
+  minlength: "minLength",
+  maxlength: "maxLength",
+  multipleof: "multipleOf",
+  exclusiveminimum: "exclusiveMinimum",
+  exclusivemaximum: "exclusiveMaximum",
+  additionalproperties: "additionalProperties",
+  unevaluatedproperties: "unevaluatedProperties",
+  propertynames: "propertyNames",
+  minproperties: "minProperties",
+  maxproperties: "maxProperties",
+  dependentrequired: "dependentRequired",
+  dependentschemas: "dependentSchemas",
+  patternproperties: "patternProperties",
+  prefixitems: "prefixItems",
+  minitems: "minItems",
+  maxitems: "maxItems",
+  uniqueitems: "uniqueItems",
+  mincontains: "minContains",
+  maxcontains: "maxContains",
+  unevaluateditems: "unevaluatedItems",
+  allof: "allOf",
+  anyof: "anyOf",
+  oneof: "oneOf"
+};
+function stripHtmlMarkup(text) {
+  return text.replace(/<[^>]+>/g, "");
+}
+function toKeywordDisplayLabel(keyword) {
+  return KEYWORD_DISPLAY_LABELS[keyword] ?? keyword;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function uniqueQueryWords(input) {
+  const words = input.toLowerCase().split(/[^$a-z0-9]+/g).filter((word) => word.length > 0);
+  return Array.from(new Set(words));
+}
+function countOccurrences(text, query) {
+  const normalizedText = text.toLowerCase();
+  const normalizedQuery = query.toLowerCase();
+  if (!normalizedQuery) {
+    return 0;
+  }
+  let count = 0;
+  let searchIndex = 0;
+  while (searchIndex < normalizedText.length) {
+    const matchIndex = normalizedText.indexOf(normalizedQuery, searchIndex);
+    if (matchIndex < 0) {
+      break;
+    }
+    count += 1;
+    searchIndex = matchIndex + normalizedQuery.length;
+  }
+  return count;
+}
+function buildSnippet(text, words, targetLength = 180) {
+  if (text.length <= targetLength) {
+    return text;
+  }
+  const lowerText = text.toLowerCase();
+  let bestIndex = -1;
+  for (const word of words) {
+    const index = lowerText.indexOf(word);
+    if (index >= 0 && (bestIndex === -1 || index < bestIndex)) {
+      bestIndex = index;
+    }
+  }
+  const anchor = bestIndex >= 0 ? bestIndex : 0;
+  const halfWindow = Math.floor(targetLength / 2);
+  let start = Math.max(0, anchor - halfWindow);
+  let end = Math.min(text.length, start + targetLength);
+  if (end - start < targetLength) {
+    start = Math.max(0, end - targetLength);
+  }
+  const rawSlice = text.slice(start, end).trim();
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < text.length ? "..." : "";
+  return `${prefix}${rawSlice}${suffix}`;
+}
+function renderHighlightedSnippet(snippet, words) {
+  if (words.length === 0) {
+    return [snippet];
+  }
+  const pattern = new RegExp(`(${words.map((word) => escapeRegExp(word)).sort((a, b) => b.length - a.length).join("|")})`, "gi");
+  const parts = snippet.split(pattern);
+  const lowerWords = new Set(words.map((word) => word.toLowerCase()));
+  return parts.map((part, index) => {
+    if (part && lowerWords.has(part.toLowerCase())) {
+      return /* @__PURE__ */ jsx12("strong", { children: part }, `snippet-part-${index}`);
+    }
+    return part;
+  });
+}
+function resolveHelperContentEntries(helpContent) {
+  if (!helpContent) {
+    return Object.entries(FIELD_HELP_LONG_DETAILS).map(([keyword, longDetails]) => ({
+      keyword,
+      keywordLabel: toKeywordDisplayLabel(keyword),
+      longDetails
+    }));
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [rawKey, rawEntry] of Object.entries(helpContent)) {
+    const keyword = normalizeHelpKey(rawKey);
+    if (!keyword) {
+      continue;
+    }
+    const entry = typeof rawEntry === "string" ? { longDetails: rawEntry } : {
+      longDetails: rawEntry.longDetails,
+      label: rawEntry.label
+    };
+    if (!entry.longDetails.trim()) {
+      continue;
+    }
+    const fallbackLabel = keyword in FIELD_HELP_LONG_DETAILS ? toKeywordDisplayLabel(keyword) : rawKey.trim() || keyword;
+    const keywordLabel = entry.label?.trim() || fallbackLabel;
+    resolved.set(keyword, {
+      keyword,
+      keywordLabel,
+      longDetails: entry.longDetails
+    });
+  }
+  return Array.from(resolved.values());
+}
+function SchemaBuilderHelper({
+  debounceMs = 280,
+  maxResults = 12,
+  placeholder = "Type to search schema keyword guidance...",
+  initialQuery = "",
+  helpContent
+}) {
+  const [query, setQuery] = useState3(initialQuery);
+  const [debouncedQuery, setDebouncedQuery] = useState3(initialQuery);
+  const helperEntries = useMemo2(() => resolveHelperContentEntries(helpContent), [helpContent]);
+  useEffect3(() => {
+    const handle = window.setTimeout(() => {
+      setDebouncedQuery(query);
+    }, debounceMs);
+    return () => {
+      window.clearTimeout(handle);
+    };
+  }, [query, debounceMs]);
+  const matches = useMemo2(() => {
+    const words = uniqueQueryWords(debouncedQuery);
+    if (words.length === 0) {
+      return [];
+    }
+    const scored = helperEntries.map((entry) => {
+      const plainText = stripHtmlMarkup(entry.longDetails);
+      const normalized = plainText.toLowerCase();
+      let matchedWords = 0;
+      let weightedHits = 0;
+      let totalHits = 0;
+      for (const word of words) {
+        const hits = countOccurrences(normalized, word);
+        if (hits > 0) {
+          matchedWords += 1;
+          totalHits += hits;
+          weightedHits += hits * Math.max(word.length, 1);
+        }
+      }
+      if (matchedWords === 0) {
+        return null;
+      }
+      const score = matchedWords * 100 + weightedHits * 10 + totalHits;
+      return {
+        keyword: entry.keyword,
+        keywordLabel: entry.keywordLabel,
+        snippet: buildSnippet(plainText, words),
+        score
+      };
+    }).filter((entry) => entry !== null).sort((a, b) => b.score - a.score || a.keywordLabel.localeCompare(b.keywordLabel));
+    return scored.slice(0, maxResults);
+  }, [debouncedQuery, helperEntries, maxResults]);
+  const highlightWords = useMemo2(() => uniqueQueryWords(debouncedQuery), [debouncedQuery]);
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-helper-panel", children: [
+    /* @__PURE__ */ jsx12("h3", { className: "raf-helper-title", children: "Keyword Assistant" }),
+    /* @__PURE__ */ jsx12("div", { className: "raf-helper-subtitle", children: "Searches keyword guidance in long-form JSON Schema notes." }),
+    /* @__PURE__ */ jsx12(
+      "input",
+      {
+        className: "raf-input raf-builder-control",
+        type: "text",
+        value: query,
+        onChange: (event) => setQuery(event.target.value),
+        placeholder,
+        "aria-label": "Search SchemaBuilder keyword help"
+      }
+    ),
+    /* @__PURE__ */ jsx12("div", { className: "raf-helper-results", role: "region", "aria-label": "SchemaBuilder helper results", children: highlightWords.length === 0 ? /* @__PURE__ */ jsx12("div", { className: "raf-helper-empty", children: "Start typing to see matching keyword snippets." }) : matches.length === 0 ? /* @__PURE__ */ jsx12("div", { className: "raf-helper-empty", children: "No matching keyword guidance found." }) : matches.map((match) => /* @__PURE__ */ jsxs8("article", { className: "raf-helper-snippet", children: [
+      /* @__PURE__ */ jsx12("header", { className: "raf-helper-snippet-keyword", children: match.keywordLabel }),
+      /* @__PURE__ */ jsx12("div", { className: "raf-helper-snippet-body", children: renderHighlightedSnippet(match.snippet, highlightWords) })
+    ] }, match.keyword)) })
+  ] });
+}
+function SchemaBuilder({ schema, domain, onChange }) {
+  const [currentSchema, setCurrentSchema] = useState3(() => schema ?? createDefaultRootSchema());
+  const [rawJson, setRawJson] = useState3(() => JSON.stringify(schema ?? createDefaultRootSchema(), null, 2));
+  const [rawJsonError, setRawJsonError] = useState3(null);
+  const [activeHelp, setActiveHelp] = useState3(null);
+  const onChangeRef = useRef3(onChange);
+  const publishedSchema = useMemo2(() => {
+    const sanitized = sanitizeSchemaForOutput(currentSchema);
+    return applyDomainToRootId(sanitized, domain);
+  }, [currentSchema, domain]);
+  useEffect3(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  useEffect3(() => {
+    if (schema) {
+      setCurrentSchema(cloneSchema(schema));
+    }
+  }, [schema]);
+  useEffect3(() => {
+    setRawJson(JSON.stringify(currentSchema, null, 2));
+    const validationErrors = validateSchemaDefinition(publishedSchema);
+    onChangeRef.current?.(publishedSchema, validationErrors);
+  }, [currentSchema, publishedSchema]);
+  const handleRootChange = (nextSchema) => {
+    setCurrentSchema(nextSchema);
+  };
+  const openHelp = useCallback((key, label, anchor) => {
+    setActiveHelp({ key, label, anchor });
+  }, []);
+  const closeHelp = useCallback(() => {
+    setActiveHelp(null);
+  }, []);
+  const prettySchema = useMemo2(() => JSON.stringify(publishedSchema, null, 2), [publishedSchema]);
+  return /* @__PURE__ */ jsxs8(FieldHelpContext.Provider, { value: { openHelp }, children: [
+    /* @__PURE__ */ jsxs8("div", { className: "raf-schema-builder", children: [
+      /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          schema: currentSchema,
+          label: "Root Schema",
+          isRoot: true,
+          domain,
+          onChange: handleRootChange
+        }
+      ),
+      /* @__PURE__ */ jsxs8("details", { className: "raf-object", children: [
+        /* @__PURE__ */ jsx12("summary", { className: "raf-object-summary", children: "Advanced: Edit Full Schema JSON" }),
+        /* @__PURE__ */ jsxs8("div", { className: "raf-object-content", children: [
+          /* @__PURE__ */ jsx12(
+            "textarea",
+            {
+              className: "raf-textarea",
+              value: rawJson,
+              onChange: (event) => {
+                const nextText = event.target.value;
+                setRawJson(nextText);
+                try {
+                  const parsed = JSON.parse(nextText);
+                  if (!isObject3(parsed)) {
+                    const message = "Schema JSON must be an object.";
+                    setRawJsonError(message);
+                    onChangeRef.current?.(publishedSchema, [
+                      {
+                        message,
+                        source: "json-parse"
+                      }
+                    ]);
+                    return;
+                  }
+                  setRawJsonError(null);
+                  setCurrentSchema(parsed);
+                } catch (error) {
+                  const message = error instanceof Error ? error.message : "Invalid JSON.";
+                  setRawJsonError(message);
+                  onChangeRef.current?.(publishedSchema, [
+                    {
+                      message,
+                      source: "json-parse"
+                    }
+                  ]);
+                }
+              }
+            }
+          ),
+          rawJsonError ? /* @__PURE__ */ jsx12("div", { className: "raf-error", children: rawJsonError }) : null
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs8("details", { className: "raf-object", children: [
+        /* @__PURE__ */ jsx12("summary", { className: "raf-object-summary", children: "Preview JSON Schema" }),
+        /* @__PURE__ */ jsx12("div", { className: "raf-object-content", children: /* @__PURE__ */ jsx12("pre", { className: "raf-json-preview", children: prettySchema }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx12(FieldInfoModal, { activeHelp, onClose: closeHelp })
+  ] });
+}
+function SchemaNodeEditor({
+  schema,
+  label,
+  onChange,
+  onRemove,
+  isRoot = false,
+  domain,
+  primaryLeadField,
+  primaryFollowField,
+  showPrimaryTitle = isRoot
+}) {
+  const schemaTypes = getSchemaTypes(schema);
+  const primaryType = schemaTypes.length === 1 ? schemaTypes[0] : void 0;
+  const hasType = (type) => schemaTypes.includes(type);
+  const editableRootId = isRoot ? toLocalId(stringOrEmpty(schema.$id), domain) : stringOrEmpty(schema.$id);
+  const fullRootId = isRoot ? toFullId(editableRootId, domain) : editableRootId;
+  return /* @__PURE__ */ jsxs8("details", { className: "raf-object", open: true, children: [
+    /* @__PURE__ */ jsx12("summary", { className: "raf-object-summary", children: label }),
+    /* @__PURE__ */ jsxs8("div", { className: "raf-object-content", children: [
+      /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+        primaryLeadField,
+        showPrimaryTitle ? /* @__PURE__ */ jsx12(
+          TextInput,
+          {
+            label: "Title",
+            keyword: "title",
+            value: stringOrEmpty(schema.title),
+            onChange: (value) => onChange(assignOptionalString(schema, "title", value))
+          }
+        ) : null,
+        /* @__PURE__ */ jsx12(
+          TypeListEditor,
+          {
+            value: schemaTypes,
+            onChange: (nextTypes) => {
+              const next = applyTypes(schema, nextTypes);
+              delete next.const;
+              delete next.enum;
+              onChange(next);
+            }
+          }
+        ),
+        primaryFollowField
+      ] }),
+      hasType("object") ? /* @__PURE__ */ jsx12(ObjectSchemaEditor, { schema, onChange, showAdvancedOptions: false }) : null,
+      /* @__PURE__ */ jsxs8(BuilderDisclosureSection, { title: "More Details", children: [
+        /* @__PURE__ */ jsxs8(BuilderDisclosureSection, { title: "Documentation & References", defaultOpen: true, children: [
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            !showPrimaryTitle ? /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "Title",
+                keyword: "title",
+                value: stringOrEmpty(schema.title),
+                onChange: (value) => onChange(assignOptionalString(schema, "title", value))
+              }
+            ) : null,
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "$ref",
+                keyword: "$ref",
+                value: stringOrEmpty(schema.$ref),
+                onChange: (value) => onChange(assignOptionalString(schema, "$ref", value))
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "$id",
+                keyword: "$id",
+                value: editableRootId,
+                onChange: (value) => onChange(assignOptionalString(schema, "$id", isRoot ? toLocalId(value, domain) : value)),
+                helperText: isRoot && domain ? `Full $id: ${fullRootId || "(empty)"}` : void 0
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "$schema",
+                keyword: "$schema",
+                value: stringOrEmpty(schema.$schema),
+                onChange: (value) => onChange(assignOptionalString(schema, "$schema", value)),
+                placeholder: DEFAULT_SCHEMA_URI
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx12(
+            TextAreaInput,
+            {
+              label: "Description",
+              keyword: "description",
+              value: stringOrEmpty(schema.description),
+              onChange: (value) => onChange(assignOptionalString(schema, "description", value))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs8(BuilderDisclosureSection, { title: "Meta-data", defaultOpen: true, children: [
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            /* @__PURE__ */ jsx12(
+              KeywordCheckbox,
+              {
+                label: "deprecated",
+                keyword: "deprecated",
+                checked: schema.deprecated === true,
+                onChange: (checked) => {
+                  const next = cloneSchema(schema);
+                  if (checked) {
+                    next.deprecated = true;
+                  } else {
+                    delete next.deprecated;
+                  }
+                  onChange(next);
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              KeywordCheckbox,
+              {
+                label: "readOnly",
+                keyword: "readOnly",
+                checked: schema.readOnly === true,
+                onChange: (checked) => {
+                  const next = cloneSchema(schema);
+                  if (checked) {
+                    next.readOnly = true;
+                  } else {
+                    delete next.readOnly;
+                  }
+                  onChange(next);
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              KeywordCheckbox,
+              {
+                label: "writeOnly",
+                keyword: "writeOnly",
+                checked: schema.writeOnly === true,
+                onChange: (checked) => {
+                  const next = cloneSchema(schema);
+                  if (checked) {
+                    next.writeOnly = true;
+                  } else {
+                    delete next.writeOnly;
+                  }
+                  onChange(next);
+                }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            /* @__PURE__ */ jsx12(
+              JsonTextInput,
+              {
+                label: "Default (JSON)",
+                keyword: "default",
+                value: schema.default,
+                placeholder: 'e.g. "abc", 42, true, {"k":"v"}',
+                onClear: () => {
+                  const next = cloneSchema(schema);
+                  delete next.default;
+                  onChange(next);
+                },
+                onValidJson: (parsed) => {
+                  onChange({ ...schema, default: parsed });
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              JsonTextInput,
+              {
+                label: "examples",
+                keyword: "examples",
+                value: schema.examples,
+                placeholder: 'e.g. ["sample", 1, true]',
+                onClear: () => {
+                  const next = cloneSchema(schema);
+                  delete next.examples;
+                  onChange(next);
+                },
+                onValidJson: (parsed) => {
+                  if (!Array.isArray(parsed)) {
+                    return;
+                  }
+                  onChange({ ...schema, examples: parsed });
+                }
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs8(BuilderDisclosureSection, { title: "Value Rules", defaultOpen: true, children: [
+          /* @__PURE__ */ jsx12(ConstEditor, { schema, schemaTypes, primaryType, onChange }),
+          /* @__PURE__ */ jsx12(EnumEditor, { schema, schemaTypes, primaryType, onChange })
+        ] }),
+        hasType("string") ? /* @__PURE__ */ jsxs8(BuilderDisclosureSection, { title: "String Constraints", defaultOpen: true, children: [
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "minLength",
+                keyword: "minLength",
+                value: numberOrEmpty(schema.minLength),
+                onChange: (value) => onChange(assignOptionalInteger(schema, "minLength", value)),
+                type: "number",
+                step: "1",
+                placeholder: "e.g. 1"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "maxLength",
+                keyword: "maxLength",
+                value: numberOrEmpty(schema.maxLength),
+                onChange: (value) => onChange(assignOptionalInteger(schema, "maxLength", value)),
+                type: "number",
+                step: "1",
+                placeholder: "e.g. 255"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx12(
+            TextInput,
+            {
+              label: "Pattern",
+              keyword: "pattern",
+              value: stringOrEmpty(schema.pattern),
+              onChange: (value) => onChange(assignOptionalString(schema, "pattern", value)),
+              placeholder: "e.g. ^[A-Za-z]+$"
+            }
+          ),
+          /* @__PURE__ */ jsx12(
+            TypeaheadInput,
+            {
+              label: "format",
+              keyword: "format",
+              value: stringOrEmpty(schema.format),
+              onChange: (value) => onChange(assignOptionalString(schema, "format", value)),
+              options: AJV_SUPPORTED_FORMATS,
+              placeholder: "e.g. email"
+            }
+          )
+        ] }) : null,
+        hasType("number") || hasType("integer") ? /* @__PURE__ */ jsxs8(BuilderDisclosureSection, { title: "Number Constraints", defaultOpen: true, children: [
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "Min",
+                keyword: "minimum",
+                value: numberOrEmpty(schema.minimum),
+                onChange: (value) => onChange(assignOptionalNumber(schema, "minimum", value)),
+                type: "number",
+                step: "any",
+                placeholder: "e.g. 0"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "Max",
+                keyword: "maximum",
+                value: numberOrEmpty(schema.maximum),
+                onChange: (value) => onChange(assignOptionalNumber(schema, "maximum", value)),
+                type: "number",
+                step: "any",
+                placeholder: "e.g. 100"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "multipleOf",
+                keyword: "multipleOf",
+                value: numberOrEmpty(schema.multipleOf),
+                onChange: (value) => onChange(assignOptionalPositiveNumber(schema, "multipleOf", value)),
+                type: "number",
+                step: "any",
+                placeholder: "e.g. 0.5"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "exclusiveMinimum",
+                keyword: "exclusiveMinimum",
+                value: numberOrEmpty(schema.exclusiveMinimum),
+                onChange: (value) => onChange(assignOptionalNumber(schema, "exclusiveMinimum", value)),
+                type: "number",
+                step: "any",
+                placeholder: "e.g. 0"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "exclusiveMaximum",
+                keyword: "exclusiveMaximum",
+                value: numberOrEmpty(schema.exclusiveMaximum),
+                onChange: (value) => onChange(assignOptionalNumber(schema, "exclusiveMaximum", value)),
+                type: "number",
+                step: "any",
+                placeholder: "e.g. 100"
+              }
+            )
+          ] })
+        ] }) : null,
+        hasType("array") ? /* @__PURE__ */ jsx12(BuilderDisclosureSection, { title: "Array Rules", defaultOpen: true, children: /* @__PURE__ */ jsx12(ArraySchemaEditor, { schema, onChange }) }) : null,
+        hasType("object") ? /* @__PURE__ */ jsx12(BuilderDisclosureSection, { title: "Object Rules", defaultOpen: true, children: /* @__PURE__ */ jsx12(ObjectSchemaAdvancedEditor, { schema, onChange }) }) : null,
+        /* @__PURE__ */ jsx12(BuilderDisclosureSection, { title: "Composition & Conditionals", defaultOpen: true, children: /* @__PURE__ */ jsxs8("div", { className: "raf-builder-section-group", children: [
+          /* @__PURE__ */ jsx12(CombinationEditor, { kind: "allOf", schema, onChange }),
+          /* @__PURE__ */ jsx12(CombinationEditor, { kind: "anyOf", schema, onChange }),
+          /* @__PURE__ */ jsx12(CombinationEditor, { kind: "oneOf", schema, onChange }),
+          /* @__PURE__ */ jsx12(SingleSchemaEditor, { kind: "not", schema, onChange }),
+          /* @__PURE__ */ jsx12(ConditionalSchemaEditor, { kind: "if", schema, onChange }),
+          /* @__PURE__ */ jsx12(ConditionalSchemaEditor, { kind: "then", schema, onChange }),
+          /* @__PURE__ */ jsx12(ConditionalSchemaEditor, { kind: "else", schema, onChange })
+        ] }) })
+      ] }),
+      !isRoot && onRemove ? /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12("button", { className: "raf-button raf-button-danger", type: "button", onClick: onRemove, children: "Remove Field" }) }) : null
+    ] })
+  ] });
+}
+function BuilderDisclosureSection({
+  title,
+  children,
+  defaultOpen = false
+}) {
+  return /* @__PURE__ */ jsxs8("details", { className: "raf-builder-disclosure", open: defaultOpen, children: [
+    /* @__PURE__ */ jsx12("summary", { className: "raf-builder-disclosure-summary", children: title }),
+    /* @__PURE__ */ jsx12("div", { className: "raf-builder-disclosure-content", children })
+  ] });
+}
+function ObjectSchemaEditor({
+  schema,
+  onChange,
+  showAdvancedOptions = true
+}) {
+  const properties = schema.properties ?? {};
+  const requiredSet = new Set(schema.required ?? []);
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+    /* @__PURE__ */ jsxs8("div", { className: "raf-builder-heading-wrap", children: [
+      /* @__PURE__ */ jsx12("h4", { className: "raf-builder-heading", children: "Properties" }),
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "properties", keyword: "properties" })
+    ] }),
+    Object.entries(properties).map(([propertyName, propertySchema], index) => /* @__PURE__ */ jsx12("div", { className: "raf-builder-property", children: /* @__PURE__ */ jsx12(
+      SchemaNodeEditor,
+      {
+        label: `Property: ${propertyName}`,
+        schema: propertySchema,
+        showPrimaryTitle: false,
+        primaryLeadField: /* @__PURE__ */ jsx12(
+          TextInput,
+          {
+            label: "Property Name",
+            keyword: "properties",
+            value: propertyName,
+            onChange: (nextName) => {
+              const normalized = nextName.trim();
+              if (normalized === propertyName) {
+                return;
+              }
+              if (normalized === "") {
+                const next2 = cloneSchema(schema);
+                const objectProperties2 = { ...next2.properties ?? {} };
+                objectProperties2[""] = objectProperties2[propertyName];
+                if (propertyName !== "") {
+                  delete objectProperties2[propertyName];
+                }
+                next2.properties = objectProperties2;
+                next2.required = (next2.required ?? []).filter((entry) => entry !== propertyName);
+                onChange(next2);
+                return;
+              }
+              const next = cloneSchema(schema);
+              const objectProperties = { ...next.properties ?? {} };
+              if (objectProperties[normalized]) {
+                return;
+              }
+              objectProperties[normalized] = objectProperties[propertyName];
+              delete objectProperties[propertyName];
+              next.properties = objectProperties;
+              const required = new Set(next.required ?? []);
+              if (required.delete(propertyName)) {
+                required.add(normalized);
+                next.required = Array.from(required);
+              }
+              onChange(next);
+            }
+          }
+        ),
+        primaryFollowField: /* @__PURE__ */ jsx12(
+          KeywordCheckbox,
+          {
+            label: "Required",
+            keyword: "required",
+            checked: requiredSet.has(propertyName),
+            onChange: (checked) => {
+              const next = cloneSchema(schema);
+              const required = new Set(next.required ?? []);
+              if (checked) {
+                required.add(propertyName);
+              } else {
+                required.delete(propertyName);
+              }
+              next.required = Array.from(required);
+              onChange(next);
+            }
+          }
+        ),
+        onChange: (nextPropertySchema) => {
+          const next = cloneSchema(schema);
+          next.properties = { ...next.properties ?? {}, [propertyName]: nextPropertySchema };
+          onChange(next);
+        },
+        onRemove: () => {
+          const next = cloneSchema(schema);
+          const objectProperties = { ...next.properties ?? {} };
+          delete objectProperties[propertyName];
+          next.properties = objectProperties;
+          next.required = (next.required ?? []).filter((entry) => entry !== propertyName);
+          onChange(next);
+        }
+      }
+    ) }, index)),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-primary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          next.properties = { ...next.properties ?? {} };
+          const newKey = createUniquePropertyName(next.properties, "field");
+          next.properties[newKey] = { type: "string" };
+          onChange(next);
+        },
+        children: "Add Property"
+      }
+    ) }),
+    showAdvancedOptions ? /* @__PURE__ */ jsx12(ObjectSchemaAdvancedEditor, { schema, onChange }) : null
+  ] });
+}
+function ObjectSchemaAdvancedEditor({ schema, onChange }) {
+  const dependentRequired = schema.dependentRequired ?? {};
+  const dependentSchemas = schema.dependentSchemas ?? {};
+  const patternProperties = schema.patternProperties ?? {};
+  const additionalPropertiesSchema = isObject3(schema.additionalProperties) ? schema.additionalProperties : void 0;
+  const additionalPropertiesMode = additionalPropertiesSchema ? "subschema" : schema.additionalProperties === false ? "false" : "true";
+  const propertyNamesSchema = isObject3(schema.propertyNames) ? schema.propertyNames : void 0;
+  const unevaluatedPropertiesSchema = isObject3(schema.unevaluatedProperties) ? schema.unevaluatedProperties : void 0;
+  return /* @__PURE__ */ jsxs8(Fragment2, { children: [
+    /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+      /* @__PURE__ */ jsx12(
+        TextInput,
+        {
+          label: "minProperties",
+          keyword: "minProperties",
+          value: numberOrEmpty(schema.minProperties),
+          onChange: (value) => onChange(assignOptionalInteger(schema, "minProperties", value)),
+          type: "number",
+          step: "1",
+          placeholder: "e.g. 0"
+        }
+      ),
+      /* @__PURE__ */ jsx12(
+        TextInput,
+        {
+          label: "maxProperties",
+          keyword: "maxProperties",
+          value: numberOrEmpty(schema.maxProperties),
+          onChange: (value) => onChange(assignOptionalInteger(schema, "maxProperties", value)),
+          type: "number",
+          step: "1",
+          placeholder: "e.g. 10"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx12(
+      SelectInput,
+      {
+        label: "additionalProperties",
+        keyword: "additionalProperties",
+        value: additionalPropertiesMode,
+        onChange: (value) => {
+          const next = cloneSchema(schema);
+          if (value === "subschema") {
+            next.additionalProperties = isObject3(next.additionalProperties) ? next.additionalProperties : { type: "string" };
+          } else if (value === "false") {
+            next.additionalProperties = false;
+          } else {
+            next.additionalProperties = true;
+          }
+          onChange(next);
+        },
+        options: [
+          { value: "true", label: "True" },
+          { value: "false", label: "False" },
+          { value: "subschema", label: "Sub-schema" }
+        ]
+      }
+    ),
+    additionalPropertiesSchema ? /* @__PURE__ */ jsx12(
+      SchemaNodeEditor,
+      {
+        label: "additionalProperties",
+        schema: additionalPropertiesSchema,
+        onChange: (nextAdditionalPropertiesSchema) => {
+          const next = cloneSchema(schema);
+          next.additionalProperties = nextAdditionalPropertiesSchema;
+          onChange(next);
+        },
+        onRemove: () => {
+          const next = cloneSchema(schema);
+          next.additionalProperties = true;
+          onChange(next);
+        }
+      }
+    ) : null,
+    /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "unevaluatedProperties", keyword: "unevaluatedProperties", labelType: "heading" }),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: !unevaluatedPropertiesSchema ? /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-secondary",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            next.unevaluatedProperties = { type: "string" };
+            onChange(next);
+          },
+          children: "Add unevaluatedProperties"
+        }
+      ) : /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-danger",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            delete next.unevaluatedProperties;
+            onChange(next);
+          },
+          children: "Clear unevaluatedProperties"
+        }
+      ) }),
+      unevaluatedPropertiesSchema ? /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          label: "unevaluatedProperties",
+          schema: unevaluatedPropertiesSchema,
+          onChange: (nextUnevaluatedPropertiesSchema) => {
+            const next = cloneSchema(schema);
+            next.unevaluatedProperties = nextUnevaluatedPropertiesSchema;
+            onChange(next);
+          },
+          onRemove: () => {
+            const next = cloneSchema(schema);
+            delete next.unevaluatedProperties;
+            onChange(next);
+          }
+        }
+      ) : null
+    ] }),
+    /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "propertyNames", keyword: "propertyNames", labelType: "heading" }),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: !propertyNamesSchema ? /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-secondary",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            next.propertyNames = { type: "string" };
+            onChange(next);
+          },
+          children: "Add propertyNames"
+        }
+      ) : /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-danger",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            delete next.propertyNames;
+            onChange(next);
+          },
+          children: "Clear propertyNames"
+        }
+      ) }),
+      propertyNamesSchema ? /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          label: "propertyNames",
+          schema: propertyNamesSchema,
+          onChange: (nextPropertyNamesSchema) => {
+            const next = cloneSchema(schema);
+            next.propertyNames = nextPropertyNamesSchema;
+            onChange(next);
+          },
+          onRemove: () => {
+            const next = cloneSchema(schema);
+            delete next.propertyNames;
+            onChange(next);
+          }
+        }
+      ) : null
+    ] }),
+    /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "dependentRequired", keyword: "dependentRequired", labelType: "heading" }),
+      Object.entries(dependentRequired).map(([propertyName, dependencies], index) => {
+        const serializedDependencies = Array.isArray(dependencies) ? dependencies.join(", ") : "";
+        return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-property", children: [
+          /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "Dependent Property",
+                keyword: "dependentRequired",
+                value: propertyName,
+                onChange: (nextName) => {
+                  const normalized = nextName.trim();
+                  if (normalized === propertyName) {
+                    return;
+                  }
+                  const next = cloneSchema(schema);
+                  const nextEntries = { ...next.dependentRequired ?? {} };
+                  const existingValue = nextEntries[propertyName] ?? [];
+                  if (normalized === "") {
+                    delete nextEntries[propertyName];
+                    next.dependentRequired = nextEntries;
+                    onChange(next);
+                    return;
+                  }
+                  if (Object.prototype.hasOwnProperty.call(nextEntries, normalized)) {
+                    return;
+                  }
+                  nextEntries[normalized] = Array.isArray(existingValue) ? existingValue : [];
+                  delete nextEntries[propertyName];
+                  next.dependentRequired = nextEntries;
+                  onChange(next);
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              TextInput,
+              {
+                label: "Required Properties (comma-separated)",
+                keyword: "dependentRequired",
+                value: serializedDependencies,
+                onChange: (nextValue) => {
+                  const next = cloneSchema(schema);
+                  const nextEntries = { ...next.dependentRequired ?? {} };
+                  nextEntries[propertyName] = parseCommaSeparatedStrings(nextValue);
+                  next.dependentRequired = nextEntries;
+                  onChange(next);
+                }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+            "button",
+            {
+              className: "raf-button raf-button-danger",
+              type: "button",
+              onClick: () => {
+                const next = cloneSchema(schema);
+                const nextEntries = { ...next.dependentRequired ?? {} };
+                delete nextEntries[propertyName];
+                next.dependentRequired = nextEntries;
+                onChange(next);
+              },
+              children: "Remove dependentRequired Entry"
+            }
+          ) })
+        ] }, `dependent-required-${index}`);
+      }),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-secondary",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            const nextEntries = { ...next.dependentRequired ?? {} };
+            const newKey = createUniqueEntryName(nextEntries, "field");
+            nextEntries[newKey] = [];
+            next.dependentRequired = nextEntries;
+            onChange(next);
+          },
+          children: "Add dependentRequired Entry"
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx12(
+      SchemaMapEditor,
+      {
+        title: "dependentSchemas",
+        addButtonLabel: "Add dependentSchemas Entry",
+        removeButtonLabel: "Remove dependentSchemas Entry",
+        schemaMap: dependentSchemas,
+        defaultSchemaFactory: () => ({ type: "object", properties: {} }),
+        onChange: (nextMap) => {
+          const next = cloneSchema(schema);
+          next.dependentSchemas = nextMap;
+          onChange(next);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx12(
+      SchemaMapEditor,
+      {
+        title: "patternProperties",
+        addButtonLabel: "Add patternProperties Entry",
+        removeButtonLabel: "Remove patternProperties Entry",
+        schemaMap: patternProperties,
+        defaultSchemaFactory: () => ({ type: "string" }),
+        onChange: (nextMap) => {
+          const next = cloneSchema(schema);
+          next.patternProperties = nextMap;
+          onChange(next);
+        }
+      }
+    )
+  ] });
+}
+function ArraySchemaEditor({ schema, onChange }) {
+  const tupleItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : void 0;
+  const items = !Array.isArray(schema.items) && isObject3(schema.items) ? schema.items : void 0;
+  const hasContains = isObject3(schema.contains);
+  const unevaluatedItemsSchema = isObject3(schema.unevaluatedItems) ? schema.unevaluatedItems : void 0;
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+    tupleItems ? /* @__PURE__ */ jsxs8(Fragment2, { children: [
+      /* @__PURE__ */ jsx12("h4", { className: "raf-builder-heading", children: "Array Items (Tuple)" }),
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "prefixItems", keyword: "prefixItems" }),
+      tupleItems.map((itemSchema, index) => /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          label: `Tuple Item ${index + 1}`,
+          schema: itemSchema,
+          onChange: (nextItemSchema) => {
+            const next = cloneSchema(schema);
+            const nextItems = Array.isArray(next.prefixItems) ? [...next.prefixItems] : Array.isArray(next.items) ? [...next.items] : [];
+            nextItems[index] = nextItemSchema;
+            next.prefixItems = nextItems;
+            next.items = false;
+            onChange(next);
+          },
+          onRemove: () => {
+            const next = cloneSchema(schema);
+            const nextItems = Array.isArray(next.prefixItems) ? [...next.prefixItems] : Array.isArray(next.items) ? [...next.items] : [];
+            nextItems.splice(index, 1);
+            next.prefixItems = nextItems;
+            next.items = false;
+            onChange(next);
+          }
+        },
+        `tuple-item-${index}`
+      )),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-primary",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            const nextItems = Array.isArray(next.prefixItems) ? [...next.prefixItems] : Array.isArray(next.items) ? [...next.items] : [];
+            nextItems.push({ type: "string" });
+            next.prefixItems = nextItems;
+            next.items = false;
+            onChange(next);
+          },
+          children: "Add Tuple Item Schema"
+        }
+      ) }),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-secondary",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            next.items = { type: "string" };
+            delete next.prefixItems;
+            onChange(next);
+          },
+          children: "Switch To Single Items Schema"
+        }
+      ) })
+    ] }) : /* @__PURE__ */ jsxs8(Fragment2, { children: [
+      /* @__PURE__ */ jsx12("h4", { className: "raf-builder-heading", children: "Array Items" }),
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "items", keyword: "items" }),
+      /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          label: "Items Schema",
+          schema: isObject3(items) ? items : { type: "string" },
+          onChange: (nextItemsSchema) => {
+            const next = cloneSchema(schema);
+            next.items = nextItemsSchema;
+            delete next.prefixItems;
+            onChange(next);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-secondary",
+          type: "button",
+          onClick: () => {
+            const next = cloneSchema(schema);
+            next.prefixItems = [{ type: "string" }];
+            next.items = false;
+            onChange(next);
+          },
+          children: "Switch To Tuple Items"
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx12("h4", { className: "raf-builder-heading", children: "Array Constraints" }),
+    /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+      /* @__PURE__ */ jsx12(
+        TextInput,
+        {
+          label: "minItems",
+          keyword: "minItems",
+          value: numberOrEmpty(schema.minItems),
+          onChange: (value) => onChange(assignOptionalInteger(schema, "minItems", value)),
+          type: "number",
+          step: "1",
+          placeholder: "e.g. 0"
+        }
+      ),
+      /* @__PURE__ */ jsx12(
+        TextInput,
+        {
+          label: "maxItems",
+          keyword: "maxItems",
+          value: numberOrEmpty(schema.maxItems),
+          onChange: (value) => onChange(assignOptionalInteger(schema, "maxItems", value)),
+          type: "number",
+          step: "1",
+          placeholder: "e.g. 10"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx12(
+      KeywordCheckbox,
+      {
+        label: "uniqueItems",
+        keyword: "uniqueItems",
+        checked: Boolean(schema.uniqueItems),
+        onChange: (checked) => {
+          const next = cloneSchema(schema);
+          if (checked) {
+            next.uniqueItems = true;
+          } else {
+            delete next.uniqueItems;
+          }
+          onChange(next);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: !hasContains ? /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          next.contains = { type: "string" };
+          onChange(next);
+        },
+        children: "Add contains"
+      }
+    ) : /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-danger",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          delete next.contains;
+          delete next.minContains;
+          delete next.maxContains;
+          onChange(next);
+        },
+        children: "Remove contains"
+      }
+    ) }),
+    hasContains ? /* @__PURE__ */ jsxs8(Fragment2, { children: [
+      /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          label: "contains",
+          schema: schema.contains,
+          onChange: (nextContainsSchema) => {
+            const next = cloneSchema(schema);
+            next.contains = nextContainsSchema;
+            onChange(next);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs8("div", { className: "raf-builder-grid", children: [
+        /* @__PURE__ */ jsx12(
+          TextInput,
+          {
+            label: "minContains",
+            keyword: "minContains",
+            value: numberOrEmpty(schema.minContains),
+            onChange: (value) => onChange(assignOptionalInteger(schema, "minContains", value)),
+            type: "number",
+            step: "1",
+            placeholder: "e.g. 1"
+          }
+        ),
+        /* @__PURE__ */ jsx12(
+          TextInput,
+          {
+            label: "maxContains",
+            keyword: "maxContains",
+            value: numberOrEmpty(schema.maxContains),
+            onChange: (value) => onChange(assignOptionalInteger(schema, "maxContains", value)),
+            type: "number",
+            step: "1",
+            placeholder: "e.g. 3"
+          }
+        )
+      ] })
+    ] }) : null,
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: !unevaluatedItemsSchema ? /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          next.unevaluatedItems = { type: "string" };
+          onChange(next);
+        },
+        children: "Add unevaluatedItems"
+      }
+    ) : /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-danger",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          delete next.unevaluatedItems;
+          onChange(next);
+        },
+        children: "Clear unevaluatedItems"
+      }
+    ) }),
+    unevaluatedItemsSchema ? /* @__PURE__ */ jsx12(
+      SchemaNodeEditor,
+      {
+        label: "unevaluatedItems",
+        schema: unevaluatedItemsSchema,
+        onChange: (nextUnevaluatedItemsSchema) => {
+          const next = cloneSchema(schema);
+          next.unevaluatedItems = nextUnevaluatedItemsSchema;
+          onChange(next);
+        },
+        onRemove: () => {
+          const next = cloneSchema(schema);
+          delete next.unevaluatedItems;
+          onChange(next);
+        }
+      }
+    ) : null
+  ] });
+}
+function CombinationEditor({
+  kind,
+  schema,
+  onChange
+}) {
+  const entries = Array.isArray(schema[kind]) ? schema[kind] : [];
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label: kind, keyword: kind, labelType: "heading" }),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: entries.length > 0 ? /* @__PURE__ */ jsxs8(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          delete next[kind];
+          onChange(next);
+        },
+        children: [
+          "Clear ",
+          kind
+        ]
+      }
+    ) : null }),
+    entries.map((entrySchema, index) => /* @__PURE__ */ jsx12(
+      SchemaNodeEditor,
+      {
+        label: `${kind}[${index}]`,
+        schema: entrySchema,
+        onChange: (nextEntrySchema) => {
+          const next = cloneSchema(schema);
+          const currentEntries = Array.isArray(next[kind]) ? next[kind] : [];
+          currentEntries[index] = nextEntrySchema;
+          next[kind] = currentEntries;
+          onChange(next);
+        },
+        onRemove: () => {
+          const next = cloneSchema(schema);
+          const currentEntries = Array.isArray(next[kind]) ? next[kind] : [];
+          currentEntries.splice(index, 1);
+          next[kind] = currentEntries;
+          onChange(next);
+        }
+      },
+      `${kind}-${index}`
+    )),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsxs8(
+      "button",
+      {
+        className: "raf-button raf-button-primary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          const currentEntries = Array.isArray(next[kind]) ? next[kind] : [];
+          next[kind] = [...currentEntries, { type: "string" }];
+          onChange(next);
+        },
+        children: [
+          "Add ",
+          kind,
+          " Entry"
+        ]
+      }
+    ) })
+  ] });
+}
+function ConditionalSchemaEditor({
+  kind,
+  schema,
+  onChange
+}) {
+  const entry = isObject3(schema[kind]) ? schema[kind] : void 0;
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label: kind, keyword: kind, labelType: "heading" }),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: !entry ? /* @__PURE__ */ jsxs8(
+      "button",
+      {
+        className: "raf-button raf-button-primary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          next[kind] = { type: "string" };
+          onChange(next);
+        },
+        children: [
+          "Add ",
+          kind
+        ]
+      }
+    ) : /* @__PURE__ */ jsxs8(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          delete next[kind];
+          onChange(next);
+        },
+        children: [
+          "Clear ",
+          kind
+        ]
+      }
+    ) }),
+    entry ? /* @__PURE__ */ jsx12(
+      SchemaNodeEditor,
+      {
+        label: kind,
+        schema: entry,
+        onChange: (nextEntrySchema) => {
+          const next = cloneSchema(schema);
+          next[kind] = nextEntrySchema;
+          onChange(next);
+        },
+        onRemove: () => {
+          const next = cloneSchema(schema);
+          delete next[kind];
+          onChange(next);
+        }
+      }
+    ) : null
+  ] });
+}
+function SingleSchemaEditor({
+  kind,
+  schema,
+  onChange
+}) {
+  const entry = isObject3(schema[kind]) ? schema[kind] : void 0;
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label: kind, keyword: kind, labelType: "heading" }),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: !entry ? /* @__PURE__ */ jsxs8(
+      "button",
+      {
+        className: "raf-button raf-button-primary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          next[kind] = { type: "string" };
+          onChange(next);
+        },
+        children: [
+          "Add ",
+          kind
+        ]
+      }
+    ) : /* @__PURE__ */ jsxs8(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        onClick: () => {
+          const next = cloneSchema(schema);
+          delete next[kind];
+          onChange(next);
+        },
+        children: [
+          "Clear ",
+          kind
+        ]
+      }
+    ) }),
+    entry ? /* @__PURE__ */ jsx12(
+      SchemaNodeEditor,
+      {
+        label: kind,
+        schema: entry,
+        onChange: (nextEntrySchema) => {
+          const next = cloneSchema(schema);
+          next[kind] = nextEntrySchema;
+          onChange(next);
+        },
+        onRemove: () => {
+          const next = cloneSchema(schema);
+          delete next[kind];
+          onChange(next);
+        }
+      }
+    ) : null
+  ] });
+}
+function SchemaMapEditor({
+  title,
+  addButtonLabel,
+  removeButtonLabel,
+  schemaMap,
+  defaultSchemaFactory,
+  onChange
+}) {
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-builder-block", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label: title, keyword: title, labelType: "heading" }),
+    Object.entries(schemaMap).map(([entryName, entrySchema], index) => /* @__PURE__ */ jsxs8("div", { className: "raf-builder-property", children: [
+      /* @__PURE__ */ jsx12("div", { className: "raf-builder-grid", children: /* @__PURE__ */ jsx12(
+        TextInput,
+        {
+          label: `${title} Key`,
+          keyword: title,
+          value: entryName,
+          onChange: (nextName) => {
+            const normalized = nextName.trim();
+            if (normalized === entryName || normalized === "") {
+              return;
+            }
+            const nextMap = { ...schemaMap };
+            if (Object.prototype.hasOwnProperty.call(nextMap, normalized)) {
+              return;
+            }
+            nextMap[normalized] = nextMap[entryName];
+            delete nextMap[entryName];
+            onChange(nextMap);
+          }
+        }
+      ) }),
+      /* @__PURE__ */ jsx12(
+        SchemaNodeEditor,
+        {
+          label: `${title}[${entryName}]`,
+          schema: entrySchema,
+          onChange: (nextEntrySchema) => {
+            const nextMap = { ...schemaMap, [entryName]: nextEntrySchema };
+            onChange(nextMap);
+          },
+          onRemove: () => {
+            const nextMap = { ...schemaMap };
+            delete nextMap[entryName];
+            onChange(nextMap);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-danger",
+          type: "button",
+          onClick: () => {
+            const nextMap = { ...schemaMap };
+            delete nextMap[entryName];
+            onChange(nextMap);
+          },
+          children: removeButtonLabel
+        }
+      ) })
+    ] }, `${title}-${index}`)),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row", children: /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        onClick: () => {
+          const nextMap = { ...schemaMap };
+          const newKey = createUniqueEntryName(nextMap, "field");
+          nextMap[newKey] = defaultSchemaFactory();
+          onChange(nextMap);
+        },
+        children: addButtonLabel
+      }
+    ) })
+  ] });
+}
+function TypeListEditor({
+  value,
+  onChange
+}) {
+  const availableTypes = FIELD_TYPES.filter((type) => !value.includes(type));
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-field", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label: "Types", keyword: "type" }),
+    value.map((type, index) => /* @__PURE__ */ jsxs8("div", { className: "raf-button-row raf-type-list-row", children: [
+      /* @__PURE__ */ jsx12(
+        "select",
+        {
+          className: "raf-select raf-builder-control",
+          "aria-label": `Type ${index + 1}`,
+          value: type,
+          onChange: (event) => {
+            const nextType = event.target.value;
+            if (nextType === type || value.includes(nextType)) {
+              return;
+            }
+            const nextTypes = [...value];
+            nextTypes[index] = nextType;
+            onChange(nextTypes);
+          },
+          children: FIELD_TYPES.map((optionType) => /* @__PURE__ */ jsx12("option", { value: optionType, children: optionType }, optionType))
+        }
+      ),
+      value.length > 1 ? /* @__PURE__ */ jsx12(
+        "button",
+        {
+          className: "raf-button raf-button-danger",
+          type: "button",
+          onClick: () => {
+            const nextTypes = value.filter((_, currentIndex) => currentIndex !== index);
+            onChange(nextTypes);
+          },
+          children: "Remove"
+        }
+      ) : null
+    ] }, `type-${index}`)),
+    /* @__PURE__ */ jsx12("div", { className: "raf-button-row raf-type-list-add-row", children: /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-button raf-button-secondary",
+        type: "button",
+        disabled: availableTypes.length === 0,
+        onClick: () => {
+          if (availableTypes.length === 0) {
+            return;
+          }
+          onChange([...value, availableTypes[0]]);
+        },
+        children: "Add Type"
+      }
+    ) })
+  ] });
+}
+function useFieldHelp() {
+  return useContext(FieldHelpContext);
+}
+function FieldLabel({
+  label,
+  keyword,
+  labelType = "standard"
+}) {
+  const fieldHelp = useFieldHelp();
+  const helpKey = keyword ?? label;
+  const help = resolveHelpDefinition(helpKey);
+  return /* @__PURE__ */ jsxs8(Fragment2, { children: [
+    /* @__PURE__ */ jsxs8("div", { className: "raf-field-label-row", children: [
+      labelType === "heading" ? /* @__PURE__ */ jsx12("h4", { className: "raf-builder-heading", children: label }) : /* @__PURE__ */ jsx12("span", { className: "raf-field-label", children: label }),
+      /* @__PURE__ */ jsxs8(
+        "button",
+        {
+          className: "raf-info-button",
+          type: "button",
+          "aria-label": `Info about ${label}`,
+          onClick: (event) => {
+            const rect = event.currentTarget.getBoundingClientRect();
+            fieldHelp?.openHelp(helpKey, label, {
+              top: rect.top,
+              left: rect.left,
+              bottom: rect.bottom,
+              right: rect.right
+            });
+          },
+          children: [
+            /* @__PURE__ */ jsx12("span", { className: "raf-info-icon", "aria-hidden": "true", children: "i" }),
+            /* @__PURE__ */ jsx12("span", { className: "raf-sr-only", children: "Info" })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx12("div", { className: "raf-field-summary", children: help.summary })
+  ] });
+}
+function KeywordCheckbox({
+  label,
+  keyword,
+  checked,
+  onChange
+}) {
+  return /* @__PURE__ */ jsxs8("div", { className: "raf-field", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label, keyword }),
+    /* @__PURE__ */ jsxs8("label", { className: "raf-checkbox-row", children: [
+      /* @__PURE__ */ jsx12(
+        "input",
+        {
+          className: "raf-checkbox",
+          type: "checkbox",
+          checked,
+          onChange: (event) => onChange(event.target.checked)
+        }
+      ),
+      /* @__PURE__ */ jsx12("span", { children: label })
+    ] })
+  ] });
+}
+function FieldInfoModal({
+  activeHelp,
+  onClose
+}) {
+  const modalRef = useRef3(null);
+  const [desktopPosition, setDesktopPosition] = useState3(null);
+  const [isMobile, setIsMobile] = useState3(false);
+  useLayoutEffect(() => {
+    if (!activeHelp) {
+      return;
+    }
+    const updatePosition = () => {
+      const mobile = window.innerWidth <= 760;
+      setIsMobile(mobile);
+      if (mobile) {
+        setDesktopPosition(null);
+        return;
+      }
+      const modalMaxWidth = Math.min(480, window.innerWidth - 24);
+      const modalMaxHeight = Math.floor(window.innerHeight * 0.38);
+      const desiredLeft = activeHelp.anchor.left;
+      const desiredTop = activeHelp.anchor.bottom + 8;
+      const left = Math.max(12, Math.min(desiredLeft, window.innerWidth - modalMaxWidth - 12));
+      const top = Math.max(12, Math.min(desiredTop, window.innerHeight - modalMaxHeight - 12));
+      setDesktopPosition({ top, left });
+    };
+    updatePosition();
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, [activeHelp]);
+  useEffect3(() => {
+    if (!activeHelp) {
+      return;
+    }
+    const closeIfOutside = (event) => {
+      const target = event.target;
+      if (!target || !(target instanceof Node)) {
+        return;
+      }
+      if (modalRef.current?.contains(target)) {
+        return;
+      }
+      onClose();
+    };
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        onClose();
+      }
+    };
+    document.addEventListener("mousedown", closeIfOutside, true);
+    document.addEventListener("touchstart", closeIfOutside, true);
+    document.addEventListener("wheel", closeIfOutside, true);
+    document.addEventListener("scroll", closeIfOutside, true);
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("mousedown", closeIfOutside, true);
+      document.removeEventListener("touchstart", closeIfOutside, true);
+      document.removeEventListener("wheel", closeIfOutside, true);
+      document.removeEventListener("scroll", closeIfOutside, true);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [activeHelp, onClose]);
+  if (!activeHelp) {
+    return null;
+  }
+  const help = resolveHelpDefinition(activeHelp.key);
+  return /* @__PURE__ */ jsx12("div", { className: "raf-info-layer", role: "presentation", onMouseDown: onClose, children: /* @__PURE__ */ jsxs8(
+    "div",
+    {
+      ref: modalRef,
+      className: `raf-info-modal${isMobile ? " raf-info-modal-mobile" : ""}`,
+      style: !isMobile && desktopPosition ? { top: `${desktopPosition.top}px`, left: `${desktopPosition.left}px` } : void 0,
+      role: "dialog",
+      "aria-modal": "false",
+      "aria-label": `${activeHelp.label} information`,
+      onMouseDown: (event) => event.stopPropagation(),
+      children: [
+        /* @__PURE__ */ jsxs8("div", { className: "raf-info-modal-header", children: [
+          /* @__PURE__ */ jsx12("strong", { children: activeHelp.label }),
+          /* @__PURE__ */ jsx12("button", { className: "raf-button raf-button-secondary", type: "button", onClick: onClose, children: "Close" })
+        ] }),
+        /* @__PURE__ */ jsxs8("div", { className: "raf-info-modal-body", children: [
+          /* @__PURE__ */ jsxs8("a", { className: "raf-info-link", href: help.link, target: "_blank", rel: "noreferrer", children: [
+            "View ",
+            activeHelp.label,
+            " in JSON Schema 2020-12"
+          ] }),
+          /* @__PURE__ */ jsx12("p", { children: parse(help.details) }),
+          /* @__PURE__ */ jsx12("p", { children: parse(help.longDetails) })
+        ] })
+      ]
+    }
+  ) });
+}
+function TextInput({
+  label,
+  keyword,
+  value,
+  onChange,
+  placeholder,
+  helperText,
+  type = "text",
+  step
+}) {
+  return /* @__PURE__ */ jsxs8("label", { className: "raf-field", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label, keyword }),
+    /* @__PURE__ */ jsx12(
+      "input",
+      {
+        className: "raf-input raf-builder-control",
+        type,
+        "aria-label": label,
+        value,
+        placeholder,
+        step,
+        onChange: (event) => onChange(event.target.value)
+      }
+    ),
+    helperText ? /* @__PURE__ */ jsx12("div", { className: "raf-muted", children: helperText }) : null
+  ] });
+}
+function SelectInput({
+  label,
+  keyword,
+  value,
+  onChange,
+  options
+}) {
+  return /* @__PURE__ */ jsxs8("label", { className: "raf-field", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label, keyword }),
+    /* @__PURE__ */ jsx12("select", { className: "raf-select raf-builder-control", "aria-label": label, value, onChange: (event) => onChange(event.target.value), children: options.map((option) => /* @__PURE__ */ jsx12("option", { value: option.value, children: option.label }, option.value)) })
+  ] });
+}
+function TypeaheadInput({
+  label,
+  keyword,
+  value,
+  onChange,
+  options,
+  placeholder
+}) {
+  const [isOpen, setIsOpen] = useState3(false);
+  const containerRef = useRef3(null);
+  const normalizedValue = value.trim().toLowerCase();
+  const filteredOptions = options.filter(
+    (option) => normalizedValue === "" ? true : option.toLowerCase().startsWith(normalizedValue)
+  );
+  useEffect3(() => {
+    if (!isOpen) {
+      return;
+    }
+    const handlePointerDown = (event) => {
+      if (!containerRef.current?.contains(event.target)) {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handlePointerDown);
+    return () => document.removeEventListener("mousedown", handlePointerDown);
+  }, [isOpen]);
+  return /* @__PURE__ */ jsxs8("label", { className: "raf-field raf-typeahead", ref: containerRef, children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label, keyword }),
+    /* @__PURE__ */ jsx12(
+      "input",
+      {
+        className: "raf-input raf-builder-control",
+        type: "text",
+        "aria-label": label,
+        value,
+        placeholder,
+        onFocus: () => setIsOpen(true),
+        onClick: () => setIsOpen(true),
+        onChange: (event) => {
+          setIsOpen(true);
+          onChange(event.target.value);
+        }
+      }
+    ),
+    isOpen && filteredOptions.length > 0 ? /* @__PURE__ */ jsx12("div", { className: "raf-typeahead-menu", role: "listbox", "aria-label": `${label} options`, children: filteredOptions.map((option) => /* @__PURE__ */ jsx12(
+      "button",
+      {
+        className: "raf-typeahead-option",
+        type: "button",
+        role: "option",
+        "aria-selected": value === option,
+        onMouseDown: (event) => {
+          event.preventDefault();
+          onChange(option);
+          setIsOpen(false);
+        },
+        children: option
+      },
+      option
+    )) }) : null
+  ] });
+}
+function TextAreaInput({
+  label,
+  keyword,
+  value,
+  onChange
+}) {
+  return /* @__PURE__ */ jsxs8("label", { className: "raf-field", children: [
+    /* @__PURE__ */ jsx12(FieldLabel, { label, keyword }),
+    /* @__PURE__ */ jsx12(
+      "textarea",
+      {
+        className: "raf-textarea raf-builder-control",
+        "aria-label": label,
+        value,
+        onChange: (event) => onChange(event.target.value)
+      }
+    )
+  ] });
+}
+function JsonTextInput({
+  label,
+  keyword,
+  value,
+  onValidJson,
+  onClear,
+  onInvalidJsonText,
+  stringValueDisplay = "json",
+  placeholder
+}) {
+  const serializedValue = value === void 0 ? "" : stringValueDisplay === "raw" && typeof value === "string" ? value : toInlineJson(value);
+  const [draftValue, setDraftValue] = useState3(serializedValue);
+  useEffect3(() => {
+    setDraftValue(serializedValue);
+  }, [serializedValue]);
+  return /* @__PURE__ */ jsx12(
+    TextInput,
+    {
+      label,
+      keyword,
+      value: draftValue,
+      onChange: (nextText) => {
+        setDraftValue(nextText);
+        if (nextText.trim() === "") {
+          onClear();
+          return;
+        }
+        try {
+          const parsed = JSON.parse(nextText);
+          onValidJson(parsed);
+        } catch {
+          onInvalidJsonText?.(nextText);
+        }
+      },
+      placeholder
+    }
+  );
+}
+function ConstEditor({
+  schema,
+  schemaTypes,
+  primaryType,
+  onChange
+}) {
+  if (primaryType === "null" && schemaTypes.length === 1) {
+    return null;
+  }
+  const enumValues = Array.isArray(schema.enum) ? schema.enum : void 0;
+  if (enumValues && enumValues.length > 0) {
+    const selectedIndex = enumValues.findIndex((entry) => deepEqual(entry, schema.const));
+    return /* @__PURE__ */ jsxs8("label", { className: "raf-field", children: [
+      /* @__PURE__ */ jsx12(FieldLabel, { label: "Const", keyword: "const" }),
+      /* @__PURE__ */ jsxs8(
+        "select",
+        {
+          className: "raf-select raf-builder-control",
+          "aria-label": "Const",
+          value: selectedIndex >= 0 ? String(selectedIndex) : "",
+          onChange: (event) => {
+            const indexValue = event.target.value;
+            const next = cloneSchema(schema);
+            if (indexValue === "") {
+              delete next.const;
+              onChange(next);
+              return;
+            }
+            const index = Number(indexValue);
+            if (!Number.isInteger(index) || index < 0 || index >= enumValues.length) {
+              return;
+            }
+            next.const = cloneSchema(enumValues[index]);
+            onChange(next);
+          },
+          children: [
+            /* @__PURE__ */ jsx12("option", { value: "", children: "None" }),
+            enumValues.map((option, index) => /* @__PURE__ */ jsx12("option", { value: String(index), children: String(option) }, `${index}-${String(option)}`))
+          ]
+        }
+      )
+    ] });
+  }
+  if (primaryType === "boolean") {
+    return /* @__PURE__ */ jsx12(
+      KeywordCheckbox,
+      {
+        label: "Const",
+        keyword: "const",
+        checked: schema.const === true,
+        onChange: (checked) => {
+          const next = cloneSchema(schema);
+          next.const = checked;
+          onChange(next);
+        }
+      }
+    );
+  }
+  if (primaryType === "number" || primaryType === "integer") {
+    return /* @__PURE__ */ jsx12(
+      TextInput,
+      {
+        label: "Const",
+        keyword: "const",
+        type: "number",
+        step: primaryType === "integer" ? "1" : "any",
+        value: typeof schema.const === "number" ? String(schema.const) : "",
+        placeholder: primaryType === "integer" ? "e.g. 3" : "e.g. 3.14",
+        onChange: (value) => {
+          const next = cloneSchema(schema);
+          if (value.trim() === "") {
+            delete next.const;
+            onChange(next);
+            return;
+          }
+          const parsed = Number(value);
+          if (!Number.isFinite(parsed)) {
+            return;
+          }
+          if (primaryType === "integer" && !Number.isInteger(parsed)) {
+            return;
+          }
+          next.const = parsed;
+          onChange(next);
+        }
+      }
+    );
+  }
+  if (primaryType === "string") {
+    return /* @__PURE__ */ jsx12(
+      TextInput,
+      {
+        label: "Const",
+        keyword: "const",
+        type: "text",
+        value: typeof schema.const === "string" ? schema.const : "",
+        placeholder: "e.g. fixed-value",
+        onChange: (value) => {
+          const next = cloneSchema(schema);
+          if (value === "") {
+            delete next.const;
+          } else {
+            next.const = value;
+          }
+          onChange(next);
+        }
+      }
+    );
+  }
+  if (!primaryType) {
+    return /* @__PURE__ */ jsx12(
+      JsonTextInput,
+      {
+        label: "Const",
+        keyword: "const",
+        value: schema.const,
+        stringValueDisplay: "raw",
+        placeholder: "e.g. A, 2, true, null",
+        onClear: () => {
+          const next = cloneSchema(schema);
+          delete next.const;
+          onChange(next);
+        },
+        onValidJson: (parsed) => {
+          if (!matchesAnySchemaType(parsed, schemaTypes)) {
+            return;
+          }
+          onChange({ ...schema, const: parsed });
+        },
+        onInvalidJsonText: (rawText) => {
+          const parsed = parseLooseScalarByTypes(rawText, schemaTypes);
+          if (parsed === void 0) {
+            return;
+          }
+          onChange({ ...schema, const: parsed });
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx12(
+    JsonTextInput,
+    {
+      label: "Const (JSON)",
+      keyword: "const",
+      value: schema.const,
+      placeholder: 'e.g. "fixed-value", 3, true, null, {"k":"v"}',
+      onClear: () => {
+        const next = cloneSchema(schema);
+        delete next.const;
+        onChange(next);
+      },
+      onValidJson: (parsed) => {
+        onChange({ ...schema, const: parsed });
+      }
+    }
+  );
+}
+function EnumEditor({
+  schema,
+  schemaTypes,
+  primaryType,
+  onChange
+}) {
+  if (primaryType === "boolean" || primaryType === "null") {
+    return null;
+  }
+  if (primaryType === "string") {
+    return /* @__PURE__ */ jsx12(
+      StringEnumInput,
+      {
+        value: Array.isArray(schema.enum) ? schema.enum : void 0,
+        onChange: (nextEnum) => {
+          const next = cloneSchema(schema);
+          delete next.const;
+          if (!nextEnum || nextEnum.length === 0) {
+            delete next.enum;
+          } else {
+            next.enum = nextEnum;
+          }
+          onChange(next);
+        }
+      }
+    );
+  }
+  if (primaryType === "number" || primaryType === "integer") {
+    return /* @__PURE__ */ jsx12(
+      NumberEnumInput,
+      {
+        value: Array.isArray(schema.enum) ? schema.enum : void 0,
+        integerOnly: primaryType === "integer",
+        onChange: (nextEnum) => {
+          const next = cloneSchema(schema);
+          delete next.const;
+          if (!nextEnum || nextEnum.length === 0) {
+            delete next.enum;
+          } else {
+            next.enum = nextEnum;
+          }
+          onChange(next);
+        }
+      }
+    );
+  }
+  if (!primaryType && schemaTypes.length > 1) {
+    return /* @__PURE__ */ jsx12(
+      StringEnumInput,
+      {
+        value: Array.isArray(schema.enum) ? schema.enum : void 0,
+        parseEntry: (entry) => parseLooseScalarByTypes(entry, schemaTypes),
+        onChange: (nextEnum) => {
+          const next = cloneSchema(schema);
+          delete next.const;
+          if (!nextEnum || nextEnum.length === 0) {
+            delete next.enum;
+          } else {
+            next.enum = nextEnum;
+          }
+          onChange(next);
+        }
+      }
+    );
+  }
+  return null;
+}
+function NumberEnumInput({
+  value,
+  integerOnly,
+  onChange
+}) {
+  const serializedValue = Array.isArray(value) ? JSON.stringify(value) : "";
+  const [draftValue, setDraftValue] = useState3(serializedValue);
+  const lastSubmittedSignatureRef = useRef3(null);
+  useEffect3(() => {
+    const nextSignature = Array.isArray(value) ? JSON.stringify(value) : "";
+    if (lastSubmittedSignatureRef.current === nextSignature) {
+      return;
+    }
+    setDraftValue(serializedValue);
+  }, [serializedValue, value]);
+  return /* @__PURE__ */ jsx12(
+    TextInput,
+    {
+      label: "Enum",
+      keyword: "enum",
+      value: draftValue,
+      placeholder: integerOnly ? "e.g. [1, 2, 3]" : "e.g. [1, 2.5, 3]",
+      onChange: (nextText) => {
+        if (!/^[\[\]\d,\.\-+\seE]*$/.test(nextText)) {
+          return;
+        }
+        setDraftValue(nextText);
+        if (nextText.trim() === "") {
+          lastSubmittedSignatureRef.current = "";
+          onChange(void 0);
+          return;
+        }
+        const parsed = parseNumberEnum(nextText, integerOnly);
+        if (!parsed) {
+          return;
+        }
+        lastSubmittedSignatureRef.current = JSON.stringify(parsed);
+        onChange(parsed);
+      }
+    }
+  );
+}
+function parseNumberEnum(input, integerOnly) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const hasWrappedBrackets = trimmed.startsWith("[") && trimmed.endsWith("]");
+  const core = hasWrappedBrackets ? trimmed.slice(1, -1) : trimmed;
+  if (core.trim() === "") {
+    return [];
+  }
+  const segments = core.split(",").map((entry) => entry.trim());
+  if (segments.some((entry) => entry === "")) {
+    return null;
+  }
+  const parsedValues = [];
+  for (const segment of segments) {
+    const parsed = Number(segment);
+    if (!Number.isFinite(parsed)) {
+      return null;
+    }
+    if (integerOnly && !Number.isInteger(parsed)) {
+      return null;
+    }
+    parsedValues.push(parsed);
+  }
+  return parsedValues;
+}
+function StringEnumInput({
+  value,
+  parseEntry,
+  onChange
+}) {
+  const displayValues = Array.isArray(value) ? value.map((entry) => typeof entry === "string" ? entry : String(entry)) : [];
+  const serializedValue = Array.isArray(value) ? serializeStringEnum(displayValues) : "";
+  const [draftValue, setDraftValue] = useState3(serializedValue);
+  const lastSubmittedSignatureRef = useRef3(null);
+  useEffect3(() => {
+    const nextSignature = Array.isArray(value) ? JSON.stringify(displayValues) : "";
+    if (lastSubmittedSignatureRef.current === nextSignature) {
+      return;
+    }
+    setDraftValue(serializedValue);
+  }, [serializedValue, value]);
+  return /* @__PURE__ */ jsx12(
+    TextInput,
+    {
+      label: "Enum",
+      keyword: "enum",
+      type: "text",
+      value: draftValue,
+      placeholder: `e.g. A, B, "C, D", 'E, F'`,
+      onChange: (nextText) => {
+        setDraftValue(nextText);
+        if (nextText.trim() === "") {
+          lastSubmittedSignatureRef.current = "";
+          onChange(void 0);
+          return;
+        }
+        const parsed = parseStringEnum(nextText);
+        if (!parsed.valid || !parsed.values) {
+          return;
+        }
+        const normalizedValues = parsed.values.map((entry) => {
+          if (!parseEntry) {
+            return entry;
+          }
+          return parseEntry(entry);
+        });
+        if (normalizedValues.some((entry) => entry === void 0)) {
+          return;
+        }
+        const typedValues = normalizedValues;
+        const submittedSignature = JSON.stringify(
+          typedValues.map((entry) => typeof entry === "string" ? entry : String(entry))
+        );
+        lastSubmittedSignatureRef.current = submittedSignature;
+        onChange(typedValues);
+      }
+    }
+  );
+}
+function parseLooseScalarByTypes(value, schemaTypes) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return void 0;
+  }
+  if (schemaTypes.includes("boolean")) {
+    if (trimmed === "true") {
+      return true;
+    }
+    if (trimmed === "false") {
+      return false;
+    }
+  }
+  if (schemaTypes.includes("null") && trimmed === "null") {
+    return null;
+  }
+  if (schemaTypes.includes("integer")) {
+    const parsedInteger = Number(trimmed);
+    if (Number.isInteger(parsedInteger)) {
+      return parsedInteger;
+    }
+  }
+  if (schemaTypes.includes("number")) {
+    const parsedNumber = Number(trimmed);
+    if (Number.isFinite(parsedNumber)) {
+      return parsedNumber;
+    }
+  }
+  if (schemaTypes.includes("string")) {
+    return value;
+  }
+  return void 0;
+}
+function parseStringEnum(input) {
+  const values = [];
+  let token = "";
+  let inDoubleQuote = false;
+  let inSingleQuote = false;
+  let tokenUsedQuotes = false;
+  let tokenClosedQuote = false;
+  const pushToken = () => {
+    const candidate = tokenUsedQuotes ? token : token.trim();
+    if (candidate.length > 0) {
+      values.push(candidate);
+    }
+    token = "";
+    tokenUsedQuotes = false;
+    tokenClosedQuote = false;
+  };
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (inDoubleQuote) {
+      if (char === '"') {
+        if (token.endsWith("/")) {
+          token = `${token.slice(0, -1)}"`;
+          continue;
+        }
+        inDoubleQuote = false;
+        tokenClosedQuote = true;
+        continue;
+      }
+      token += char;
+      continue;
+    }
+    if (inSingleQuote) {
+      if (char === "'") {
+        if (token.endsWith("/")) {
+          token = `${token.slice(0, -1)}'`;
+          continue;
+        }
+        inSingleQuote = false;
+        tokenClosedQuote = true;
+        continue;
+      }
+      token += char;
+      continue;
+    }
+    if (char === ",") {
+      pushToken();
+      continue;
+    }
+    if (char === '"') {
+      if (token.trim().length === 0) {
+        token = "";
+      }
+      inDoubleQuote = true;
+      tokenUsedQuotes = true;
+      continue;
+    }
+    if (char === "'") {
+      if (token.trim().length === 0) {
+        token = "";
+      }
+      inSingleQuote = true;
+      tokenUsedQuotes = true;
+      continue;
+    }
+    if (tokenClosedQuote && /\s/.test(char)) {
+      continue;
+    }
+    token += char;
+  }
+  if (inDoubleQuote || inSingleQuote) {
+    return { valid: false, values: null };
+  }
+  pushToken();
+  return { valid: true, values };
+}
+function serializeStringEnum(values) {
+  return values.map((value) => {
+    const needsQuotes = value === "" || /[\s,\"']/.test(value);
+    if (!needsQuotes) {
+      return value;
+    }
+    const escaped = value.replace(/\"/g, '/"');
+    return `"${escaped}"`;
+  }).join(", ");
+}
+function createDefaultRootSchema() {
+  return {
+    $schema: DEFAULT_SCHEMA_URI,
+    title: "New Schema",
+    type: "object",
+    properties: {},
+    required: []
+  };
+}
+function applyTypes(schema, nextTypesInput) {
+  const next = cloneSchema(schema);
+  const previousTypes = getSchemaTypes(next);
+  const nextTypes = normalizeTypes(nextTypesInput);
+  const removedTypes = previousTypes.filter((type) => !nextTypes.includes(type));
+  for (const removedType of removedTypes) {
+    removeTypeSpecificKeywords(next, removedType, nextTypes);
+  }
+  next.type = nextTypes.length === 1 ? nextTypes[0] : nextTypes;
+  if (nextTypes.includes("object")) {
+    next.properties = next.properties ?? {};
+    next.required = Array.isArray(next.required) ? next.required : [];
+  }
+  if (nextTypes.includes("array")) {
+    next.items = next.items ?? { type: "string" };
+  }
+  return next;
+}
+function removeTypeSpecificKeywords(schema, type, activeTypes) {
+  if (type === "object") {
+    if (!activeTypes.includes("object")) {
+      delete schema.properties;
+      delete schema.patternProperties;
+      delete schema.required;
+      delete schema.dependentRequired;
+      delete schema.dependentSchemas;
+      delete schema.additionalProperties;
+      delete schema.unevaluatedProperties;
+      delete schema.propertyNames;
+      delete schema.minProperties;
+      delete schema.maxProperties;
+    }
+    return;
+  }
+  if (type === "array") {
+    if (!activeTypes.includes("array")) {
+      delete schema.items;
+      delete schema.contains;
+      delete schema.minItems;
+      delete schema.maxItems;
+      delete schema.uniqueItems;
+      delete schema.minContains;
+      delete schema.maxContains;
+      delete schema.unevaluatedItems;
+    }
+    return;
+  }
+  if (type === "string") {
+    if (!activeTypes.includes("string")) {
+      delete schema.pattern;
+    }
+    return;
+  }
+  if (type === "number" || type === "integer") {
+    if (!(activeTypes.includes("number") || activeTypes.includes("integer"))) {
+      delete schema.minimum;
+      delete schema.maximum;
+      delete schema.multipleOf;
+      delete schema.exclusiveMinimum;
+      delete schema.exclusiveMaximum;
+    }
+  }
+}
+function getSchemaTypes(schema) {
+  if (Array.isArray(schema.type)) {
+    return normalizeTypes(schema.type);
+  }
+  if (typeof schema.type === "string") {
+    return normalizeTypes([schema.type]);
+  }
+  return ["object"];
+}
+function normalizeTypes(types) {
+  const normalized = [];
+  for (const type of types) {
+    if (!FIELD_TYPES.includes(type)) {
+      continue;
+    }
+    if (!normalized.includes(type)) {
+      normalized.push(type);
+    }
+  }
+  return normalized.length > 0 ? normalized : ["string"];
+}
+function assignOptionalString(schema, key, value) {
+  const next = cloneSchema(schema);
+  if (value.trim() === "") {
+    delete next[key];
+    return next;
+  }
+  next[key] = value;
+  return next;
+}
+function assignOptionalNumber(schema, key, value) {
+  const next = cloneSchema(schema);
+  if (value.trim() === "") {
+    delete next[key];
+    return next;
+  }
+  const parsed = Number(value);
+  if (Number.isNaN(parsed)) {
+    return next;
+  }
+  next[key] = parsed;
+  return next;
+}
+function assignOptionalInteger(schema, key, value) {
+  const next = cloneSchema(schema);
+  if (value.trim() === "") {
+    delete next[key];
+    return next;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return next;
+  }
+  next[key] = parsed;
+  return next;
+}
+function assignOptionalPositiveNumber(schema, key, value) {
+  const next = cloneSchema(schema);
+  if (value.trim() === "") {
+    delete next[key];
+    return next;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return next;
+  }
+  next[key] = parsed;
+  return next;
+}
+function parseCommaSeparatedStrings(value) {
+  return Array.from(
+    new Set(
+      value.split(",").map((entry) => entry.trim()).filter((entry) => entry !== "")
+    )
+  );
+}
+function createUniquePropertyName(properties, baseName) {
+  if (!properties[baseName]) {
+    return baseName;
+  }
+  let index = 1;
+  while (properties[`${baseName}${index}`]) {
+    index += 1;
+  }
+  return `${baseName}${index}`;
+}
+function createUniqueEntryName(entries, baseName) {
+  if (!Object.prototype.hasOwnProperty.call(entries, baseName)) {
+    return baseName;
+  }
+  let index = 1;
+  while (Object.prototype.hasOwnProperty.call(entries, `${baseName}${index}`)) {
+    index += 1;
+  }
+  return `${baseName}${index}`;
+}
+function cloneSchema(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function sanitizeSchemaForOutput(schema) {
+  const next = cloneSchema(schema);
+  if (next.properties) {
+    const sanitizedProperties = {};
+    for (const [propertyName, propertySchema] of Object.entries(next.properties)) {
+      if (propertyName.trim() === "") {
+        continue;
+      }
+      sanitizedProperties[propertyName] = sanitizeSchemaForOutput(propertySchema);
+    }
+    if (Object.keys(sanitizedProperties).length > 0) {
+      next.properties = sanitizedProperties;
+    } else {
+      delete next.properties;
+    }
+  }
+  if (next.patternProperties) {
+    const sanitizedPatternProperties = {};
+    for (const [patternKey, patternSchema] of Object.entries(next.patternProperties)) {
+      if (patternKey.trim() === "") {
+        continue;
+      }
+      sanitizedPatternProperties[patternKey] = sanitizeSchemaForOutput(patternSchema);
+    }
+    next.patternProperties = sanitizedPatternProperties;
+  }
+  if (next.dependentSchemas) {
+    const sanitizedDependentSchemas = {};
+    for (const [propertyName, dependentSchema] of Object.entries(next.dependentSchemas)) {
+      if (propertyName.trim() === "") {
+        continue;
+      }
+      sanitizedDependentSchemas[propertyName] = sanitizeSchemaForOutput(dependentSchema);
+    }
+    next.dependentSchemas = sanitizedDependentSchemas;
+  }
+  if (next.dependentRequired) {
+    const sanitizedDependentRequired = {};
+    for (const [propertyName, dependencies] of Object.entries(next.dependentRequired)) {
+      if (propertyName.trim() === "") {
+        continue;
+      }
+      if (!Array.isArray(dependencies)) {
+        sanitizedDependentRequired[propertyName] = [];
+        continue;
+      }
+      const cleanedDependencies = Array.from(
+        new Set(
+          dependencies.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry !== "")
+        )
+      );
+      sanitizedDependentRequired[propertyName] = cleanedDependencies;
+    }
+    next.dependentRequired = sanitizedDependentRequired;
+  }
+  if (Array.isArray(next.required)) {
+    next.required = next.required.filter((entry) => entry.trim() !== "");
+    if (next.required.length === 0) {
+      delete next.required;
+    }
+  }
+  if (Array.isArray(next.items)) {
+    next.prefixItems = next.items.map((itemSchema) => sanitizeSchemaForOutput(itemSchema));
+    next.items = false;
+  }
+  if (Array.isArray(next.prefixItems)) {
+    next.prefixItems = next.prefixItems.map((itemSchema) => sanitizeSchemaForOutput(itemSchema));
+  } else if (isObject3(next.items)) {
+    next.items = sanitizeSchemaForOutput(next.items);
+  }
+  if (isObject3(next.contains)) {
+    next.contains = sanitizeSchemaForOutput(next.contains);
+  }
+  if (isObject3(next.unevaluatedItems)) {
+    next.unevaluatedItems = sanitizeSchemaForOutput(next.unevaluatedItems);
+  }
+  if (isObject3(next.not)) {
+    next.not = sanitizeSchemaForOutput(next.not);
+  }
+  if (isObject3(next.additionalProperties)) {
+    next.additionalProperties = sanitizeSchemaForOutput(next.additionalProperties);
+  }
+  if (isObject3(next.unevaluatedProperties)) {
+    next.unevaluatedProperties = sanitizeSchemaForOutput(next.unevaluatedProperties);
+  }
+  if (isObject3(next.propertyNames)) {
+    next.propertyNames = sanitizeSchemaForOutput(next.propertyNames);
+  }
+  for (const key of ["if", "then", "else"]) {
+    if (isObject3(next[key])) {
+      next[key] = sanitizeSchemaForOutput(next[key]);
+    }
+  }
+  for (const key of ["allOf", "anyOf", "oneOf"]) {
+    if (Array.isArray(next[key])) {
+      next[key] = next[key].map((entry) => sanitizeSchemaForOutput(entry));
+    }
+  }
+  return next;
+}
+function applyDomainToRootId(schema, domain) {
+  if (!domain) {
+    return schema;
+  }
+  const next = cloneSchema(schema);
+  const localId = stringOrEmpty(next.$id);
+  if (!localId.trim()) {
+    return next;
+  }
+  next.$id = toFullId(localId, domain);
+  return next;
+}
+function toLocalId(value, domain) {
+  const trimmed = value.trim();
+  if (!domain || !trimmed) {
+    return trimmed;
+  }
+  const normalizedDomain = normalizeDomain(domain);
+  if (!normalizedDomain) {
+    return trimmed;
+  }
+  if (trimmed === normalizedDomain) {
+    return "";
+  }
+  const domainWithSlash = `${normalizedDomain}/`;
+  if (trimmed.startsWith(domainWithSlash)) {
+    return trimmed.slice(domainWithSlash.length);
+  }
+  return trimmed;
+}
+function toFullId(localId, domain) {
+  const trimmedLocal = localId.trim();
+  if (!domain || !trimmedLocal) {
+    return trimmedLocal;
+  }
+  const normalizedDomain = normalizeDomain(domain);
+  if (!normalizedDomain) {
+    return trimmedLocal;
+  }
+  if (trimmedLocal === normalizedDomain || trimmedLocal.startsWith(`${normalizedDomain}/`)) {
+    return trimmedLocal;
+  }
+  return `${normalizedDomain}/${trimmedLocal.replace(/^\/+/, "")}`;
+}
+function normalizeDomain(domain) {
+  return domain.trim().replace(/\/+$/, "");
+}
+function validateSchemaDefinition(schema) {
+  const consistencyErrors = validateConstAndEnumConsistency(schema);
+  try {
+    const ajv = createAjvForSchema(schema);
+    const valid = ajv.validateSchema(schema);
+    const schemaErrors = valid ? [] : (ajv.errors ?? []).map((error) => ({
+      message: error.message ?? "Schema validation error",
+      keyword: error.keyword,
+      instancePath: error.instancePath,
+      schemaPath: error.schemaPath,
+      source: "schema"
+    }));
+    return [...schemaErrors, ...consistencyErrors];
+  } catch (error) {
+    return [
+      {
+        message: error instanceof Error ? error.message : "Schema validation failed.",
+        source: "schema"
+      },
+      ...consistencyErrors
+    ];
+  }
+}
+function validateConstAndEnumConsistency(schema, schemaPointer = "") {
+  const errors = [];
+  const schemaTypes = getSchemaTypes(schema);
+  const hasConst = Object.prototype.hasOwnProperty.call(schema, "const");
+  if (hasConst && !matchesAnySchemaType(schema.const, schemaTypes)) {
+    errors.push({
+      message: "const value does not match the field type.",
+      keyword: "const",
+      instancePath: schemaPointer,
+      schemaPath: `${schemaPointer}/const`,
+      source: "schema"
+    });
+  }
+  if (schema.enum !== void 0) {
+    if (!Array.isArray(schema.enum)) {
+      errors.push({
+        message: "enum must be an array.",
+        keyword: "enum",
+        instancePath: schemaPointer,
+        schemaPath: `${schemaPointer}/enum`,
+        source: "schema"
+      });
+    } else {
+      schema.enum.forEach((enumValue, index) => {
+        if (!matchesAnySchemaType(enumValue, schemaTypes)) {
+          errors.push({
+            message: `enum value at index ${index} does not match the field type.`,
+            keyword: "enum",
+            instancePath: schemaPointer,
+            schemaPath: `${schemaPointer}/enum/${index}`,
+            source: "schema"
+          });
+        }
+      });
+      if (hasConst && !schema.enum.some((entry) => deepEqual(entry, schema.const))) {
+        errors.push({
+          message: "const value must exist in enum when both are provided.",
+          keyword: "const",
+          instancePath: schemaPointer,
+          schemaPath: `${schemaPointer}/const`,
+          source: "schema"
+        });
+      }
+    }
+  }
+  if (schema.properties) {
+    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+      errors.push(
+        ...validateConstAndEnumConsistency(
+          propertySchema,
+          `${schemaPointer}/properties/${escapeJsonPointerToken2(propertyName)}`
+        )
+      );
+    }
+  }
+  if (schema.patternProperties) {
+    for (const [patternKey, patternSchema] of Object.entries(schema.patternProperties)) {
+      errors.push(
+        ...validateConstAndEnumConsistency(
+          patternSchema,
+          `${schemaPointer}/patternProperties/${escapeJsonPointerToken2(patternKey)}`
+        )
+      );
+    }
+  }
+  if (schema.dependentSchemas) {
+    for (const [propertyName, dependentSchema] of Object.entries(schema.dependentSchemas)) {
+      errors.push(
+        ...validateConstAndEnumConsistency(
+          dependentSchema,
+          `${schemaPointer}/dependentSchemas/${escapeJsonPointerToken2(propertyName)}`
+        )
+      );
+    }
+  }
+  if (Array.isArray(schema.items)) {
+    schema.items.forEach((itemSchema, index) => {
+      errors.push(...validateConstAndEnumConsistency(itemSchema, `${schemaPointer}/items/${index}`));
+    });
+  } else if (isObject3(schema.items)) {
+    errors.push(...validateConstAndEnumConsistency(schema.items, `${schemaPointer}/items`));
+  }
+  if (isObject3(schema.contains)) {
+    errors.push(...validateConstAndEnumConsistency(schema.contains, `${schemaPointer}/contains`));
+  }
+  if (isObject3(schema.unevaluatedItems)) {
+    errors.push(...validateConstAndEnumConsistency(schema.unevaluatedItems, `${schemaPointer}/unevaluatedItems`));
+  }
+  if (isObject3(schema.not)) {
+    errors.push(...validateConstAndEnumConsistency(schema.not, `${schemaPointer}/not`));
+  }
+  if (isObject3(schema.additionalProperties)) {
+    errors.push(
+      ...validateConstAndEnumConsistency(schema.additionalProperties, `${schemaPointer}/additionalProperties`)
+    );
+  }
+  if (isObject3(schema.unevaluatedProperties)) {
+    errors.push(
+      ...validateConstAndEnumConsistency(schema.unevaluatedProperties, `${schemaPointer}/unevaluatedProperties`)
+    );
+  }
+  if (isObject3(schema.propertyNames)) {
+    errors.push(...validateConstAndEnumConsistency(schema.propertyNames, `${schemaPointer}/propertyNames`));
+  }
+  for (const key of ["if", "then", "else"]) {
+    if (isObject3(schema[key])) {
+      errors.push(...validateConstAndEnumConsistency(schema[key], `${schemaPointer}/${key}`));
+    }
+  }
+  for (const combinatorKey of ["allOf", "anyOf", "oneOf"]) {
+    const entries = schema[combinatorKey];
+    if (!Array.isArray(entries)) {
+      continue;
+    }
+    entries.forEach((entry, index) => {
+      errors.push(...validateConstAndEnumConsistency(entry, `${schemaPointer}/${combinatorKey}/${index}`));
+    });
+  }
+  return errors;
+}
+function matchesAnySchemaType(value, schemaTypes) {
+  return schemaTypes.some((schemaType) => matchesSchemaType(value, schemaType));
+}
+function matchesSchemaType(value, schemaType) {
+  if (schemaType === "string") {
+    return typeof value === "string";
+  }
+  if (schemaType === "number") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  if (schemaType === "integer") {
+    return typeof value === "number" && Number.isInteger(value);
+  }
+  if (schemaType === "boolean") {
+    return typeof value === "boolean";
+  }
+  if (schemaType === "null") {
+    return value === null;
+  }
+  if (schemaType === "array") {
+    return Array.isArray(value);
+  }
+  return isObject3(value);
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((entry, index) => deepEqual(entry, b[index]));
+  }
+  if (isObject3(a) && isObject3(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    return keysA.every((key) => deepEqual(a[key], b[key]));
+  }
+  return false;
+}
+function escapeJsonPointerToken2(value) {
+  return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function numberOrEmpty(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "";
+}
+function toInlineJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  SchemaBuilder,
+  SchemaBuilderHelper,
+  SchemaForm
+};
+//# sourceMappingURL=index.mjs.map