@sanity/schema 5.0.0-next.0-9b570ece82-202507150640 → 5.0.0-next.7

package/lib/_internal.js

@@ -1,44 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: !0 });
-var descriptors = require("@sanity/descriptors"), resolve = require("./_chunks-cjs/resolve.js"), difference = require("lodash/difference.js"), groqJs = require("groq-js"), flatten = require("lodash/flatten.js"), get = require("lodash/get.js"), uniq = require("lodash/uniq.js"), humanizeList = require("humanize-list"), partition = require("lodash/partition.js"), isPlainObject = require("lodash/isPlainObject.js"), omit = require("lodash/omit.js"), leven = require("leven"), inspect = require("object-inspect");
-function _interopDefaultCompat(e) {
-  return e && typeof e == "object" && "default" in e ? e : { default: e };
-}
-var difference__default = /* @__PURE__ */ _interopDefaultCompat(difference), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), get__default = /* @__PURE__ */ _interopDefaultCompat(get), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), humanizeList__default = /* @__PURE__ */ _interopDefaultCompat(humanizeList), partition__default = /* @__PURE__ */ _interopDefaultCompat(partition), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), leven__default = /* @__PURE__ */ _interopDefaultCompat(leven), inspect__default = /* @__PURE__ */ _interopDefaultCompat(inspect);
-const MAX_DEPTH_UKNOWN = 5;
+import { SetBuilder, processSetSynchronization } from "@sanity/descriptors";
+import isEqual from "lodash/isEqual.js";
+import isObject from "lodash/isObject.js";
+import { OWN_PROPS_NAME, Rule, Schema } from "./_chunks-es/Rule.js";
+import { ALL_FIELDS_GROUP_NAME, DEFAULT_MAX_FIELD_DEPTH, resolveSearchConfig, resolveSearchConfigForBaseFieldPaths } from "./_chunks-es/Rule.js";
+import difference from "lodash/difference.js";
+import cloneDeep from "lodash/cloneDeep.js";
+import flatten from "lodash/flatten.js";
+import get from "lodash/get.js";
+import uniq from "lodash/uniq.js";
+import humanizeList from "humanize-list";
+import partition from "lodash/partition.js";
+import isPlainObject from "lodash/isPlainObject.js";
+import omit from "lodash/omit.js";
+import leven from "leven";
+import inspect from "object-inspect";
+import { createReferenceTypeNode } from "groq-js";
+const MAX_IDLE_WORK = 8.333333333333334;
+class IdleScheduler {
+  #durations = [];
+  #lastAwake;
+  constructor(durations) {
+    this.#lastAwake = performance.now(), this.#durations = durations;
+  }
+  async map(arr, fn) {
+    const result = [];
+    for (const val of arr) {
+      const pause = this._tryPause();
+      pause && await pause, result.push(fn(val));
+    }
+    return result;
+  }
+  async forEach(arr, fn) {
+    for (const val of arr) {
+      const pause = this._tryPause();
+      pause && await pause, fn(val);
+    }
+  }
+  async forEachIter(iter, fn) {
+    for (const val of iter) {
+      const pause = this._tryPause();
+      pause && await pause, fn(val);
+    }
+  }
+  /** Should be invoked at the end to also measure the last pause. */
+  end() {
+    this.#durations.push(performance.now() - this.#lastAwake);
+  }
+  /**
+   * Yields control back to the UI.
+   */
+  _tryPause() {
+    const elapsed = performance.now() - this.#lastAwake;
+    if (!(elapsed < MAX_IDLE_WORK))
+      return this.#durations.push(elapsed), new Promise((resolve) => {
+        const done = () => {
+          this.#lastAwake = performance.now(), resolve();
+        };
+        typeof requestIdleCallback == "function" ? requestIdleCallback(done, { timeout: 1 }) : typeof requestAnimationFrame == "function" ? requestAnimationFrame(done) : setTimeout(done, 0);
+      });
+  }
+}
+const SYNC_SCHEDULER = {
+  async map(arr, fn) {
+    return arr.map(fn);
+  },
+  async forEach(arr, fn) {
+    return arr.forEach(fn);
+  },
+  async forEachIter(iter, fn) {
+    for (const val of iter)
+      fn(val);
+  }
+}, MAX_DEPTH_UKNOWN = 5;
 class DescriptorConverter {
-  opts;
   cache = /* @__PURE__ */ new WeakMap();
-  constructor(opts) {
-    this.opts = opts;
-  }
   /**
    * Returns a synchronization object for a schema.
    *
    * This is automatically cached in a weak map.
    */
-  get(schema) {
+  async get(schema, opts) {
     let value = this.cache.get(schema);
     if (value) return value;
-    const builder = new descriptors.SetBuilder();
-    for (const name of schema.getLocalTypeNames()) {
-      const typeDef = convertTypeDef(schema.get(name));
-      builder.addObject("sanity.schema.namedType", { name, typeDef });
-    }
-    return schema.parent && builder.addSet(this.get(schema.parent)), value = builder.build("sanity.schema.registry"), this.cache.set(schema, value), value;
+    let idleScheduler;
+    const scheduler = opts?.scheduler || (opts?.pauseDurations ? idleScheduler = new IdleScheduler(opts.pauseDurations) : SYNC_SCHEDULER), options = {
+      fields: /* @__PURE__ */ new Map(),
+      duplicateFields: /* @__PURE__ */ new Map(),
+      arrayElements: /* @__PURE__ */ new Map(),
+      duplicateArrayElements: /* @__PURE__ */ new Map()
+    }, namedTypes = await scheduler.map(schema.getLocalTypeNames(), (name) => {
+      const typeDef = convertTypeDef(schema.get(name), name, options);
+      return { name, typeDef };
+    }), rewriteMap = /* @__PURE__ */ new Map();
+    for (const [fieldDef, key] of options.duplicateFields.entries())
+      rewriteMap.set(fieldDef, { __type: "hoisted", key });
+    for (const [arrayElem, key] of options.duplicateArrayElements.entries())
+      rewriteMap.set(arrayElem, { __type: "hoisted", key });
+    const builder = new SetBuilder({ rewriteMap });
+    return await scheduler.forEachIter(options.duplicateFields.entries(), ([fieldDef, key]) => {
+      builder.addObject("sanity.schema.hoisted", { key, value: { ...fieldDef } });
+    }), await scheduler.forEachIter(options.duplicateArrayElements.entries(), ([arrayElem, key]) => {
+      builder.addObject("sanity.schema.hoisted", { key, value: { ...arrayElem } });
+    }), await scheduler.forEach(namedTypes, (namedType) => {
+      builder.addObject("sanity.schema.namedType", namedType);
+    }), schema.parent && builder.addSet(await this.get(schema.parent, { scheduler })), value = builder.build("sanity.schema.registry"), this.cache.set(schema, value), idleScheduler && idleScheduler.end(), value;
   }
 }
-function convertCommonTypeDef(schemaType, opts) {
-  const ownProps = resolve.OWN_PROPS_NAME in schemaType ? schemaType[resolve.OWN_PROPS_NAME] : schemaType;
+function convertCommonTypeDef(schemaType, path, opts) {
+  const ownProps = OWN_PROPS_NAME in schemaType ? schemaType[OWN_PROPS_NAME] : schemaType;
   let fields;
-  Array.isArray(ownProps.fields) && (fields = ownProps.fields.map(
-    ({ name, group, fieldset, type }) => ({
+  Array.isArray(ownProps.fields) && (fields = ownProps.fields.map((field) => {
+    const fieldPath = `${path}.${field.name}`, value = opts.fields.get(field);
+    if (value) {
+      const otherPath = opts.duplicateFields.get(value);
+      return (!otherPath || isLessCanonicalName(fieldPath, otherPath)) && opts.duplicateFields.set(value, fieldPath), value;
+    }
+    const { name, group, fieldset, type } = field, converted = {
       name,
-      typeDef: convertTypeDef(type),
+      typeDef: convertTypeDef(type, fieldPath, opts),
       groups: arrayifyString(group),
       fieldset
-    })
-  ));
+    };
+    return opts.fields.set(field, converted), converted;
+  }));
   let fieldsets;
   Array.isArray(ownProps.fieldsets) && (fieldsets = filterStringKey(
     "name",
@@ -58,16 +142,18 @@ function convertCommonTypeDef(schemaType, opts) {
   Array.isArray(ownProps.groups) && (groups = filterStringKey(
     "name",
     ownProps.groups.map(
-      ({ name, title, hidden, default: def }) => ({
+      ({ name, title, hidden, default: def, i18n }) => ({
         name,
         title: maybeString(title),
         hidden: conditionalTrue(hidden),
-        default: maybeTrue(def)
+        default: maybeTrue(def),
+        i18n: maybeI18n(i18n)
       })
     )
   ));
   const reason = ownProps.deprecated?.reason;
-  return {
+  let orderings;
+  return Array.isArray(ownProps.orderings) && (orderings = ownProps.orderings.map(maybeOrdering).filter((o) => o !== void 0)), {
     title: maybeString(ownProps.title),
     description: maybeStringOrJSX(ownProps.description),
     readOnly: conditionalTrue(ownProps.readOnly),
@@ -80,11 +166,13 @@ function convertCommonTypeDef(schemaType, opts) {
     rows: maybeNumberAsString(ownProps.rows),
     fields,
     fieldsets,
-    groups
+    groups,
+    validation: maybeValidations(ownProps),
+    orderings
   };
 }
-function convertTypeDef(schemaType, opts) {
-  const common2 = convertCommonTypeDef(schemaType);
+function convertTypeDef(schemaType, path, opts) {
+  const common2 = convertCommonTypeDef(schemaType, path, opts);
   if (!schemaType.type)
     return {
       extends: null,
@@ -95,10 +183,18 @@ function convertTypeDef(schemaType, opts) {
     case "array":
       return {
         extends: "array",
-        of: schemaType.of.map((ofType) => ({
-          name: ofType.name,
-          typeDef: convertTypeDef(ofType)
-        })),
+        of: schemaType.of.map((ofType, idx) => {
+          const itemPath = `${path}.${ofType.name}`, value = opts.arrayElements.get(ofType);
+          if (value) {
+            const otherPath = opts.duplicateArrayElements.get(value);
+            return (!otherPath || isLessCanonicalName(itemPath, otherPath)) && opts.duplicateArrayElements.set(value, itemPath), value;
+          }
+          const converted = {
+            name: ofType.name,
+            typeDef: convertTypeDef(ofType, `${path}.${ofType.name}`, opts)
+          };
+          return opts.arrayElements.set(ofType, converted), converted;
+        }),
         ...common2
       };
     case "reference":
@@ -147,7 +243,7 @@ function convertUnknown(val, seen = /* @__PURE__ */ new Set(), maxDepth = MAX_DE
   if (typeof val == "function") return FUNCTION_MARKER;
   if (seen.has(val))
     return CYCLIC_MARKER;
-  if (seen.add(val), typeof val == "object") {
+  if (seen.add(val), isObject(val)) {
     if (Array.isArray(val))
       return val.map((elem) => {
         const res = convertUnknown(elem, seen, maxDepth - 1);
@@ -171,13 +267,239 @@ function convertUnknown(val, seen = /* @__PURE__ */ new Set(), maxDepth = MAX_DE
 }
 function maybeStringOrJSX(val) {
   if (typeof val == "string") return val;
-  if (val && typeof val == "object" && "$$typeof" in val && "type" in val && "props" in val) {
+  if (isObject(val) && "$$typeof" in val && "type" in val && "props" in val) {
     const { type, props } = val, strType = typeof type == "function" ? type.name : type;
     return typeof strType != "string" ? void 0 : { __type: "jsx", type: strType, props: convertUnknown(props) };
   }
 }
+function maybeValidations(obj) {
+  if (!isObject(obj) || !("type" in obj)) return;
+  const impliedRules = [];
+  switch ("options" in obj && isObject(obj.options) && "list" in obj.options && Array.isArray(obj.options.list) && impliedRules.push({
+    type: "enum",
+    values: obj.options.list.map((o) => convertUnknown(extractValueFromListOption(o, obj))).filter((v) => v !== void 0)
+  }), obj.type) {
+    case "url":
+      impliedRules.push({
+        type: "uri",
+        allowRelative: !1
+      });
+      break;
+    case "slug":
+      impliedRules.push({
+        type: "custom"
+      });
+      break;
+    case "reference":
+      impliedRules.push({
+        type: "reference"
+      });
+      break;
+    case "email":
+      impliedRules.push({
+        type: "email"
+      });
+      break;
+  }
+  if (!("validation" in obj) || !obj.validation)
+    return impliedRules.length > 0 ? [
+      {
+        level: "error",
+        rules: impliedRules
+      }
+    ] : void 0;
+  const validations = [], rules = Array.isArray(obj.validation) ? obj.validation : [obj.validation];
+  for (const rule of rules) {
+    const validation = maybeValidation(rule);
+    if (validation === void 0)
+      continue;
+    const rulesToAdd = impliedRules.filter((ir) => !validation.rules.some((r) => isEqual(r, ir)));
+    rulesToAdd.length > 0 && validation.rules.unshift(...rulesToAdd), !validations.some((v) => isEqual(v, validation)) && validations.push(validation);
+  }
+  return validations.length > 0 ? validations : void 0;
+}
+function hasValueField(typeDef) {
+  return !typeDef || typeof typeDef != "object" ? !1 : "fields" in typeDef ? Array.isArray(typeDef.fields) ? typeDef.fields.some((field) => field.name === "value") : !1 : "type" in typeDef && typeDef.type ? hasValueField(typeDef.type) : !1;
+}
+function extractValueFromListOption(option, typeDef) {
+  return typeDef.jsonType === "object" && hasValueField(typeDef) ? option : isObject(option) && "value" in option && option.value ? option.value : option;
+}
+function maybeValidation(val) {
+  if (val) {
+    if (isIRuleFunction(val))
+      try {
+        const result = val(new Rule());
+        if (isIRule(result))
+          return maybeValidation(result);
+        throw new Error("failed to convert to plain rule");
+      } catch {
+        return {
+          level: "error",
+          rules: [{ type: "custom", name: "function" }]
+        };
+      }
+    if (isIRule(val)) {
+      const level = val._level || "error", message = maybeValidationMessage(val._message), rules = [];
+      for (const spec of val._rules || []) {
+        const optional = val._required === "optional" || void 0, convertedRule = convertRuleSpec(spec, optional);
+        convertedRule !== void 0 && (rules.some((r) => isEqual(r, convertedRule)) || rules.push(convertedRule));
+      }
+      return rules.length === 0 ? void 0 : {
+        level,
+        rules,
+        ...message && { message }
+      };
+    }
+  }
+}
+function isIRule(val) {
+  return isObject(val) && "_rules" in val;
+}
+function maybeValidationMessage(val) {
+  if (typeof val == "string") return val;
+  if (!isObject(val) || Array.isArray(val)) return;
+  const objectMessage = {};
+  for (const [field, value] of Object.entries(val))
+    typeof field != "string" || typeof value != "string" || (objectMessage[field] = value);
+  return Object.keys(objectMessage).length > 0 ? objectMessage : void 0;
+}
+function isIRuleFunction(val) {
+  return typeof val == "function";
+}
+function convertRuleSpec(spec, optional) {
+  if (!isObject(spec) || !("flag" in spec))
+    return;
+  const constraint = "constraint" in spec ? spec.constraint : void 0;
+  switch (spec.flag) {
+    case "integer":
+      return { type: "integer" };
+    case "email":
+      return { type: "email" };
+    case "unique":
+      return { type: "uniqueItems" };
+    case "reference":
+      return { type: "reference" };
+    case "assetRequired":
+      return { type: "assetRequired" };
+    case "stringCasing":
+      return constraint === "uppercase" ? { type: "uppercase" } : constraint === "lowercase" ? { type: "lowercase" } : void 0;
+    case "all":
+      if (Array.isArray(constraint)) {
+        const children = constraint.map((childRule) => maybeValidation(childRule)).filter((c) => c !== void 0);
+        if (children.length > 0)
+          return { type: "allOf", children };
+      }
+      return;
+    case "either":
+      if (Array.isArray(constraint)) {
+        const children = constraint.map((childRule) => maybeValidation(childRule)).filter((c) => c !== void 0);
+        if (children.length > 0)
+          return { type: "anyOf", children };
+      }
+      return;
+    case "valid":
+      return Array.isArray(constraint) ? {
+        type: "enum",
+        values: constraint.map((c) => convertUnknown(c)).filter((v) => v !== void 0)
+      } : void 0;
+    case "min":
+      return { type: "minimum", value: convertConstraintValue(constraint) };
+    case "max":
+      return { type: "maximum", value: convertConstraintValue(constraint) };
+    case "length":
+      return { type: "length", value: convertConstraintValue(constraint) };
+    case "precision":
+      return { type: "precision", value: convertConstraintValue(constraint) };
+    case "lessThan":
+      return { type: "exclusiveMaximum", value: convertConstraintValue(constraint) };
+    case "greaterThan":
+      return { type: "exclusiveMinimum", value: convertConstraintValue(constraint) };
+    case "regex":
+      if (isObject(constraint) && "pattern" in constraint) {
+        const { pattern } = constraint, invert = "invert" in constraint ? maybeBoolean(constraint.invert) : void 0;
+        if (pattern instanceof RegExp)
+          return {
+            type: "regex",
+            pattern: pattern.source,
+            ...invert && { invert: !0 }
+          };
+      }
+      return;
+    case "uri": {
+      const allowRelative = isObject(constraint) && "options" in constraint && isObject(constraint.options) && "allowRelative" in constraint.options ? maybeBoolean(constraint.options.allowRelative) : void 0;
+      return {
+        type: "uri",
+        ...allowRelative !== void 0 && { allowRelative }
+      };
+    }
+    case "custom":
+      return { type: "custom", ...optional && { optional } };
+    case "media":
+      return { type: "custom", name: "media" };
+    case "type":
+      return;
+    case "presence":
+      return constraint === "required" ? { type: "required" } : void 0;
+    default:
+      return;
+  }
+}
+function convertConstraintValue(constraint) {
+  return isObject(constraint) && "type" in constraint && "path" in constraint && constraint.type && constraint.path ? {
+    type: "fieldReference",
+    path: Array.isArray(constraint.path) ? constraint.path : [constraint.path]
+  } : String(constraint);
+}
+function maybeBoolean(val) {
+  if (typeof val == "boolean")
+    return val;
+}
+function maybeI18n(val) {
+  if (!isObject(val) || Array.isArray(val)) return;
+  const localizedMessage = {};
+  for (const entry of Object.entries(val))
+    if (isI18nEntry(entry)) {
+      const [field, value] = entry;
+      localizedMessage[field] = {
+        ns: value.ns,
+        key: value.key
+      };
+    }
+  return Object.keys(localizedMessage).length > 0 ? localizedMessage : void 0;
+}
+function isI18nEntry(entry) {
+  const [key, value] = entry;
+  return typeof key == "string" && !!value && typeof value == "object" && "key" in value && "ns" in value && typeof value.key == "string" && typeof value.ns == "string";
+}
+function maybeOrdering(val) {
+  if (!isObject(val) || Array.isArray(val)) return;
+  const name = "name" in val && typeof val.name == "string" ? val.name : void 0;
+  if (name === void 0) return;
+  const title = "title" in val && typeof val.title == "string" ? val.title : name, by = "by" in val && Array.isArray(val.by) ? val.by : [], orderingBy = [];
+  for (const item of by) {
+    const orderingItem = maybeOrderingBy(item);
+    orderingItem && orderingBy.push(orderingItem);
+  }
+  if (orderingBy.length === 0) return;
+  const i18n = "i18n" in val ? maybeI18n(val.i18n) : void 0;
+  return {
+    name,
+    title,
+    by: orderingBy,
+    ...i18n && { i18n }
+  };
+}
+function maybeOrderingBy(val) {
+  if (!isObject(val) || Array.isArray(val)) return;
+  const field = "field" in val && typeof val.field == "string" ? val.field : void 0, direction = "direction" in val && (val.direction === "asc" || val.direction === "desc") ? val.direction : void 0;
+  if (!(!field || !direction))
+    return { field, direction };
+}
+function isLessCanonicalName(a, b) {
+  return a.length < b.length || a.length === b.length && a < b;
+}
 function processSchemaSynchronization(sync, response) {
-  return descriptors.processSetSynchronization(sync, response);
+  return processSetSynchronization(sync, response);
 }
 const ACTIONS_FLAG = "__experimental_actions", DEFAULT_ACTIONS = ["create", "update", "delete", "publish"], VALID_ACTIONS = DEFAULT_ACTIONS, readActions = (schemaType) => ACTIONS_FLAG in schemaType ? schemaType[ACTIONS_FLAG] : DEFAULT_ACTIONS, validateActions = (typeName, actions) => {
   if (!Array.isArray(actions))
@@ -186,7 +508,7 @@ const ACTIONS_FLAG = "__experimental_actions", DEFAULT_ACTIONS = ["create", "upd
         ", "
       )}`
     );
-  const invalid = difference__default.default(actions, VALID_ACTIONS);
+  const invalid = difference(actions, VALID_ACTIONS);
   if (invalid.length > 0)
     throw new Error(
       `Invalid action${invalid.length > 1 ? "s" : ""} configured for schema type "${typeName}": ${invalid.join(
@@ -475,12 +797,16 @@ var assetSourceData = {
       id: "_id",
       title: "originalFilename",
       mimeType: "mimeType",
-      size: "size"
+      size: "size",
+      media: "media"
     },
     prepare(doc) {
       return {
         title: doc.title || typeof doc.path == "string" && doc.path.split("/").slice(-1)[0],
-        media: { asset: { _ref: doc.id } },
+        media: {
+          asset: { _ref: doc.id },
+          ...doc.media ? { media: doc.media } : {}
+        },
         subtitle: `${doc.mimeType} (${(Number(doc.size) / 1024 / 1024).toFixed(2)} MB)`
       };
     }
@@ -499,19 +825,23 @@ var assetSourceData = {
   fields: [
     {
       name: "top",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     },
     {
       name: "bottom",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     },
     {
       name: "left",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     },
     {
       name: "right",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     }
   ]
 }, imageDimensions = {
@@ -519,9 +849,27 @@ var assetSourceData = {
   type: "object",
   title: "Image dimensions",
   fields: [
-    { name: "height", type: "number", title: "Height", readOnly: !0 },
-    { name: "width", type: "number", title: "Width", readOnly: !0 },
-    { name: "aspectRatio", type: "number", title: "Aspect ratio", readOnly: !0 }
+    {
+      name: "height",
+      type: "number",
+      title: "Height",
+      readOnly: !0,
+      validation: (Rule2) => Rule2.required()
+    },
+    {
+      name: "width",
+      type: "number",
+      title: "Width",
+      readOnly: !0,
+      validation: (Rule2) => Rule2.required()
+    },
+    {
+      name: "aspectRatio",
+      type: "number",
+      title: "Aspect ratio",
+      readOnly: !0,
+      validation: (Rule2) => Rule2.required()
+    }
   ]
 }, imageHotspot = {
   name: "sanity.imageHotspot",
@@ -530,19 +878,23 @@ var assetSourceData = {
   fields: [
     {
       name: "x",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     },
     {
       name: "y",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     },
     {
       name: "height",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     },
     {
       name: "width",
-      type: "number"
+      type: "number",
+      validation: (Rule2) => Rule2.required()
     }
   ]
 }, imageMetadata = {
@@ -632,7 +984,7 @@ var assetSourceData = {
       name: "current",
       title: "Current slug",
       type: "string",
-      validation: (Rule) => Rule.required()
+      validation: (Rule2) => Rule2.required()
     },
     {
       // The source field is deprecated/unused, but leaving it included and hidden
@@ -657,537 +1009,221 @@ const builtinTypes = [
   imageDimensions,
   imagePalette,
   imagePaletteSwatch
-], documentDefaultFields = (typeName) => ({
-  _id: {
-    type: "objectAttribute",
-    value: { type: "string" }
-  },
-  _type: {
-    type: "objectAttribute",
-    value: { type: "string", value: typeName }
-  },
-  _createdAt: {
-    type: "objectAttribute",
-    value: { type: "string" }
-  },
-  _updatedAt: {
-    type: "objectAttribute",
-    value: { type: "string" }
-  },
-  _rev: {
-    type: "objectAttribute",
-    value: { type: "string" }
-  }
-}), typesMap = /* @__PURE__ */ new Map([
-  ["text", { type: "string" }],
-  ["url", { type: "string" }],
-  ["datetime", { type: "string" }],
-  ["date", { type: "string" }],
-  ["boolean", { type: "boolean" }],
-  ["email", { type: "string" }]
-]);
-function extractSchema(schemaDef, extractOptions = {}) {
-  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [];
-  sortByDependencies(schemaDef).forEach((typeName) => {
-    const schemaType = schemaDef.get(typeName);
-    if (schemaType === void 0)
-      return;
-    const base = convertBaseType(schemaType);
-    base !== null && (base.type === "type" && inlineFields.add(schemaType), base.type === "document" && documentTypes.set(typeName, base), schema.push(base));
-  });
-  function convertBaseType(schemaType) {
-    let typeName;
-    if (schemaType.type ? typeName = schemaType.type.name : "jsonType" in schemaType && (typeName = schemaType.jsonType), typeName === "document" && isObjectType(schemaType)) {
-      const defaultAttributes = documentDefaultFields(schemaType.name), object2 = createObject(schemaType);
-      return object2.type === "unknown" ? null : {
-        name: schemaType.name,
-        type: "document",
-        attributes: {
-          ...defaultAttributes,
-          ...object2.attributes
+], HELP_IDS = {
+  TYPE_INVALID: "schema-type-invalid",
+  TYPE_IS_ESM_MODULE: "schema-type-is-esm-module",
+  TYPE_NAME_RESERVED: "schema-type-name-reserved",
+  TYPE_MISSING_NAME: "schema-type-missing-name-or-type",
+  TYPE_MISSING_TYPE: "schema-type-missing-name-or-type",
+  TYPE_TITLE_RECOMMENDED: "schema-type-title-is-recommended",
+  TYPE_TITLE_INVALID: "schema-type-title-is-recommended",
+  OBJECT_FIELDS_INVALID: "schema-object-fields-invalid",
+  OBJECT_FIELD_NOT_UNIQUE: "schema-object-fields-invalid",
+  OBJECT_FIELD_NAME_INVALID: "schema-object-fields-invalid",
+  OBJECT_FIELD_DEFINITION_INVALID_TYPE: "schema-object-fields-invalid",
+  ARRAY_PREDEFINED_CHOICES_INVALID: "schema-predefined-choices-invalid",
+  ARRAY_OF_ARRAY: "schema-array-of-array",
+  ARRAY_OF_INVALID: "schema-array-of-invalid",
+  ARRAY_OF_NOT_UNIQUE: "schema-array-of-invalid",
+  ARRAY_OF_TYPE_GLOBAL_TYPE_CONFLICT: "schema-array-of-type-global-type-conflict",
+  ARRAY_OF_TYPE_BUILTIN_TYPE_CONFLICT: "schema-array-of-type-builtin-type-conflict",
+  REFERENCE_TO_INVALID: "schema-reference-to-invalid",
+  REFERENCE_TO_NOT_UNIQUE: "schema-reference-to-invalid",
+  REFERENCE_INVALID_OPTIONS: "schema-reference-invalid-options",
+  REFERENCE_INVALID_OPTIONS_LOCATION: "schema-reference-options-nesting",
+  REFERENCE_INVALID_FILTER_PARAMS_COMBINATION: "schema-reference-filter-params-combination",
+  SLUG_SLUGIFY_FN_RENAMED: "slug-slugifyfn-renamed",
+  ASSET_METADATA_FIELD_INVALID: "asset-metadata-field-invalid",
+  CROSS_DATASET_REFERENCE_INVALID: "cross-dataset-reference-invalid",
+  GLOBAL_DOCUMENT_REFERENCE_INVALID: "global-document-reference-invalid",
+  DEPRECATED_BLOCKEDITOR_KEY: "schema-deprecated-blockeditor-key",
+  STANDALONE_BLOCK_TYPE: "schema-standalone-block-type"
+};
+function createValidationResult(severity, message, helpId) {
+  if (helpId && !Object.keys(HELP_IDS).some((id) => HELP_IDS[id] === helpId))
+    throw new Error(
+      `Used the unknown helpId "${helpId}", please add it to the array in createValidationResult.js`
+    );
+  return {
+    severity,
+    message,
+    helpId
+  };
+}
+const error = (message, helpId) => createValidationResult("error", message, helpId), warning = (message, helpId) => createValidationResult("warning", message, helpId);
+function groupProblems(types) {
+  return flatten(types.map((type) => getTypeProblems(type))).filter(
+    (type) => type.problems.length > 0
+  );
+}
+function createTypeWithMembersProblemsAccessor(memberPropertyName, getMembers = (type) => get(type, memberPropertyName)) {
+  return function(type, parentPath) {
+    const currentPath = [
+      ...parentPath,
+      { kind: "type", type: type.type, name: type.name }
+    ], members = getMembers(type) || [], memberProblems = Array.isArray(members) ? members.map((memberType) => {
+      const propertySegment = {
+        kind: "property",
+        name: memberPropertyName
+      }, memberPath = [...currentPath, propertySegment];
+      return getTypeProblems(memberType, memberPath);
+    }) : [
+      [
+        {
+          path: currentPath,
+          problems: [error(`Member declaration (${memberPropertyName}) is not an array`)]
         }
-      };
+      ]
+    ];
+    return [
+      {
+        path: currentPath,
+        problems: type._problems || []
+      },
+      ...flatten(memberProblems)
+    ];
+  };
+}
+const arrify = (val) => Array.isArray(val) ? val : typeof val > "u" && [] || [val], getObjectProblems = createTypeWithMembersProblemsAccessor("fields"), getImageProblems = createTypeWithMembersProblemsAccessor("fields"), getFileProblems = createTypeWithMembersProblemsAccessor("fields"), getArrayProblems = createTypeWithMembersProblemsAccessor("of"), getReferenceProblems = createTypeWithMembersProblemsAccessor(
+  "to",
+  (type) => "to" in type ? arrify(type.to) : []
+), getBlockAnnotationProblems = createTypeWithMembersProblemsAccessor("marks.annotations"), getBlockMemberProblems = createTypeWithMembersProblemsAccessor("of"), getBlockProblems = (type, problems) => [
+  ...getBlockAnnotationProblems(type, problems),
+  ...getBlockMemberProblems(type, problems)
+];
+function getDefaultProblems(type, path = []) {
+  return [
+    {
+      path: [...path, { kind: "type", type: type.type, name: type.name }],
+      problems: type._problems || []
     }
-    const value = convertSchemaType(schemaType);
-    return value.type === "unknown" ? null : value.type === "object" ? {
-      name: schemaType.name,
-      type: "type",
-      value: {
-        type: "object",
-        attributes: {
-          _type: {
-            type: "objectAttribute",
-            value: {
-              type: "string",
-              value: schemaType.name
-            }
-          },
-          ...value.attributes
-        }
-      }
-    } : {
-      name: schemaType.name,
-      type: "type",
-      value
-    };
+  ];
+}
+function getTypeProblems(type, path = []) {
+  switch (type.type) {
+    case "object":
+      return getObjectProblems(type, path);
+    case "document":
+      return getObjectProblems(type, path);
+    case "array":
+      return getArrayProblems(type, path);
+    case "reference":
+      return getReferenceProblems(type, path);
+    case "block":
+      return getBlockProblems(type, path);
+    case "image":
+      return getImageProblems(type, path);
+    case "file":
+      return getFileProblems(type, path);
+    default:
+      return getDefaultProblems(type, path);
   }
-  function convertSchemaType(schemaType) {
-    if (inlineFields.has(schemaType.type))
-      return { type: "inline", name: schemaType.type.name };
-    if (schemaType.type?.type?.name === "object")
-      return { type: "inline", name: schemaType.type.name };
-    if (isStringType(schemaType))
-      return createStringTypeNodeDefintion(schemaType);
-    if (isNumberType(schemaType))
-      return createNumberTypeNodeDefintion(schemaType);
-    if (schemaType.type && typesMap.has(schemaType.type.name))
-      return typesMap.get(schemaType.type.name);
-    if (isCrossDatasetReferenceType(schemaType))
-      return { type: "unknown" };
-    if (isGlobalDocumentReferenceType(schemaType))
-      return { type: "unknown" };
-    if (isReferenceType(schemaType))
-      return createReferenceTypeNodeDefintion(schemaType);
-    if (isArrayType(schemaType))
-      return createArray(schemaType);
-    if (isObjectType(schemaType))
-      return createObject(schemaType);
-    if (lastType(schemaType)?.name === "document") {
-      const doc = documentTypes.get(schemaType.name);
-      return doc === void 0 ? { type: "unknown" } : { type: "object", attributes: doc?.attributes };
-    }
-    throw new Error(`Type "${schemaType.name}" not found`);
+}
+function getDupes(array2, selector = (v) => v) {
+  const dupes = array2.reduce((acc, item) => {
+    const key = selector(item);
+    return acc[key] || (acc[key] = []), acc[key].push(item), acc;
+  }, {});
+  return Object.keys(dupes).map((key) => dupes[key].length > 1 ? dupes[key] : null).filter(Boolean);
+}
+const NOOP_VISITOR = (typeDef) => typeDef, TYPE_TYPE = { name: "type", type: null }, FUTURE_RESERVED = ["any", "time", "date"];
+function traverseSchema(types = [], coreTypes2 = [], visitor = NOOP_VISITOR) {
+  const coreTypesRegistry = /* @__PURE__ */ Object.create(null), registry = /* @__PURE__ */ Object.create(null), coreTypeNames2 = coreTypes2.map((typeDef) => typeDef.name), reservedTypeNames = FUTURE_RESERVED.concat(coreTypeNames2), typeNames = types.map((typeDef) => typeDef && typeDef.name).filter(Boolean);
+  coreTypes2.forEach((coreType) => {
+    coreTypesRegistry[coreType.name] = coreType;
+  }), types.forEach((type, i) => {
+    registry[type && type.name || `__unnamed_${i}`] = {};
+  });
+  function getType(typeName) {
+    return typeName === "type" ? TYPE_TYPE : coreTypesRegistry[typeName] || registry[typeName] || null;
   }
-  function createObject(schemaType) {
-    const attributes = {}, fields = gatherFields(schemaType);
-    for (const field of fields) {
-      const fieldIsRequired = isFieldRequired(field), value = convertSchemaType(field.type);
-      if (value === null)
-        continue;
-      hasAssetRequired(field) && value.type === "object" && (value.attributes.asset.optional = !1);
-      const optional = extractOptions.enforceRequiredFields ? fieldIsRequired === !1 : !0;
-      attributes[field.name] = {
-        type: "objectAttribute",
-        value,
-        optional
-      };
-    }
-    return Object.keys(attributes).length === 0 ? { type: "unknown" } : (schemaType.type?.name !== "document" && schemaType.name !== "object" && (attributes._type = {
-      type: "objectAttribute",
-      value: {
-        type: "string",
-        value: schemaType.name
-      }
-    }), {
-      type: "object",
-      attributes
-    });
+  const duplicateNames = uniq(flatten(getDupes(typeNames)));
+  function isDuplicate(typeName) {
+    return duplicateNames.includes(typeName);
   }
-  function createArray(arraySchemaType) {
-    const of = [];
-    for (const item of arraySchemaType.of) {
-      const field = convertSchemaType(item);
-      field.type === "inline" ? of.push({
-        type: "object",
-        attributes: {
-          _key: createKeyField()
-        },
-        rest: field
-      }) : (field.type === "object" && (field.rest = {
-        type: "object",
-        attributes: {
-          _key: createKeyField()
-        }
-      }), of.push(field));
-    }
-    return of.length === 0 ? { type: "null" } : {
-      type: "array",
-      of: of.length > 1 ? {
-        type: "union",
-        of
-      } : of[0]
-    };
+  function getTypeNames() {
+    return typeNames.concat(coreTypeNames2);
   }
-  return schema;
-}
-function createKeyField() {
-  return {
-    type: "objectAttribute",
-    value: {
-      type: "string"
-    }
-  };
-}
-function isFieldRequired(field) {
-  const { validation } = field.type;
-  if (!validation)
-    return !1;
-  const rules = Array.isArray(validation) ? validation : [validation];
-  for (const rule of rules) {
-    let required = !1;
-    const proxy = new Proxy(
-      {},
-      {
-        get: (target, methodName) => () => (methodName === "required" && (required = !0), proxy)
-      }
-    );
-    if (typeof rule == "function" && (rule(proxy), required) || typeof rule == "object" && rule !== null && "_required" in rule && rule._required === "required")
-      return !0;
+  function isReserved(typeName) {
+    return typeName === "type" || reservedTypeNames.includes(typeName);
   }
-  return !1;
-}
-function hasAssetRequired(field) {
-  const { validation } = field.type;
-  if (!validation)
-    return !1;
-  const rules = Array.isArray(validation) ? validation : [validation];
-  for (const rule of rules) {
-    let assetRequired = !1;
-    const proxy = new Proxy(
-      {},
-      {
-        get: (target, methodName) => () => (methodName === "assetRequired" && (assetRequired = !0), proxy)
-      }
+  const visitType = (isRoot) => (typeDef, index) => visitor(typeDef, {
+    visit: visitType(!1),
+    isRoot,
+    getType,
+    getTypeNames,
+    isReserved,
+    isDuplicate,
+    index
+  });
+  return coreTypes2.forEach((coreTypeDef) => {
+    Object.assign(coreTypesRegistry[coreTypeDef.name], visitType(coreTypeDef));
+  }), types.forEach((typeDef, i) => {
+    Object.assign(
+      registry[typeDef && typeDef.name || `__unnamed_${i}`],
+      visitType(!0)(typeDef, i)
     );
-    if (typeof rule == "function" && (rule(proxy), assetRequired) || typeof rule == "object" && rule !== null && "_rules" in rule && Array.isArray(rule._rules) && rule._rules.some((r) => r.flag === "assetRequired"))
-      return !0;
-  }
-  return !1;
-}
-function isObjectType(typeDef) {
-  return isType(typeDef, "object") || typeDef.jsonType === "object" || "fields" in typeDef;
-}
-function isArrayType(typeDef) {
-  return isType(typeDef, "array");
-}
-function isReferenceType(typeDef) {
-  return isType(typeDef, "reference");
-}
-function isCrossDatasetReferenceType(typeDef) {
-  return isType(typeDef, "crossDatasetReference");
-}
-function isGlobalDocumentReferenceType(typeDef) {
-  return isType(typeDef, "globalDocumentReference");
-}
-function isStringType(typeDef) {
-  return isType(typeDef, "string");
-}
-function isNumberType(typeDef) {
-  return isType(typeDef, "number");
-}
-function createStringTypeNodeDefintion(stringSchemaType) {
-  const listOptions = stringSchemaType.options?.list;
-  return listOptions && Array.isArray(listOptions) ? {
-    type: "union",
-    of: listOptions.map((v) => ({
-      type: "string",
-      value: typeof v == "string" ? v : v.value
-    }))
-  } : {
-    type: "string"
+  }), {
+    get(typeName) {
+      const res = registry[typeName] || coreTypesRegistry[typeName];
+      if (res)
+        return res;
+      throw new Error(`No such type: ${typeName}`);
+    },
+    has(typeName) {
+      return typeName in registry || typeName in coreTypesRegistry;
+    },
+    getTypeNames() {
+      return Object.keys(registry);
+    },
+    getTypes() {
+      return this.getTypeNames().map(this.get);
+    },
+    toJSON() {
+      return this.getTypes();
+    }
   };
 }
-function createNumberTypeNodeDefintion(numberSchemaType) {
-  const listOptions = numberSchemaType.options?.list;
-  return listOptions && Array.isArray(listOptions) ? {
-    type: "union",
-    of: listOptions.map((v) => ({
-      type: "number",
-      value: typeof v == "number" ? v : v.value
-    }))
-  } : {
-    type: "number"
-  };
+const coreTypes = [
+  { name: "array", jsonType: "array", type: "type" },
+  { name: "block", jsonType: "object", type: "type" },
+  { name: "boolean", jsonType: "boolean", type: "type" },
+  { name: "datetime", jsonType: "string", type: "type" },
+  { name: "date", jsonType: "string", type: "type" },
+  { name: "document", jsonType: "object", type: "type" },
+  { name: "email", jsonType: "string", type: "type" },
+  { name: "file", jsonType: "object", type: "type" },
+  { name: "geopoint", jsonType: "object", type: "type" },
+  { name: "image", jsonType: "object", type: "type" },
+  { name: "number", jsonType: "number", type: "type" },
+  { name: "object", jsonType: "object", type: "type" },
+  { name: "reference", jsonType: "object", type: "type" },
+  { name: "crossDatasetReference", jsonType: "object", type: "type" },
+  { name: "globalDocumentReference", jsonType: "object", type: "type" },
+  { name: "slug", jsonType: "object", type: "type" },
+  { name: "span", jsonType: "object", type: "type" },
+  { name: "string", jsonType: "string", type: "type" },
+  { name: "telephone", jsonType: "string", type: "type" },
+  { name: "text", jsonType: "string", type: "type" },
+  { name: "url", jsonType: "string", type: "type" }
+], coreTypeNames = coreTypes.map((t) => t.name);
+function traverseSanitySchema(schemaTypes, visitor) {
+  return traverseSchema(schemaTypes, coreTypes, visitor);
 }
-function createReferenceTypeNodeDefintion(reference2) {
-  const references = gatherReferenceNames(reference2);
-  return references.length === 1 ? groqJs.createReferenceTypeNode(references[0]) : {
-    type: "union",
-    of: references.map((name) => groqJs.createReferenceTypeNode(name))
-  };
+function isPrimitiveTypeName(typeName) {
+  return typeName === "string" || typeName === "number" || typeName === "boolean";
 }
-function gatherReferenceNames(type) {
-  const allReferences = gatherReferenceTypes(type);
-  return [...new Set(allReferences.map((ref) => ref.name))];
+function isAssignable(typeName, type) {
+  return (typeof type.name == "string" ? type.name : type.type) === typeName;
 }
-function gatherReferenceTypes(type) {
-  const refTo = "to" in type ? type.to : [];
-  return "type" in type && isReferenceType(type.type) ? [...gatherReferenceTypes(type.type), ...refTo] : refTo;
+function quote$2(n) {
+  return `"${n}"`;
 }
-function gatherFields(type) {
-  return "fields" in type ? type.type ? gatherFields(type.type).concat(type.fields) : type.fields : [];
-}
-function isType(typeDef, typeName) {
-  let type = typeDef;
-  for (; type; ) {
-    if (type.name === typeName || type.type && type.type.name === typeName)
-      return !0;
-    type = type.type;
-  }
-  return !1;
-}
-function lastType(typeDef) {
-  let type = typeDef;
-  for (; type; ) {
-    if (!type.type)
-      return type;
-    type = type.type;
-  }
-}
-function sortByDependencies(compiledSchema) {
-  const seen = /* @__PURE__ */ new Set();
-  function walkDependencies(schemaType, dependencies) {
-    if (!seen.has(schemaType)) {
-      if (seen.add(schemaType), "fields" in schemaType)
-        for (const field of gatherFields(schemaType)) {
-          const last = lastType(field.type);
-          if (last.name === "document") {
-            dependencies.add(last);
-            continue;
-          }
-          let schemaTypeName;
-          schemaType.type.type ? schemaTypeName = field.type.type.name : "jsonType" in schemaType.type && (schemaTypeName = field.type.jsonType), (schemaTypeName === "object" || schemaTypeName === "block") && (isReferenceType(field.type) ? field.type.to.forEach((ref) => dependencies.add(ref.type)) : dependencies.add(field.type)), walkDependencies(field.type, dependencies);
-        }
-      else if ("of" in schemaType)
-        for (const item of schemaType.of)
-          walkDependencies(item, dependencies);
-    }
-  }
-  const dependencyMap = /* @__PURE__ */ new Map();
-  compiledSchema.getTypeNames().forEach((typeName) => {
-    const schemaType = compiledSchema.get(typeName);
-    if (schemaType === void 0 || schemaType.type === null)
-      return;
-    const dependencies = /* @__PURE__ */ new Set();
-    walkDependencies(schemaType, dependencies), dependencyMap.set(schemaType, dependencies), seen.clear();
-  });
-  const typeNames = [], currentlyVisiting = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
-  function visit(type) {
-    if (visited.has(type) || currentlyVisiting.has(type))
-      return;
-    currentlyVisiting.add(type);
-    const deps = dependencyMap.get(type);
-    deps !== void 0 && deps.forEach((dep) => visit(dep)), currentlyVisiting.delete(type), visited.add(type), typeNames.includes(type.name) || typeNames.unshift(type.name);
-  }
-  for (const [type] of dependencyMap)
-    visit(type);
-  return typeNames;
-}
-const HELP_IDS = {
-  TYPE_INVALID: "schema-type-invalid",
-  TYPE_IS_ESM_MODULE: "schema-type-is-esm-module",
-  TYPE_NAME_RESERVED: "schema-type-name-reserved",
-  TYPE_MISSING_NAME: "schema-type-missing-name-or-type",
-  TYPE_MISSING_TYPE: "schema-type-missing-name-or-type",
-  TYPE_TITLE_RECOMMENDED: "schema-type-title-is-recommended",
-  TYPE_TITLE_INVALID: "schema-type-title-is-recommended",
-  OBJECT_FIELDS_INVALID: "schema-object-fields-invalid",
-  OBJECT_FIELD_NOT_UNIQUE: "schema-object-fields-invalid",
-  OBJECT_FIELD_NAME_INVALID: "schema-object-fields-invalid",
-  OBJECT_FIELD_DEFINITION_INVALID_TYPE: "schema-object-fields-invalid",
-  ARRAY_PREDEFINED_CHOICES_INVALID: "schema-predefined-choices-invalid",
-  ARRAY_OF_ARRAY: "schema-array-of-array",
-  ARRAY_OF_INVALID: "schema-array-of-invalid",
-  ARRAY_OF_NOT_UNIQUE: "schema-array-of-invalid",
-  ARRAY_OF_TYPE_GLOBAL_TYPE_CONFLICT: "schema-array-of-type-global-type-conflict",
-  ARRAY_OF_TYPE_BUILTIN_TYPE_CONFLICT: "schema-array-of-type-builtin-type-conflict",
-  REFERENCE_TO_INVALID: "schema-reference-to-invalid",
-  REFERENCE_TO_NOT_UNIQUE: "schema-reference-to-invalid",
-  REFERENCE_INVALID_OPTIONS: "schema-reference-invalid-options",
-  REFERENCE_INVALID_OPTIONS_LOCATION: "schema-reference-options-nesting",
-  REFERENCE_INVALID_FILTER_PARAMS_COMBINATION: "schema-reference-filter-params-combination",
-  SLUG_SLUGIFY_FN_RENAMED: "slug-slugifyfn-renamed",
-  ASSET_METADATA_FIELD_INVALID: "asset-metadata-field-invalid",
-  CROSS_DATASET_REFERENCE_INVALID: "cross-dataset-reference-invalid",
-  GLOBAL_DOCUMENT_REFERENCE_INVALID: "global-document-reference-invalid",
-  DEPRECATED_BLOCKEDITOR_KEY: "schema-deprecated-blockeditor-key",
-  STANDALONE_BLOCK_TYPE: "schema-standalone-block-type"
-};
-function createValidationResult(severity, message, helpId) {
-  if (helpId && !Object.keys(HELP_IDS).some((id) => HELP_IDS[id] === helpId))
-    throw new Error(
-      `Used the unknown helpId "${helpId}", please add it to the array in createValidationResult.js`
-    );
-  return {
-    severity,
-    message,
-    helpId
-  };
-}
-const error = (message, helpId) => createValidationResult("error", message, helpId), warning = (message, helpId) => createValidationResult("warning", message, helpId);
-function groupProblems(types) {
-  return flatten__default.default(types.map((type) => getTypeProblems(type))).filter(
-    (type) => type.problems.length > 0
-  );
-}
-function createTypeWithMembersProblemsAccessor(memberPropertyName, getMembers = (type) => get__default.default(type, memberPropertyName)) {
-  return function(type, parentPath) {
-    const currentPath = [
-      ...parentPath,
-      { kind: "type", type: type.type, name: type.name }
-    ], members = getMembers(type) || [], memberProblems = Array.isArray(members) ? members.map((memberType) => {
-      const propertySegment = {
-        kind: "property",
-        name: memberPropertyName
-      }, memberPath = [...currentPath, propertySegment];
-      return getTypeProblems(memberType, memberPath);
-    }) : [
-      [
-        {
-          path: currentPath,
-          problems: [error(`Member declaration (${memberPropertyName}) is not an array`)]
-        }
-      ]
-    ];
-    return [
-      {
-        path: currentPath,
-        problems: type._problems || []
-      },
-      ...flatten__default.default(memberProblems)
-    ];
-  };
-}
-const arrify = (val) => Array.isArray(val) ? val : typeof val > "u" && [] || [val], getObjectProblems = createTypeWithMembersProblemsAccessor("fields"), getImageProblems = createTypeWithMembersProblemsAccessor("fields"), getFileProblems = createTypeWithMembersProblemsAccessor("fields"), getArrayProblems = createTypeWithMembersProblemsAccessor("of"), getReferenceProblems = createTypeWithMembersProblemsAccessor(
-  "to",
-  (type) => "to" in type ? arrify(type.to) : []
-), getBlockAnnotationProblems = createTypeWithMembersProblemsAccessor("marks.annotations"), getBlockMemberProblems = createTypeWithMembersProblemsAccessor("of"), getBlockProblems = (type, problems) => [
-  ...getBlockAnnotationProblems(type, problems),
-  ...getBlockMemberProblems(type, problems)
-];
-function getDefaultProblems(type, path = []) {
-  return [
-    {
-      path: [...path, { kind: "type", type: type.type, name: type.name }],
-      problems: type._problems || []
-    }
-  ];
-}
-function getTypeProblems(type, path = []) {
-  switch (type.type) {
-    case "object":
-      return getObjectProblems(type, path);
-    case "document":
-      return getObjectProblems(type, path);
-    case "array":
-      return getArrayProblems(type, path);
-    case "reference":
-      return getReferenceProblems(type, path);
-    case "block":
-      return getBlockProblems(type, path);
-    case "image":
-      return getImageProblems(type, path);
-    case "file":
-      return getFileProblems(type, path);
-    default:
-      return getDefaultProblems(type, path);
-  }
-}
-function getDupes(array2, selector = (v) => v) {
-  const dupes = array2.reduce((acc, item) => {
-    const key = selector(item);
-    return acc[key] || (acc[key] = []), acc[key].push(item), acc;
-  }, {});
-  return Object.keys(dupes).map((key) => dupes[key].length > 1 ? dupes[key] : null).filter(Boolean);
-}
-const NOOP_VISITOR = (typeDef) => typeDef, TYPE_TYPE = { name: "type", type: null }, FUTURE_RESERVED = ["any", "time", "date"];
-function traverseSchema(types = [], coreTypes2 = [], visitor = NOOP_VISITOR) {
-  const coreTypesRegistry = /* @__PURE__ */ Object.create(null), registry = /* @__PURE__ */ Object.create(null), coreTypeNames2 = coreTypes2.map((typeDef) => typeDef.name), reservedTypeNames = FUTURE_RESERVED.concat(coreTypeNames2), typeNames = types.map((typeDef) => typeDef && typeDef.name).filter(Boolean);
-  coreTypes2.forEach((coreType) => {
-    coreTypesRegistry[coreType.name] = coreType;
-  }), types.forEach((type, i) => {
-    registry[type && type.name || `__unnamed_${i}`] = {};
-  });
-  function getType(typeName) {
-    return typeName === "type" ? TYPE_TYPE : coreTypesRegistry[typeName] || registry[typeName] || null;
-  }
-  const duplicateNames = uniq__default.default(flatten__default.default(getDupes(typeNames)));
-  function isDuplicate(typeName) {
-    return duplicateNames.includes(typeName);
-  }
-  function getTypeNames() {
-    return typeNames.concat(coreTypeNames2);
-  }
-  function isReserved(typeName) {
-    return typeName === "type" || reservedTypeNames.includes(typeName);
-  }
-  const visitType = (isRoot) => (typeDef, index) => visitor(typeDef, {
-    visit: visitType(!1),
-    isRoot,
-    getType,
-    getTypeNames,
-    isReserved,
-    isDuplicate,
-    index
-  });
-  return coreTypes2.forEach((coreTypeDef) => {
-    Object.assign(coreTypesRegistry[coreTypeDef.name], visitType(coreTypeDef));
-  }), types.forEach((typeDef, i) => {
-    Object.assign(
-      registry[typeDef && typeDef.name || `__unnamed_${i}`],
-      visitType(!0)(typeDef, i)
-    );
-  }), {
-    get(typeName) {
-      const res = registry[typeName] || coreTypesRegistry[typeName];
-      if (res)
-        return res;
-      throw new Error(`No such type: ${typeName}`);
-    },
-    has(typeName) {
-      return typeName in registry || typeName in coreTypesRegistry;
-    },
-    getTypeNames() {
-      return Object.keys(registry);
-    },
-    getTypes() {
-      return this.getTypeNames().map(this.get);
-    },
-    toJSON() {
-      return this.getTypes();
-    }
-  };
-}
-const coreTypes = [
-  { name: "array", jsonType: "array", type: "type" },
-  { name: "block", jsonType: "object", type: "type" },
-  { name: "boolean", jsonType: "boolean", type: "type" },
-  { name: "datetime", jsonType: "string", type: "type" },
-  { name: "date", jsonType: "string", type: "type" },
-  { name: "document", jsonType: "object", type: "type" },
-  { name: "email", jsonType: "string", type: "type" },
-  { name: "file", jsonType: "object", type: "type" },
-  { name: "geopoint", jsonType: "object", type: "type" },
-  { name: "image", jsonType: "object", type: "type" },
-  { name: "number", jsonType: "number", type: "type" },
-  { name: "object", jsonType: "object", type: "type" },
-  { name: "reference", jsonType: "object", type: "type" },
-  { name: "crossDatasetReference", jsonType: "object", type: "type" },
-  { name: "globalDocumentReference", jsonType: "object", type: "type" },
-  { name: "slug", jsonType: "object", type: "type" },
-  { name: "span", jsonType: "object", type: "type" },
-  { name: "string", jsonType: "string", type: "type" },
-  { name: "telephone", jsonType: "string", type: "type" },
-  { name: "text", jsonType: "string", type: "type" },
-  { name: "url", jsonType: "string", type: "type" }
-], coreTypeNames = coreTypes.map((t) => t.name);
-function traverseSanitySchema(schemaTypes, visitor) {
-  return traverseSchema(schemaTypes, coreTypes, visitor);
-}
-function isPrimitiveTypeName(typeName) {
-  return typeName === "string" || typeName === "number" || typeName === "boolean";
-}
-function isAssignable(typeName, type) {
-  return (typeof type.name == "string" ? type.name : type.type) === typeName;
-}
-function quote$2(n) {
-  return `"${n}"`;
-}
-function pluralize(arr, suf = "s") {
-  return arr.length === 1 ? "" : suf;
+function pluralize(arr, suf = "s") {
+  return arr.length === 1 ? "" : suf;
 }
 function format(value) {
-  return Array.isArray(value) ? `array with ${value.length} entries` : typeof value == "object" && value !== null ? `object with keys ${humanizeList__default.default(Object.keys(value).map(quote$2))}` : quote$2(value);
+  return Array.isArray(value) ? `array with ${value.length} entries` : typeof value == "object" && value !== null ? `object with keys ${humanizeList(Object.keys(value).map(quote$2))}` : quote$2(value);
 }
 var array = (typeDef, visitorContext) => {
   const ofIsArray = Array.isArray(typeDef.of);
@@ -1233,7 +1269,7 @@ var array = (typeDef, visitorContext) => {
         _problems: invalid
       };
   }
-  const problems = flatten__default.default([
+  const problems = flatten([
     ofIsArray ? getDupes(typeDef.of, (t) => `${t.name};${t.type}`).map(
       (dupes) => error(
         `Found ${dupes.length} members with same type, but not unique names "${dupes[0].type}" in array. This makes it impossible to tell their values apart and you should consider naming them`,
@@ -1252,7 +1288,7 @@ var array = (typeDef, visitorContext) => {
       HELP_IDS.ARRAY_OF_INVALID
     )
   );
-  const [primitiveTypes, objectTypes] = partition__default.default(
+  const [primitiveTypes, objectTypes] = partition(
     of,
     (ofType) => isPrimitiveTypeName(ofType.type) || isPrimitiveTypeName(visitorContext.getType(ofType.type)?.jsonType)
   ), isMixedArray = primitiveTypes.length > 0 && objectTypes.length > 0;
@@ -1262,9 +1298,9 @@ var array = (typeDef, visitorContext) => {
       error(
         `The array type's 'of' property can't have both object types and primitive types (found primitive type ${pluralize(
           primitiveTypeNames
-        )} ${humanizeList__default.default(primitiveTypeNames.map(quote$2))} and object type${pluralize(
+        )} ${humanizeList(primitiveTypeNames.map(quote$2))} and object type${pluralize(
           objectTypeNames
-        )} ${humanizeList__default.default(objectTypeNames.map(quote$2))})`,
+        )} ${humanizeList(objectTypeNames.map(quote$2))})`,
         HELP_IDS.ARRAY_OF_INVALID
       )
     );
@@ -1273,7 +1309,7 @@ var array = (typeDef, visitorContext) => {
   return !isMixedArray && Array.isArray(list) && (primitiveTypes.length > 0 ? list.forEach((option) => {
     const value = option?.value ?? option;
     if (!primitiveTypes.some((primitiveType) => typeof value === visitorContext.getType(primitiveType.type).jsonType)) {
-      const formattedTypeList = humanizeList__default.default(
+      const formattedTypeList = humanizeList(
         primitiveTypes.map((t) => t.name || t.type),
         { conjunction: "or" }
       );
@@ -1294,7 +1330,7 @@ var array = (typeDef, visitorContext) => {
       error(
         `An invalid entry found in options.list: ${format(
           option
-        )}. Must be an object with "_type" set to ${humanizeList__default.default(
+        )}. Must be an object with "_type" set to ${humanizeList(
           objectTypes.map((t) => t.name || t.type).map((t) => t === "object" ? "undefined" : quote$2(t)),
           { conjunction: "or" }
         )}`,
@@ -1346,12 +1382,12 @@ function validateBlockType(typeDef, visitorContext) {
   );
   return disallowedKeys.length > 0 && problems.push(
     error(
-      `Found unknown properties for block declaration: ${humanizeList__default.default(
+      `Found unknown properties for block declaration: ${humanizeList(
         disallowedKeys.map(quote$1)
       )}`
     )
   ), marks && (marks = validateMarks(typeDef.marks, visitorContext, problems)), styles && (styles = validateStyles(styles, visitorContext, problems)), lists && (lists = validateLists(lists, visitorContext, problems)), members && (members = validateMembers(members, visitorContext, problems)), {
-    ...omit__default.default(typeDef, disallowedKeys),
+    ...omit(typeDef, disallowedKeys),
     marks,
     styles,
     name: typeDef.name || typeDef.type,
@@ -1361,14 +1397,14 @@ function validateBlockType(typeDef, visitorContext) {
 }
 function validateMarks(marks, visitorContext, problems) {
   let decorators = marks.decorators, annotations = marks.annotations;
-  if (!isPlainObject__default.default(marks))
+  if (!isPlainObject(marks))
     return problems.push(error(`"marks" declaration should be an object, got ${getTypeOf(marks)}`)), problems;
   const disallowedMarkKeys = Object.keys(marks).filter(
     (key) => !allowedMarkKeys.includes(key) && !key.startsWith("_")
   );
   return disallowedMarkKeys.length > 0 && problems.push(
     error(
-      `Found unknown properties for block declaration: ${humanizeList__default.default(
+      `Found unknown properties for block declaration: ${humanizeList(
         disallowedMarkKeys.map(quote$1)
       )}`
     )
@@ -1382,7 +1418,7 @@ function validateMarks(marks, visitorContext, problems) {
 }
 function validateLists(lists, visitorContext, problems) {
   return Array.isArray(lists) ? (lists.forEach((list, index) => {
-    if (!isPlainObject__default.default(list)) {
+    if (!isPlainObject(list)) {
       problems.push(error(`List must be an object, got ${getTypeOf(list)}`));
       return;
     }
@@ -1391,7 +1427,7 @@ function validateLists(lists, visitorContext, problems) {
     );
     disallowedKeys.length > 0 && problems.push(
       error(
-        `Found unknown properties for list ${name}: ${humanizeList__default.default(disallowedKeys.map(quote$1))}`
+        `Found unknown properties for list ${name}: ${humanizeList(disallowedKeys.map(quote$1))}`
       )
     ), list.value ? typeof list.value != "string" ? problems.push(
       error(
@@ -1404,7 +1440,7 @@ function validateLists(lists, visitorContext, problems) {
 }
 function validateStyles(styles, visitorContext, problems) {
   return Array.isArray(styles) ? (styles.forEach((style, index) => {
-    if (!isPlainObject__default.default(style)) {
+    if (!isPlainObject(style)) {
       problems.push(error(`Style must be an object, got ${getTypeOf(style)}`));
       return;
     }
@@ -1413,7 +1449,7 @@ function validateStyles(styles, visitorContext, problems) {
     );
     disallowedKeys.length > 0 && problems.push(
       error(
-        `Found unknown properties for style ${name}: ${humanizeList__default.default(disallowedKeys.map(quote$1))}`
+        `Found unknown properties for style ${name}: ${humanizeList(disallowedKeys.map(quote$1))}`
       )
     ), style.value ? typeof style.value != "string" ? problems.push(
       error(
@@ -1431,7 +1467,7 @@ function validateStyles(styles, visitorContext, problems) {
 }
 function validateDecorators(decorators, visitorContext, problems) {
   return decorators.forEach((decorator, index) => {
-    if (!isPlainObject__default.default(decorator)) {
+    if (!isPlainObject(decorator)) {
       problems.push(error(`Annotation must be an object, got ${getTypeOf(decorator)}`));
       return;
     }
@@ -1440,7 +1476,7 @@ function validateDecorators(decorators, visitorContext, problems) {
     );
     disallowedKeys.length > 0 && problems.push(
       error(
-        `Found unknown properties for decorator ${name}: ${humanizeList__default.default(
+        `Found unknown properties for decorator ${name}: ${humanizeList(
           disallowedKeys.map(quote$1)
         )}`
       )
@@ -1460,7 +1496,7 @@ function validateDecorators(decorators, visitorContext, problems) {
 }
 function validateAnnotations(annotations, visitorContext, problems) {
   return annotations.map((annotation) => {
-    if (!isPlainObject__default.default(annotation))
+    if (!isPlainObject(annotation))
       return {
         ...annotation,
         _problems: [error(`Annotation must be an object, got ${getTypeOf(annotation)}`)]
@@ -1537,7 +1573,7 @@ function validateTypeName(typeName, visitorContext) {
       )
     ];
   if (!possibleTypeNames.includes(typeName)) {
-    const suggestions = possibleTypeNames.map((possibleTypeName) => [leven__default.default(typeName, possibleTypeName), possibleTypeName]).filter(([distance]) => distance < 3).map(([_, name]) => name), suggestion = suggestions.length > 0 ? ` Did you mean ${humanizeList__default.default(suggestions.map(quote), { conjunction: "or" })}?` : "";
+    const suggestions = possibleTypeNames.map((possibleTypeName) => [leven(typeName, possibleTypeName), possibleTypeName]).filter(([distance]) => distance < 3).map(([_, name]) => name), suggestion = suggestions.length > 0 ? ` Did you mean ${humanizeList(suggestions.map(quote), { conjunction: "or" })}?` : "";
     return [error(`Unknown type: ${typeName}.${suggestion}`)];
   }
   return [];
@@ -1574,7 +1610,7 @@ function isValidDatasetName(name) {
   return name.length >= 2 && name.toLowerCase() === name && VALID_DATASET.test(name) || `The provided dataset "${name}" doesn't look like a valid dataset. Dataset names must be more than 2 characters, can only contain lowercase characters, numbers, underscores and dashes and can not start with a dash or an underscore`;
 }
 var crossDatasetReference = (typeDef, visitorContext) => {
-  const isValidTo = Array.isArray(typeDef.to) || isPlainObject__default.default(typeDef.to), normalizedTo = normalizeToProp$2(typeDef), problems = flatten__default.default([
+  const isValidTo = Array.isArray(typeDef.to) || isPlainObject(typeDef.to), normalizedTo = normalizeToProp$2(typeDef), problems = flatten([
     isValidTo ? getDupes(normalizedTo, (t) => `${t.name};${t.type}`).map(
       (dupes) => error(
         `Found ${dupes.length} members with same type, but not unique names "${dupes[0].type}" in reference. This makes it impossible to tell their values apart and you should consider naming them`,
@@ -1596,7 +1632,7 @@ var crossDatasetReference = (typeDef, visitorContext) => {
         `The referenced type at index ${index} must be named. Specify the name of the type you want to create references to.`,
         HELP_IDS.CROSS_DATASET_REFERENCE_INVALID
       )
-    ), isPlainObject__default.default(crossDatasetTypeDef.preview) || problems.push(
+    ), isPlainObject(crossDatasetTypeDef.preview) || problems.push(
       error(
         `Missing required preview config for the referenced type "${crossDatasetTypeDef.type || "<unknown type>"}"`,
         HELP_IDS.CROSS_DATASET_REFERENCE_INVALID
@@ -1631,14 +1667,14 @@ function getOptionErrors$2(typeDef) {
         HELP_IDS.REFERENCE_INVALID_OPTIONS_LOCATION
       )
     )
-  ), options ? isPlainObject__default.default(options) ? typeof options.filter == "function" && typeof options.filterParams < "u" ? problems.concat(
+  ), options ? isPlainObject(options) ? typeof options.filter == "function" && typeof options.filterParams < "u" ? problems.concat(
     error(
       "`filterParams` cannot be used if `filter` is a function. Either statically define `filter` as a string, or return `params` from the `filter`-function.",
       HELP_IDS.REFERENCE_INVALID_FILTER_PARAMS_COMBINATION
     )
   ) : typeof options.filter == "function" || !options.filter && !options.filterParams ? problems : typeof options.filter != "string" ? problems.concat(
     error(`If set, \`filter\` must be a string. Got ${typeof options.filter}`)
-  ) : typeof options.filterParams < "u" && !isPlainObject__default.default(options.filterParams) ? problems.concat(error("If set, `filterParams` must be an object.")) : options.filterParams ? problems.concat(
+  ) : typeof options.filterParams < "u" && !isPlainObject(options.filterParams) ? problems.concat(error("If set, `filterParams` must be an object.")) : options.filterParams ? problems.concat(
     Object.keys(options.filterParams).filter((key) => key.startsWith("__") || key.startsWith("$")).map((key) => error(`Filter parameter cannot be prefixed with "$" or "__". Got ${key}".`))
   ) : problems : problems.concat(
     error(
@@ -1658,25 +1694,25 @@ function validateComponent(typeDef) {
   const warnings = [];
   return components.input && !isComponentLike(components.input) && warnings.push(
     warning(
-      `The \`components.input\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect__default.default(
+      `The \`components.input\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect(
         components.input
       )}). If you have imported a custom input component, please verify that you have imported the correct named/default export.`
     )
   ), components.field && !isComponentLike(components.field) && warnings.push(
     warning(
-      `The \`components.field\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect__default.default(
+      `The \`components.field\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect(
         components.field
       )}). If you have imported a custom field component, please verify that you have imported the correct named/default export.`
     )
   ), components.item && !isComponentLike(components.item) && warnings.push(
     warning(
-      `The \`components.item\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect__default.default(
+      `The \`components.item\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect(
         components.item
       )}). If you have imported a custom item component, please verify that you have imported the correct named/default export.`
     )
   ), components.preview && !isComponentLike(components.preview) && warnings.push(
     warning(
-      `The \`components.preview\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect__default.default(
+      `The \`components.preview\` property is set but does not appear to be a valid React component (expected a function, but saw ${inspect(
         components.preview
       )}). If you have imported a custom preview component, please verify that you have imported the correct named/default export.`
     )
@@ -1686,7 +1722,7 @@ const VALID_FIELD_RE = /^[A-Za-z]+[0-9A-Za-z_]*$/, CONVENTIONAL_FIELD_RE = /^[A-
 function validateFieldName(name) {
   return typeof name != "string" ? [
     error(
-      `Field names must be strings. Saw "${inspect__default.default(name)}"`,
+      `Field names must be strings. Saw "${inspect(name)}"`,
       HELP_IDS.OBJECT_FIELD_NAME_INVALID
     )
   ] : name.startsWith("_") ? [
@@ -1709,10 +1745,10 @@ function validateFieldName(name) {
   ];
 }
 function validateField(field, _visitorContext) {
-  if (!isPlainObject__default.default(field))
+  if (!isPlainObject(field))
     return [
       error(
-        `Incorrect type for field definition - should be an object, saw ${inspect__default.default(field)}`,
+        `Incorrect type for field definition - should be an object, saw ${inspect(field)}`,
         HELP_IDS.OBJECT_FIELD_DEFINITION_INVALID_TYPE
       )
     ];
@@ -1758,11 +1794,11 @@ function validateFields(fields, options = { allowEmpty: !1 }) {
   return problems;
 }
 function validatePreview(preview) {
-  return isPlainObject__default.default(preview) ? typeof preview.prepare < "u" && typeof preview.prepare != "function" ? [
+  return isPlainObject(preview) ? typeof preview.prepare < "u" && typeof preview.prepare != "function" ? [
     error(
       `The "preview.prepare" property must be a function, instead saw "${typeof preview.prepare}"`
     )
-  ] : preview.select ? isPlainObject__default.default(preview.select) ? Object.keys(preview.select).reduce((errs, key) => typeof preview.select[key] == "string" ? errs : errs.concat(
+  ] : preview.select ? isPlainObject(preview.select) ? Object.keys(preview.select).reduce((errs, key) => typeof preview.select[key] == "string" ? errs : errs.concat(
     error(
       `The key "${key}" of "preview.select" must be a string, instead saw "${typeof preview.select[key]}"`
     )
@@ -1795,7 +1831,7 @@ var object = (typeDef, visitorContext) => {
   };
 }, documentVisitor = (typeDefinition, visitorContext) => {
   const typeDef = object(typeDefinition, visitorContext), { initialValue, initialValues } = typeDef;
-  return typeof initialValue < "u" && !isPlainObject__default.default(initialValue) && typeof initialValue != "function" && typeDef._problems.push(
+  return typeof initialValue < "u" && !isPlainObject(initialValue) && typeof initialValue != "function" && typeDef._problems.push(
     error('The "initialValue" property must be either a plain object or a function')
   ), typeof initialValues < "u" && typeDef._problems.push(error('Found property "initialValues" - did you mean "initialValue"?')), typeDef;
 }, file = (typeDef, visitorContext) => {
@@ -1830,7 +1866,7 @@ function isValidResourceId(resourceType, resourceId) {
   return resourceId ? resourceType === "dataset" ? resourceId.split(".").length !== 2 ? 'The resource ID for a dataset reference must be on the form "<projectId>.<datasetName>"' : !0 : resourceType === "media-library" ? !0 : `Cannot validate resource ID for resource type: ${resourceType}` : "The resource ID must be a non-empty string";
 }
 var globalDocumentReference = (typeDef, visitorContext) => {
-  const isValidTo = Array.isArray(typeDef.to) || isPlainObject__default.default(typeDef.to), normalizedTo = normalizeToProp$1(typeDef), problems = flatten__default.default([
+  const isValidTo = Array.isArray(typeDef.to) || isPlainObject(typeDef.to), normalizedTo = normalizeToProp$1(typeDef), problems = flatten([
     isValidTo ? getDupes(normalizedTo, (t) => `${t.name};${t.type}`).map(
       (dupes) => error(
         `Found ${dupes.length} members with same type, but not unique names "${dupes[0].type}" in reference. This makes it impossible to tell their values apart and you should consider naming them`,
@@ -1852,7 +1888,7 @@ var globalDocumentReference = (typeDef, visitorContext) => {
         `The referenced type at index ${index} must be named. Specify the name of the type you want to create references to.`,
         HELP_IDS.GLOBAL_DOCUMENT_REFERENCE_INVALID
       )
-    ), isPlainObject__default.default(crossDatasetTypeDef.preview) || problems.push(
+    ), isPlainObject(crossDatasetTypeDef.preview) || problems.push(
       error(
         `Missing required preview config for the referenced type "${crossDatasetTypeDef.type || "<unknown type>"}"`,
         HELP_IDS.GLOBAL_DOCUMENT_REFERENCE_INVALID
@@ -1897,14 +1933,14 @@ function getOptionErrors$1(typeDef) {
         HELP_IDS.REFERENCE_INVALID_OPTIONS_LOCATION
       )
     )
-  ), options ? isPlainObject__default.default(options) ? typeof options.filter == "function" && typeof options.filterParams < "u" ? problems.concat(
+  ), options ? isPlainObject(options) ? typeof options.filter == "function" && typeof options.filterParams < "u" ? problems.concat(
     error(
       "`filterParams` cannot be used if `filter` is a function. Either statically define `filter` as a string, or return `params` from the `filter`-function.",
       HELP_IDS.REFERENCE_INVALID_FILTER_PARAMS_COMBINATION
     )
   ) : typeof options.filter == "function" || !options.filter && !options.filterParams ? problems : typeof options.filter != "string" ? problems.concat(
     error(`If set, \`filter\` must be a string. Got ${typeof options.filter}`)
-  ) : typeof options.filterParams < "u" && !isPlainObject__default.default(options.filterParams) ? problems.concat(error("If set, `filterParams` must be an object.")) : options.filterParams ? problems.concat(
+  ) : typeof options.filterParams < "u" && !isPlainObject(options.filterParams) ? problems.concat(error("If set, `filterParams` must be an object.")) : options.filterParams ? problems.concat(
     Object.keys(options.filterParams).filter((key) => key.startsWith("__") || key.startsWith("$")).map((key) => error(`Filter parameter cannot be prefixed with "$" or "__". Got ${key}".`))
   ) : problems : problems.concat(
     error(
@@ -1949,138 +1985,842 @@ var image = (typeDef, visitorContext) => {
     }),
     _problems: problems
   };
-};
-function normalizeToProp(typeDef) {
-  return Array.isArray(typeDef.to) ? typeDef.to : typeDef.to ? [typeDef.to] : typeDef.to;
+};
+function normalizeToProp(typeDef) {
+  return Array.isArray(typeDef.to) ? typeDef.to : typeDef.to ? [typeDef.to] : typeDef.to;
+}
+var reference = (typeDef, visitorContext) => {
+  const isValidTo = Array.isArray(typeDef.to) || isPlainObject(typeDef.to), normalizedTo = normalizeToProp(typeDef), problems = flatten([
+    isValidTo ? getDupes(normalizedTo, (t) => `${t.name};${t.type}`).map(
+      (dupes) => error(
+        `Found ${dupes.length} members with same type, but not unique names "${dupes[0].type}" in reference. This makes it impossible to tell their values apart and you should consider naming them`,
+        HELP_IDS.REFERENCE_TO_INVALID
+      )
+    ) : error(
+      'The reference type is missing or having an invalid value for the required "to" property. It should be an array of accepted types.',
+      HELP_IDS.REFERENCE_TO_INVALID
+    )
+  ]);
+  return isValidTo && normalizedTo.length === 0 && problems.push(
+    error(
+      'The reference type should define at least one accepted type. Please check the "to" property.',
+      HELP_IDS.REFERENCE_TO_INVALID
+    )
+  ), problems.push(...getOptionErrors(typeDef)), {
+    ...typeDef,
+    to: (isValidTo ? normalizedTo : []).map(visitorContext.visit),
+    _problems: problems
+  };
+};
+function getOptionErrors(typeDef) {
+  const { options } = typeDef, problems = [];
+  return problems.push(
+    ...["filter", "filterParams"].filter((key) => key in typeDef).map(
+      (key) => error(
+        `\`${key}\` is not allowed on a reference type definition - did you mean \`options.${key}\`?`,
+        HELP_IDS.REFERENCE_INVALID_OPTIONS_LOCATION
+      )
+    )
+  ), options ? isPlainObject(options) ? typeof options.filter == "function" && typeof options.filterParams < "u" ? problems.concat(
+    error(
+      "`filterParams` cannot be used if `filter` is a function. Either statically define `filter` as a string, or return `params` from the `filter`-function.",
+      HELP_IDS.REFERENCE_INVALID_FILTER_PARAMS_COMBINATION
+    )
+  ) : typeof options.filter == "function" || !options.filter && !options.filterParams ? problems : typeof options.filter != "string" ? problems.concat(
+    error(`If set, \`filter\` must be a string. Got ${typeof options.filter}`)
+  ) : typeof options.filterParams < "u" && !isPlainObject(options.filterParams) ? problems.concat(error("If set, `filterParams` must be an object.")) : options.filterParams ? problems.concat(
+    Object.keys(options.filterParams).filter((key) => key.startsWith("__") || key.startsWith("$")).map((key) => error(`Filter parameter cannot be prefixed with "$" or "__". Got ${key}".`))
+  ) : problems : problems.concat(
+    error(
+      "The reference type expects `options` to be an object",
+      HELP_IDS.REFERENCE_INVALID_OPTIONS
+    )
+  ) : problems;
+}
+var rootType = (typeDef, visitorContext) => {
+  const hasName = !!typeDef.name;
+  if (!hasName && Object.keys(typeDef).length === 1)
+    return {
+      ...typeDef,
+      _problems: [
+        error(
+          "Invalid/undefined type declaration, check declaration or the import/export of the schema type.",
+          HELP_IDS.TYPE_INVALID
+        )
+      ]
+    };
+  const problems = [];
+  return looksLikeEsmModule(typeDef) ? problems.push(
+    error(
+      "Type appears to be an ES6 module imported through CommonJS require - use an import statement or access the `.default` property",
+      HELP_IDS.TYPE_IS_ESM_MODULE
+    )
+  ) : hasName ? visitorContext.isReserved(typeDef.name) && problems.push(
+    error(
+      `Invalid type name: "${typeDef.name}" is a reserved name.`,
+      HELP_IDS.TYPE_NAME_RESERVED
+    )
+  ) : problems.push(error("Missing type name", HELP_IDS.TYPE_MISSING_NAME)), visitorContext.isDuplicate(typeDef.name) && problems.push(
+    error(
+      `Invalid type name: A type with name "${typeDef.name}" is already defined in the schema.`
+    )
+  ), problems.push(...validateComponent(typeDef)), "title" in typeDef && typeof typeDef.title != "string" && problems.push(warning("Type title is not a string.", HELP_IDS.TYPE_TITLE_INVALID)), {
+    ...typeDef,
+    _problems: problems
+  };
+};
+function looksLikeEsmModule(typeDef) {
+  return !typeDef.name && typeDef.default && (typeDef.default.name || typeDef.default.title);
+}
+var slug = (typeDef, visitorContext) => {
+  const problems = [];
+  return typeDef.options && typeDef.options.slugifyFn && (problems.push(
+    warning(
+      'Heads up! The "slugifyFn" option has been renamed to "slugify".',
+      HELP_IDS.SLUG_SLUGIFY_FN_RENAMED
+    )
+  ), typeDef.options.slugify = typeDef.options.slugifyFn), {
+    ...typeDef,
+    _problems: problems
+  };
+};
+const typeVisitors = {
+  array,
+  object,
+  slug,
+  file,
+  image,
+  block: validateBlockType,
+  document: documentVisitor,
+  reference,
+  crossDatasetReference,
+  globalDocumentReference
+}, getNoopVisitor = (visitorContext) => (schemaDef) => ({
+  name: `<unnamed_type_@_index_${visitorContext.index}>`,
+  ...schemaDef,
+  _problems: []
+});
+function combine(...visitors) {
+  return (schemaType, visitorContext) => visitors.reduce(
+    (result, visitor) => {
+      const res = visitor(result, visitorContext);
+      return {
+        ...res,
+        _problems: result._problems.concat(res._problems)
+      };
+    },
+    { _problems: [], ...schemaType }
+  );
+}
+function validateSchema(schemaTypes, {
+  transformTypeVisitors = (visitors) => visitors,
+  transformCommonVisitors = (visitors) => visitors
+} = {}) {
+  return traverseSanitySchema(schemaTypes, (schemaDef, visitorContext) => {
+    const typeVisitor = schemaDef && schemaDef.type && transformTypeVisitors(typeVisitors)[schemaDef.type] || getNoopVisitor(visitorContext), commonVisitors = transformCommonVisitors([common]);
+    return visitorContext.isRoot ? combine(rootType, ...commonVisitors, typeVisitor)(schemaDef, visitorContext) : combine(...commonVisitors, typeVisitor)(schemaDef, visitorContext);
+  });
+}
+class ValidationError extends Error {
+  problems;
+  constructor(problems) {
+    super("ValidationError"), this.problems = problems, this.name = "ValidationError";
+  }
+}
+const builtinSchema = Schema.compile({
+  name: "studio",
+  types: builtinTypes
+});
+function createSchemaFromManifestTypes(schemaDef) {
+  const validated = validateSchema(schemaDef.types).getTypes(), problems = groupProblems(validated).filter(
+    (group) => group.problems.some((problem) => problem.severity === "error")
+  );
+  if (problems.length > 0)
+    throw new ValidationError(problems);
+  return Schema.compile({
+    name: schemaDef.name,
+    types: schemaDef.types.map(coerceType).filter(Boolean),
+    parent: builtinSchema
+  });
+}
+function coerceType(obj) {
+  if (!isObject(obj)) return;
+  const typ = cloneDeep(obj);
+  return traverse(typ), typ;
+}
+function traverse(obj) {
+  if (isObject(obj)) {
+    if (Array.isArray(obj)) {
+      obj.forEach(traverse);
+      return;
+    }
+    for (const v of Object.values(obj))
+      traverse(v);
+    coerceValidation(obj);
+  }
+}
+function coerceValidation(val) {
+  if (!isObject(val) || !("validation" in val)) return;
+  const manifestValidation = Array.isArray(val.validation) ? val.validation : [val.validation];
+  val.validation = manifestValidation.map((group) => {
+    if (isObject(group))
+      return (baseRule) => {
+        let rule = baseRule;
+        const level = "level" in group ? group.level : void 0, rules = "rules" in group ? group.rules : void 0, message = "message" in group ? group.message : void 0;
+        if (!(!rules || !Array.isArray(rules))) {
+          isValidLevel(level) && (message === void 0 || typeof message == "string") && (rule = rule[level](message));
+          for (const ruleSpec of rules)
+            rule = applyRuleSpec(rule, ruleSpec);
+          return rule;
+        }
+      };
+  }).filter(Boolean);
+}
+function coerceConstraintRule(val) {
+  if (isObject(val))
+    return Array.isArray(val) ? val.map(coerceConstraintRule).filter(Boolean) : (baseRule) => {
+      let rule = baseRule;
+      const rules = "_rules" in val ? val._rules : void 0, level = "_level" in val ? val._level : void 0, message = "_message" in val ? val._message : void 0;
+      if (!(!rules || !Array.isArray(rules))) {
+        typeof level == "string" && (rule = rule[level](message));
+        for (const ruleSpec of rules)
+          rule = applyRuleSpec(rule, ruleSpec);
+        return rule;
+      }
+    };
+}
+function applyRuleSpec(rule, ruleSpec) {
+  if (!ruleSpec || typeof ruleSpec != "object")
+    return rule;
+  const flag = "flag" in ruleSpec ? ruleSpec.flag : void 0, constraint = "constraint" in ruleSpec ? ruleSpec.constraint : void 0;
+  switch (flag) {
+    case "presence":
+      if (constraint === "required")
+        return rule.required();
+      if (constraint === "optional")
+        return rule.optional();
+      break;
+    case "type":
+      if (typeof constraint == "string")
+        return rule.type(constraint);
+      break;
+    case "min":
+      if (typeof constraint == "number" || typeof constraint == "string")
+        return rule.min(constraint);
+      break;
+    case "max":
+      if (typeof constraint == "number" || typeof constraint == "string")
+        return rule.max(constraint);
+      break;
+    case "length":
+      if (typeof constraint == "number")
+        return rule.length(constraint);
+      break;
+    case "integer":
+      return rule.integer();
+    case "email":
+      return rule.email();
+    case "unique":
+      return rule.unique();
+    case "reference":
+      return rule.reference();
+    case "precision":
+      if (typeof constraint == "number")
+        return rule.precision(constraint);
+      break;
+    case "positive":
+      return rule.positive();
+    case "negative":
+      return rule.negative();
+    case "greaterThan":
+      if (typeof constraint == "number")
+        return rule.greaterThan(constraint);
+      break;
+    case "lessThan":
+      if (typeof constraint == "number")
+        return rule.lessThan(constraint);
+      break;
+    case "stringCasing":
+      if (constraint === "uppercase")
+        return rule.uppercase();
+      if (constraint === "lowercase")
+        return rule.lowercase();
+      break;
+    case "valid":
+      if (Array.isArray(constraint))
+        return rule.valid(constraint);
+      break;
+    case "regex":
+      if (isObject(constraint) && "pattern" in constraint && (typeof constraint.pattern == "string" || constraint.pattern instanceof RegExp)) {
+        const options = {};
+        "name" in constraint && typeof constraint.name == "string" && (options.name = constraint.name), "invert" in constraint && (options.invert = constraint.invert);
+        const pattern = typeof constraint.pattern == "string" ? stringToRegExp(constraint.pattern) : constraint.pattern;
+        return rule.regex(pattern, options);
+      }
+      break;
+    case "uri":
+      if (isObject(constraint) && "options" in constraint)
+        return rule.uri(constraint.options);
+      break;
+    case "assetRequired":
+      return rule.assetRequired();
+    case "all":
+      return rule.all(coerceConstraintRule(constraint));
+    case "either":
+      return rule.either(coerceConstraintRule(constraint));
+    case "custom":
+      if (constraint === void 0) return rule.custom(() => !0);
+      if (typeof constraint == "function") return rule.custom(constraint);
+      break;
+    case "media":
+      if (constraint === void 0) return rule.media(() => !0);
+      if (typeof constraint == "function") return rule.media(constraint);
+      break;
+  }
+  return rule;
+}
+const isValidLevel = (level) => !!level && typeof level == "string" && ["error", "warning", "info"].includes(level);
+function stringToRegExp(str) {
+  const match = str.match(/^\/(.*)\/([gimuy]*)$/);
+  return match ? new RegExp(match[1], match[2]) : new RegExp(str);
+}
+const documentDefaultFields = (typeName) => ({
+  _id: {
+    type: "objectAttribute",
+    value: { type: "string" }
+  },
+  _type: {
+    type: "objectAttribute",
+    value: { type: "string", value: typeName }
+  },
+  _createdAt: {
+    type: "objectAttribute",
+    value: { type: "string" }
+  },
+  _updatedAt: {
+    type: "objectAttribute",
+    value: { type: "string" }
+  },
+  _rev: {
+    type: "objectAttribute",
+    value: { type: "string" }
+  }
+}), typesMap = /* @__PURE__ */ new Map([
+  ["text", { type: "string" }],
+  ["url", { type: "string" }],
+  ["datetime", { type: "string" }],
+  ["date", { type: "string" }],
+  ["boolean", { type: "boolean" }],
+  ["email", { type: "string" }]
+]);
+function extractSchema(schemaDef, extractOptions = {}) {
+  const inlineFields = /* @__PURE__ */ new Set(), documentTypes = /* @__PURE__ */ new Map(), schema = [], generatedTypes = /* @__PURE__ */ new Map(), { sortedSchemaTypeNames, repeated } = sortByDependencies(schemaDef);
+  repeated.forEach((key, objectField) => {
+    const base = convertSchemaType(objectField.type);
+    if (base !== null) {
+      if (base.type === "inline") {
+        repeated.delete(objectField);
+        return;
+      }
+      if (base.type === "unknown") {
+        repeated.delete(objectField);
+        return;
+      }
+      schema.push({
+        type: "type",
+        name: getGeneratedTypeName(key),
+        value: base
+      });
+    }
+  }), sortedSchemaTypeNames.forEach((typeName) => {
+    const schemaType = schemaDef.get(typeName);
+    if (schemaType === void 0)
+      return;
+    const base = convertBaseType(schemaType);
+    base !== null && (base.type === "type" && inlineFields.add(schemaType), base.type === "document" && documentTypes.set(typeName, base), schema.push(base));
+  });
+  function getGeneratedTypeName(typeName, suffix = "") {
+    const name = generatedTypes.get(typeName);
+    if (name) return name;
+    for (let i = 0; i < 5; i++) {
+      const uniqueName = `${typeName}${suffix}${i || ""}`;
+      if (!sortedSchemaTypeNames.includes(uniqueName))
+        return generatedTypes.set(typeName, uniqueName), uniqueName;
+    }
+    throw new Error(`Unable to generate unique type name for ${typeName}.`);
+  }
+  function convertBaseType(schemaType) {
+    let typeName;
+    if (schemaType.type ? typeName = schemaType.type.name : "jsonType" in schemaType && (typeName = schemaType.jsonType), typeName === "document" && isObjectType(schemaType)) {
+      const defaultAttributes = documentDefaultFields(schemaType.name), object2 = createObject(schemaType);
+      return object2.type === "unknown" ? null : {
+        name: schemaType.name,
+        type: "document",
+        attributes: {
+          ...defaultAttributes,
+          ...object2.attributes
+        }
+      };
+    }
+    const value = convertSchemaType(schemaType);
+    return value.type === "unknown" ? null : value.type === "object" ? (value.attributes = {
+      _type: {
+        type: "objectAttribute",
+        value: {
+          type: "string",
+          value: schemaType.name
+        }
+      },
+      ...value.attributes
+    }, {
+      name: schemaType.name,
+      type: "type",
+      value
+    }) : {
+      name: schemaType.name,
+      type: "type",
+      value
+    };
+  }
+  function convertSchemaType(schemaType) {
+    if (inlineFields.has(schemaType.type))
+      return { type: "inline", name: schemaType.type.name };
+    if (schemaType.type?.name && sortedSchemaTypeNames.indexOf(schemaType.type?.name) > -1)
+      return { type: "inline", name: schemaType.type?.name };
+    if (isStringType(schemaType))
+      return createStringTypeNodeDefintion(schemaType);
+    if (isNumberType(schemaType))
+      return createNumberTypeNodeDefintion(schemaType);
+    if (schemaType.type && typesMap.has(schemaType.type.name))
+      return typesMap.get(schemaType.type.name);
+    if (isCrossDatasetReferenceType(schemaType))
+      return { type: "unknown" };
+    if (isGlobalDocumentReferenceType(schemaType))
+      return { type: "unknown" };
+    if (isReferenceType(schemaType))
+      return createReferenceTypeNodeDefintion(schemaType);
+    if (isArrayType(schemaType))
+      return createArray(schemaType);
+    if (isObjectType(schemaType))
+      return createObject(schemaType);
+    if (lastType(schemaType)?.name === "document") {
+      const doc = documentTypes.get(schemaType.name);
+      return doc === void 0 ? { type: "unknown" } : { type: "object", attributes: doc?.attributes };
+    }
+    throw new Error(`Type "${schemaType.name}" not found`);
+  }
+  function createObject(schemaType) {
+    const attributes = {}, fields = gatherFields(schemaType);
+    for (const field of fields) {
+      const fieldIsRequired = isFieldRequired(field?.type?.validation);
+      let value;
+      const hoisted = repeated.get(field), isTopLevelSchemaType = sortedSchemaTypeNames.includes(field.type.name);
+      if (hoisted && !isTopLevelSchemaType)
+        value = {
+          type: "inline",
+          name: getGeneratedTypeName(hoisted)
+        };
+      else {
+        if (value = convertSchemaType(field.type), value === null)
+          continue;
+        hasAssetRequired(field?.type?.validation) && value.type === "object" && (value.attributes.asset.optional = !1);
+      }
+      const optional = extractOptions.enforceRequiredFields ? fieldIsRequired === !1 : !0;
+      attributes[field.name] = {
+        type: "objectAttribute",
+        value,
+        optional
+      };
+    }
+    return extractOptions.enforceRequiredFields && hasAssetRequired(schemaType.validation) && attributes.asset && (attributes.asset.optional = !1), Object.keys(attributes).length === 0 ? { type: "unknown" } : (schemaType.type?.name !== "document" && schemaType.name !== "object" && (attributes._type = {
+      type: "objectAttribute",
+      value: {
+        type: "string",
+        value: schemaType.name
+      }
+    }), {
+      type: "object",
+      attributes
+    });
+  }
+  function createArray(arraySchemaType) {
+    const of = [];
+    for (const item of arraySchemaType.of) {
+      const field = convertSchemaType(item);
+      field.type === "inline" ? of.push({
+        type: "object",
+        attributes: {
+          _key: createKeyField()
+        },
+        rest: field
+      }) : (field.type === "object" && (field.rest = {
+        type: "object",
+        attributes: {
+          _key: createKeyField()
+        }
+      }), of.push(field));
+    }
+    return of.length === 0 ? { type: "null" } : {
+      type: "array",
+      of: of.length > 1 ? {
+        type: "union",
+        of
+      } : of[0]
+    };
+  }
+  function createReferenceTypeNodeDefintion(reference2) {
+    const references = gatherReferenceNames(reference2);
+    for (const name of references)
+      generatedTypes.has(name) || schema.push({
+        type: "type",
+        name: getGeneratedTypeName(name, ".reference"),
+        value: createReferenceTypeNode(name)
+      });
+    return references.length === 1 ? { type: "inline", name: getGeneratedTypeName(references[0], ".reference") } : {
+      type: "union",
+      of: references.map((name) => ({
+        type: "inline",
+        name: getGeneratedTypeName(name, ".reference")
+      }))
+    };
+  }
+  return schema;
+}
+function createKeyField() {
+  return {
+    type: "objectAttribute",
+    value: {
+      type: "string"
+    }
+  };
+}
+function isFieldRequired(validation) {
+  if (!validation)
+    return !1;
+  const rules = Array.isArray(validation) ? validation : [validation];
+  for (const rule of rules) {
+    let required = !1;
+    const proxy = new Proxy(
+      {},
+      {
+        get: (target, methodName) => () => (methodName === "required" && (required = !0), proxy)
+      }
+    );
+    if (typeof rule == "function" && (rule(proxy), required) || typeof rule == "object" && rule !== null && "_required" in rule && rule._required === "required")
+      return !0;
+  }
+  return !1;
+}
+function hasAssetRequired(validation) {
+  if (!validation)
+    return !1;
+  const rules = Array.isArray(validation) ? validation : [validation];
+  for (const rule of rules) {
+    let assetRequired = !1;
+    const proxy = new Proxy(
+      {},
+      {
+        get: (target, methodName) => () => (methodName === "assetRequired" && (assetRequired = !0), proxy)
+      }
+    );
+    if (typeof rule == "function" && (rule(proxy), assetRequired) || typeof rule == "object" && rule !== null && "_rules" in rule && Array.isArray(rule._rules) && rule._rules.some((r) => r.flag === "assetRequired"))
+      return !0;
+  }
+  return !1;
+}
+function isObjectType(typeDef) {
+  return isType(typeDef, "object") || typeDef.jsonType === "object" || "fields" in typeDef;
+}
+function isArrayType(typeDef) {
+  return isType(typeDef, "array");
+}
+function isReferenceType(typeDef) {
+  return isType(typeDef, "reference");
+}
+function isCrossDatasetReferenceType(typeDef) {
+  return isType(typeDef, "crossDatasetReference");
+}
+function isGlobalDocumentReferenceType(typeDef) {
+  return isType(typeDef, "globalDocumentReference");
+}
+function isStringType(typeDef) {
+  return isType(typeDef, "string");
+}
+function isNumberType(typeDef) {
+  return isType(typeDef, "number");
+}
+function createStringTypeNodeDefintion(stringSchemaType) {
+  const listOptions = stringSchemaType.options?.list;
+  return listOptions && Array.isArray(listOptions) ? {
+    type: "union",
+    of: listOptions.map((v) => ({
+      type: "string",
+      value: typeof v == "string" ? v : v.value
+    }))
+  } : {
+    type: "string"
+  };
 }
-var reference = (typeDef, visitorContext) => {
-  const isValidTo = Array.isArray(typeDef.to) || isPlainObject__default.default(typeDef.to), normalizedTo = normalizeToProp(typeDef), problems = flatten__default.default([
-    isValidTo ? getDupes(normalizedTo, (t) => `${t.name};${t.type}`).map(
-      (dupes) => error(
-        `Found ${dupes.length} members with same type, but not unique names "${dupes[0].type}" in reference. This makes it impossible to tell their values apart and you should consider naming them`,
-        HELP_IDS.REFERENCE_TO_INVALID
-      )
-    ) : error(
-      'The reference type is missing or having an invalid value for the required "to" property. It should be an array of accepted types.',
-      HELP_IDS.REFERENCE_TO_INVALID
-    )
-  ]);
-  return isValidTo && normalizedTo.length === 0 && problems.push(
-    error(
-      'The reference type should define at least one accepted type. Please check the "to" property.',
-      HELP_IDS.REFERENCE_TO_INVALID
-    )
-  ), problems.push(...getOptionErrors(typeDef)), {
-    ...typeDef,
-    to: (isValidTo ? normalizedTo : []).map(visitorContext.visit),
-    _problems: problems
+function createNumberTypeNodeDefintion(numberSchemaType) {
+  const listOptions = numberSchemaType.options?.list;
+  return listOptions && Array.isArray(listOptions) ? {
+    type: "union",
+    of: listOptions.map((v) => ({
+      type: "number",
+      value: typeof v == "number" ? v : v.value
+    }))
+  } : {
+    type: "number"
   };
-};
-function getOptionErrors(typeDef) {
-  const { options } = typeDef, problems = [];
-  return problems.push(
-    ...["filter", "filterParams"].filter((key) => key in typeDef).map(
-      (key) => error(
-        `\`${key}\` is not allowed on a reference type definition - did you mean \`options.${key}\`?`,
-        HELP_IDS.REFERENCE_INVALID_OPTIONS_LOCATION
-      )
-    )
-  ), options ? isPlainObject__default.default(options) ? typeof options.filter == "function" && typeof options.filterParams < "u" ? problems.concat(
-    error(
-      "`filterParams` cannot be used if `filter` is a function. Either statically define `filter` as a string, or return `params` from the `filter`-function.",
-      HELP_IDS.REFERENCE_INVALID_FILTER_PARAMS_COMBINATION
-    )
-  ) : typeof options.filter == "function" || !options.filter && !options.filterParams ? problems : typeof options.filter != "string" ? problems.concat(
-    error(`If set, \`filter\` must be a string. Got ${typeof options.filter}`)
-  ) : typeof options.filterParams < "u" && !isPlainObject__default.default(options.filterParams) ? problems.concat(error("If set, `filterParams` must be an object.")) : options.filterParams ? problems.concat(
-    Object.keys(options.filterParams).filter((key) => key.startsWith("__") || key.startsWith("$")).map((key) => error(`Filter parameter cannot be prefixed with "$" or "__". Got ${key}".`))
-  ) : problems : problems.concat(
-    error(
-      "The reference type expects `options` to be an object",
-      HELP_IDS.REFERENCE_INVALID_OPTIONS
-    )
-  ) : problems;
 }
-var rootType = (typeDef, visitorContext) => {
-  const hasName = !!typeDef.name;
-  if (!hasName && Object.keys(typeDef).length === 1)
-    return {
-      ...typeDef,
-      _problems: [
-        error(
-          "Invalid/undefined type declaration, check declaration or the import/export of the schema type.",
-          HELP_IDS.TYPE_INVALID
-        )
-      ]
-    };
+function gatherReferenceNames(type) {
+  const allReferences = gatherReferenceTypes(type);
+  return [...new Set(allReferences.map((ref) => ref.name))];
+}
+function gatherReferenceTypes(type) {
+  const refTo = "to" in type ? type.to : [];
+  return "type" in type && isReferenceType(type.type) ? [...gatherReferenceTypes(type.type), ...refTo] : refTo;
+}
+function gatherFields(type) {
+  return "fields" in type ? type.type ? gatherFields(type.type).concat(type.fields) : type.fields : [];
+}
+function isType(typeDef, typeName) {
+  let type = typeDef;
+  for (; type; ) {
+    if (type.name === typeName || type.type && type.type.name === typeName)
+      return !0;
+    type = type.type;
+  }
+  return !1;
+}
+function lastType(typeDef) {
+  let type = typeDef;
+  for (; type; ) {
+    if (!type.type)
+      return type;
+    type = type.type;
+  }
+}
+function sortByDependencies(compiledSchema) {
+  const seen = /* @__PURE__ */ new Set(), objectMap = /* @__PURE__ */ new Set(), repeated = /* @__PURE__ */ new Map(), repeatedNames = /* @__PURE__ */ new Set();
+  function pickRepeatedName(path) {
+    for (let idx = path.length - 1; idx >= 0; idx--) {
+      const name = path.slice(idx).join(".");
+      if (!repeatedNames.has(name))
+        return repeatedNames.add(name), name;
+    }
+    throw new Error(`Unable to pick repeated name: ${path.join(".")}`);
+  }
+  function walkDependencies(schemaType, dependencies, path, hoistRepetitions = !0) {
+    if (!seen.has(schemaType)) {
+      if (seen.add(schemaType), "fields" in schemaType)
+        for (const field of gatherFields(schemaType)) {
+          const last = lastType(field.type);
+          if (last.name === "document") {
+            dependencies.add(last);
+            continue;
+          }
+          let schemaTypeName;
+          if (schemaType.type.type ? schemaTypeName = field.type.type.name : "jsonType" in schemaType.type && (schemaTypeName = field.type.jsonType), schemaTypeName === "object" || schemaTypeName === "block") {
+            if (isReferenceType(field.type))
+              field.type.to.forEach((ref) => dependencies.add(ref.type));
+            else if (dependencies.add(field.type), hoistRepetitions && !validSchemaNames.has(field.type.name)) {
+              const fieldPath = path.concat([field.name]);
+              !repeated.has(field) && objectMap.has(field) && repeated.set(field, pickRepeatedName(fieldPath)), objectMap.add(field);
+            }
+          } else field.type && dependencies.add(field.type);
+          walkDependencies(field.type, dependencies, path.concat([field.name]));
+        }
+      else if ("of" in schemaType)
+        for (const item of schemaType.of)
+          walkDependencies(item, dependencies, path.concat(item.name), !isReferenceType(schemaType));
+    }
+  }
+  const dependencyMap = /* @__PURE__ */ new Map(), schemaTypeNames = compiledSchema.getTypeNames(), validSchemaNames = /* @__PURE__ */ new Set();
+  schemaTypeNames.forEach((typeName) => {
+    const schemaType = compiledSchema.get(typeName);
+    if (schemaType === void 0 || schemaType.type === null)
+      return;
+    validSchemaNames.add(typeName);
+    const dependencies = /* @__PURE__ */ new Set();
+    walkDependencies(schemaType, dependencies, [typeName]), dependencyMap.set(schemaType, dependencies), seen.clear();
+  });
+  const typeNames = [], currentlyVisiting = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set();
+  function visit(type) {
+    if (visited.has(type) || currentlyVisiting.has(type))
+      return;
+    currentlyVisiting.add(type);
+    const deps = dependencyMap.get(type);
+    deps !== void 0 && deps.forEach((dep) => visit(dep)), currentlyVisiting.delete(type), visited.add(type), typeNames.includes(type.name) && typeNames.splice(typeNames.indexOf(type.name), 1), typeNames.unshift(type.name);
+  }
+  for (const [type] of dependencyMap)
+    visit(type);
+  return {
+    sortedSchemaTypeNames: typeNames.filter((typeName) => validSchemaNames.has(typeName)),
+    repeated
+  };
+}
+function validateNoCallbacks(typeDef) {
   const problems = [];
-  return looksLikeEsmModule(typeDef) ? problems.push(
-    error(
-      "Type appears to be an ES6 module imported through CommonJS require - use an import statement or access the `.default` property",
-      HELP_IDS.TYPE_IS_ESM_MODULE
-    )
-  ) : hasName ? visitorContext.isReserved(typeDef.name) && problems.push(
+  return problems.push(...validateConditionalProperties(typeDef)), problems.push(...validateValueProperties(typeDef)), problems.push(...validateComponents(typeDef)), problems.push(...validateOptions(typeDef)), problems.push(...validateFieldsetsAndGroups(typeDef)), problems.push(...validateBlockSpecific(typeDef)), problems;
+}
+function validateConditionalProperties(typeDef) {
+  const problems = [];
+  return typeof typeDef.hidden == "function" && problems.push(
+    error('The "hidden" property cannot be a function. Use a static boolean value instead.')
+  ), typeof typeDef.readOnly == "function" && problems.push(
+    error('The "readOnly" property cannot be a function. Use a static boolean value instead.')
+  ), problems;
+}
+function validateValueProperties(typeDef) {
+  const problems = [];
+  return typeof typeDef.initialValue == "function" && problems.push(
+    error('The "initialValue" property cannot be a function. Use a static value instead.')
+  ), typeof typeDef.validation == "function" && problems.push(
+    error('The "validation" property cannot be a function. Use static validation rules instead.')
+  ), typeDef.validation && typeof typeDef.validation == "object" && checkForCustomValidators(typeDef.validation) && problems.push(
+    error("Custom validation functions are not supported. Use only built-in validation rules.")
+  ), typeDef.preview?.prepare && typeof typeDef.preview.prepare == "function" && problems.push(error('The "preview.prepare" property cannot be a function.')), typeDef.blockEditor?.render && problems.push(error('The "blockEditor.render" property cannot be a function.')), problems;
+}
+function validateComponents(typeDef) {
+  const problems = [];
+  if (!typeDef.components)
+    return problems;
+  const componentProps = [
+    "input",
+    "field",
+    "item",
+    "preview",
+    "diff",
+    "block",
+    "inlineBlock",
+    "annotation"
+  ];
+  for (const prop of componentProps)
+    typeDef.components[prop] && isComponentLike(typeDef.components[prop]) && problems.push(error(`The "components.${prop}" property cannot be a component function.`));
+  return typeDef.components.portableText?.plugins && problems.push(
+    error('The "components.portableText.plugins" property cannot contain plugin functions.')
+  ), problems;
+}
+function validateOptions(typeDef) {
+  const problems = [];
+  return !typeDef.options || typeof typeDef.options != "object" || (problems.push(...validateCommonOptions(typeDef.options)), problems.push(...validateAssetSources(typeDef.options)), problems.push(...validateOtherFunctionOptions(typeDef.options))), problems;
+}
+function validateCommonOptions(options) {
+  const problems = [];
+  return typeof options.filter == "function" && problems.push(
     error(
-      `Invalid type name: "${typeDef.name}" is a reserved name.`,
-      HELP_IDS.TYPE_NAME_RESERVED
+      'The "options.filter" property cannot be a function. Use a static GROQ filter string with filterParams instead.'
     )
-  ) : problems.push(error("Missing type name", HELP_IDS.TYPE_MISSING_NAME)), visitorContext.isDuplicate(typeDef.name) && problems.push(
+  ), typeof options.source == "function" && problems.push(
     error(
-      `Invalid type name: A type with name "${typeDef.name}" is already defined in the schema.`
+      'The "options.source" property cannot be a function. Use a static string path instead.'
     )
-  ), problems.push(...validateComponent(typeDef)), "title" in typeDef && typeof typeDef.title != "string" && problems.push(warning("Type title is not a string.", HELP_IDS.TYPE_TITLE_INVALID)), {
-    ...typeDef,
-    _problems: problems
-  };
-};
-function looksLikeEsmModule(typeDef) {
-  return !typeDef.name && typeDef.default && (typeDef.default.name || typeDef.default.title);
+  ), typeof options.slugify == "function" && problems.push(error('The "options.slugify" property cannot be a function.')), typeof options.isUnique == "function" && problems.push(error('The "options.isUnique" property cannot be a function.')), problems;
 }
-var slug = (typeDef, visitorContext) => {
+function validateAssetSources(options) {
   const problems = [];
-  return typeDef.options && typeDef.options.slugifyFn && (problems.push(
-    warning(
-      'Heads up! The "slugifyFn" option has been renamed to "slugify".',
-      HELP_IDS.SLUG_SLUGIFY_FN_RENAMED
-    )
-  ), typeDef.options.slugify = typeDef.options.slugifyFn), {
-    ...typeDef,
-    _problems: problems
-  };
-};
-const typeVisitors = {
-  array,
-  object,
-  slug,
-  file,
-  image,
-  block: validateBlockType,
-  document: documentVisitor,
-  reference,
-  crossDatasetReference,
-  globalDocumentReference
-}, getNoopVisitor = (visitorContext) => (schemaDef) => ({
-  name: `<unnamed_type_@_index_${visitorContext.index}>`,
-  ...schemaDef,
-  _problems: []
-});
-function combine(...visitors) {
-  return (schemaType, visitorContext) => visitors.reduce(
-    (result, visitor) => {
-      const res = visitor(result, visitorContext);
-      return {
-        ...res,
-        _problems: result._problems.concat(res._problems)
-      };
-    },
-    { _problems: [], ...schemaType }
-  );
+  if (!Array.isArray(options.sources))
+    return problems;
+  for (let i = 0; i < options.sources.length; i++) {
+    const source = options.sources[i];
+    source && (source.component && isComponentLike(source.component) && problems.push(
+      error(`Asset source at index ${i} has a "component" property that cannot be a function.`)
+    ), source.icon && isComponentLike(source.icon) && problems.push(
+      error(`Asset source at index ${i} has an "icon" property that cannot be a component.`)
+    ), (typeof source == "function" || source.Uploader) && problems.push(error(`Asset source at index ${i} contains functions or classes.`)));
+  }
+  return problems;
 }
-function validateSchema(schemaTypes, { transformTypeVisitors = (visitors) => visitors } = {}) {
-  return traverseSanitySchema(schemaTypes, (schemaDef, visitorContext) => {
-    const typeVisitor = schemaDef && schemaDef.type && transformTypeVisitors(typeVisitors)[schemaDef.type] || getNoopVisitor(visitorContext);
-    return visitorContext.isRoot ? combine(rootType, common, typeVisitor)(schemaDef, visitorContext) : combine(common, typeVisitor)(schemaDef, visitorContext);
-  });
+function validateOtherFunctionOptions(options) {
+  const problems = [], knownFunctionOptions = ["filter", "source", "slugify", "isUnique"];
+  for (const [key, value] of Object.entries(options))
+    typeof value == "function" && !knownFunctionOptions.includes(key) && problems.push(error(`The "options.${key}" property cannot be a function.`));
+  return problems;
+}
+function validateFieldsetsAndGroups(typeDef) {
+  const problems = [];
+  return problems.push(...validateFieldsets(typeDef.fieldsets)), problems.push(...validateGroups(typeDef.groups)), problems;
+}
+function validateFieldsets(fieldsets) {
+  const problems = [];
+  if (!Array.isArray(fieldsets))
+    return problems;
+  for (let i = 0; i < fieldsets.length; i++) {
+    const fieldset = fieldsets[i];
+    fieldset && (typeof fieldset.hidden == "function" && problems.push(
+      error(`Fieldset at index ${i} has a "hidden" property that cannot be a function.`)
+    ), typeof fieldset.readOnly == "function" && problems.push(
+      error(`Fieldset at index ${i} has a "readOnly" property that cannot be a function.`)
+    ));
+  }
+  return problems;
+}
+function validateGroups(groups) {
+  const problems = [];
+  if (!Array.isArray(groups))
+    return problems;
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    group && (typeof group.hidden == "function" && problems.push(
+      error(`Field group at index ${i} has a "hidden" property that cannot be a function.`)
+    ), group.icon && isComponentLike(group.icon) && problems.push(
+      error(`Field group at index ${i} has an "icon" property that cannot be a component.`)
+    ));
+  }
+  return problems;
+}
+function validateBlockSpecific(typeDef) {
+  const problems = [];
+  return typeDef.type !== "block" || (problems.push(...validateBlockStyles(typeDef.styles)), problems.push(...validateBlockMarks(typeDef.marks))), problems;
+}
+function validateBlockStyles(styles) {
+  const problems = [];
+  if (!Array.isArray(styles))
+    return problems;
+  for (let i = 0; i < styles.length; i++) {
+    const style = styles[i];
+    style?.component && isComponentLike(style.component) && problems.push(
+      error(`Block style at index ${i} has a "component" property that cannot be a function.`)
+    );
+  }
+  return problems;
+}
+function validateBlockMarks(marks) {
+  const problems = [];
+  if (!marks)
+    return problems;
+  if (Array.isArray(marks.decorators))
+    for (let i = 0; i < marks.decorators.length; i++) {
+      const decorator = marks.decorators[i];
+      decorator?.component && isComponentLike(decorator.component) && problems.push(
+        error(
+          `Block decorator at index ${i} has a "component" property that cannot be a function.`
+        )
+      );
+    }
+  if (Array.isArray(marks.annotations))
+    for (let i = 0; i < marks.annotations.length; i++) {
+      const annotation = marks.annotations[i];
+      annotation?.component && isComponentLike(annotation.component) && problems.push(
+        error(
+          `Block annotation at index ${i} has a "component" property that cannot be a function.`
+        )
+      );
+    }
+  return problems;
+}
+function checkForCustomValidators(validation) {
+  if (!validation) return !1;
+  if (Array.isArray(validation))
+    return validation.some((v) => checkForCustomValidators(v));
+  if (typeof validation == "object") {
+    if (Array.isArray(validation._rules))
+      return validation._rules.some((rule) => rule.flag === "custom" && typeof rule.constraint == "function");
+    if (typeof validation.custom == "function")
+      return !0;
+  }
+  return !1;
 }
 function unsupportedTypeValidator(typeLabel) {
   return function() {
@@ -2094,8 +2834,15 @@ function unsupportedTypeValidator(typeLabel) {
     };
   };
 }
+function noCallbacksVisitor(typeDef, visitorContext) {
+  return {
+    ...typeDef,
+    _problems: validateNoCallbacks(typeDef)
+  };
+}
 function validateMediaLibraryAssetAspect(maybeAspect) {
   const validated = validateSchema([maybeAspect], {
+    transformCommonVisitors: (visitors) => [...visitors, noCallbacksVisitor],
     transformTypeVisitors: (typeVisitors2) => ({
       ...typeVisitors2,
       document: unsupportedTypeValidator("document"),
@@ -2108,15 +2855,20 @@ function validateMediaLibraryAssetAspect(maybeAspect) {
   }), errors = groupProblems(validated.getTypes()).map((group) => group.problems.filter(({ severity }) => severity === "error")).filter((problems) => problems.length);
   return [errors.length === 0, errors];
 }
-exports.DEFAULT_MAX_FIELD_DEPTH = resolve.DEFAULT_MAX_FIELD_DEPTH;
-exports.resolveSearchConfig = resolve.resolveSearchConfig;
-exports.resolveSearchConfigForBaseFieldPaths = resolve.resolveSearchConfigForBaseFieldPaths;
-exports.DescriptorConverter = DescriptorConverter;
-exports.builtinTypes = builtinTypes;
-exports.extractSchema = extractSchema;
-exports.groupProblems = groupProblems;
-exports.isActionEnabled = isActionEnabled;
-exports.processSchemaSynchronization = processSchemaSynchronization;
-exports.validateMediaLibraryAssetAspect = validateMediaLibraryAssetAspect;
-exports.validateSchema = validateSchema;
+export {
+  ALL_FIELDS_GROUP_NAME,
+  DEFAULT_MAX_FIELD_DEPTH,
+  DescriptorConverter,
+  ValidationError,
+  builtinTypes,
+  createSchemaFromManifestTypes,
+  extractSchema,
+  groupProblems,
+  isActionEnabled,
+  processSchemaSynchronization,
+  resolveSearchConfig,
+  resolveSearchConfigForBaseFieldPaths,
+  validateMediaLibraryAssetAspect,
+  validateSchema
+};
 //# sourceMappingURL=_internal.js.map