@sanity/agent-schema 0.0.1

package/dist/index.js

@@ -0,0 +1,1051 @@
+import { z } from "zod";
+async function fetchDatasetStats(client, options) {
+  const { organizationId, projectId, dataset } = options, response = await client.request({
+    uri: `/agent/${organizationId}/dataset-stats/${projectId}/${dataset}`
+  });
+  return "status" in response && response.status === "processing" ? { status: "processing" } : { status: "ready", stats: response };
+}
+function isHoistedMarker(x) {
+  if (x === null || typeof x != "object") return !1;
+  const obj = x;
+  return obj.__type === "hoisted" && typeof obj.key == "string";
+}
+function mapperWithHoisting(hoisted, map) {
+  const cache = /* @__PURE__ */ new Map();
+  return (entry) => {
+    if (isHoistedMarker(entry)) {
+      let result = cache.get(entry.key);
+      if (!result) {
+        const value = hoisted[entry.key];
+        if (!value) throw new Error(`Unknown hoisted key: ${entry.key}`);
+        result = map(value), cache.set(entry.key, result);
+      }
+      return result;
+    }
+    return map(entry);
+  };
+}
+const STOP = /* @__PURE__ */ Symbol("STOP");
+function decodeWithMarkers(x) {
+  const result = decodeWithMarkersOrStop(x);
+  if (result !== STOP)
+    return result;
+}
+function decodeWithMarkersOrStop(x) {
+  if (x == null || typeof x != "object") return x;
+  if (Array.isArray(x)) {
+    const result2 = [];
+    for (const item of x) {
+      const decoded = decodeWithMarkers(item);
+      if (decoded === STOP) return STOP;
+      result2.push(decoded);
+    }
+    return result2;
+  }
+  if ("__type" in x) {
+    const typed = x;
+    switch (typed.__type) {
+      case "function":
+      case "jsx":
+      case "unknown":
+      case "cyclic":
+      case "maxDepth":
+        return STOP;
+      case "number":
+        return Number(typed.value);
+      case "undefined":
+        return;
+      case "object":
+        return decodeWithMarkersOrStop(typed.value);
+      default:
+        throw new Error(`unknown type: ${typed.__type}`);
+    }
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(x)) {
+    const decoded = decodeWithMarkers(value);
+    result[key] = decoded;
+  }
+  return result;
+}
+function mutableSqueeze(obj) {
+  for (const [key, value] of Object.entries(obj))
+    value === void 0 && delete obj[key];
+  return obj;
+}
+const STRIP_FIELDS_TYPES = /* @__PURE__ */ new Set([
+  "block",
+  "reference",
+  "globalDocumentReference",
+  "crossDatasetReference"
+]);
+function convertToDefinition(input) {
+  if (!input?.types || Object.keys(input.types).length === 0)
+    return [];
+  const hoisted = input.hoisted ?? {}, convertField = mapperWithHoisting(hoisted, (field) => ({
+    groups: field.groups,
+    fieldset: field.fieldset,
+    ...convertTypeDef(field.name, field.typeDef)
+  })), convertArrayElement = mapperWithHoisting(
+    hoisted,
+    (element) => convertTypeDef(element.name, element.typeDef)
+  );
+  function convertTypeDef(name, typeDef) {
+    const { extends: type, fields, fieldsets, to, of, validation, ...rest } = typeDef;
+    return mutableSqueeze({
+      name,
+      type,
+      fields: fields && !STRIP_FIELDS_TYPES.has(type) ? fields.map(convertField) : void 0,
+      fieldsets: (fieldsets?.length || 0) > 0 ? fieldsets : void 0,
+      of: of ? of.map(convertArrayElement) : void 0,
+      to: to?.map(({ name: toName }) => mutableSqueeze({ type: toName })),
+      validation,
+      ...decodeWithMarkers(rest)
+    });
+  }
+  const types = [];
+  for (const [name, typeDef] of Object.entries(input.types))
+    types.push(convertTypeDef(name, typeDef));
+  return types;
+}
+const DEFAULT_TTL_MS = 300 * 1e3, memoryCache = /* @__PURE__ */ new Map();
+function getFromMemoryCache(descriptorId) {
+  const entry = memoryCache.get(descriptorId);
+  if (entry) {
+    if (Date.now() > entry.expiresAt) {
+      memoryCache.delete(descriptorId);
+      return;
+    }
+    return entry.response;
+  }
+}
+function setInMemoryCache(descriptorId, response, ttl) {
+  memoryCache.set(descriptorId, { response, expiresAt: Date.now() + ttl });
+}
+async function fetchSchemaByDescriptorId(client, descriptorId, options) {
+  const { cache, ttlMs = DEFAULT_TTL_MS } = options ?? {};
+  if (cache === !0) {
+    const hit = getFromMemoryCache(descriptorId);
+    if (hit) return convertToDefinition(hit);
+  } else if (cache) {
+    const hit = await cache.get(descriptorId);
+    if (hit) return convertToDefinition(hit);
+  }
+  const response = await client.request({
+    uri: `/descriptors/schemas/${descriptorId}`
+  });
+  return cache === !0 ? setInMemoryCache(descriptorId, response, ttlMs) : cache && await cache.set(descriptorId, response).catch(() => {
+  }), convertToDefinition(response);
+}
+const SCHEMA_CONSTANTS = {
+  SKIP_PATTERNS: /^(system\.|sanity\.|assist\.|media\.|mux\.)/,
+  TITLE_FIELD_CANDIDATES: ["title", "name", "heading", "label"],
+  DEFAULT_OPTIONS: {
+    trackPaths: !0,
+    maxExpansionDepth: 1
+  },
+  DEFAULTS: {
+    titleField: "title",
+    fallbackTitleField: "_id",
+    maxFieldsInSummary: 10,
+    maxEnumValues: 10,
+    maxDescriptionLength: 50,
+    maxDocDescriptionLength: 512
+  }
+};
+function resolveFilterSync(filter) {
+  if (filter && Array.isArray(filter))
+    return filter.length > 0 ? filter : void 0;
+}
+const TITLE_FIELD_CANDIDATES = SCHEMA_CONSTANTS.TITLE_FIELD_CANDIDATES;
+function isTextLike(type) {
+  return type === "string" || type === "text";
+}
+function findTitleField(fields) {
+  for (const candidate of TITLE_FIELD_CANDIDATES)
+    if (fields.some((f) => f.name === candidate && isTextLike(f.type))) return candidate;
+  return fields.some((f) => f.name === "title") ? "title" : fields.find((f) => isTextLike(f.type))?.name ?? SCHEMA_CONSTANTS.DEFAULTS.fallbackTitleField;
+}
+function expandFields(fields, objectTypes, depth) {
+  return depth <= 0 ? fields : fields.map((field) => {
+    const expanded = { ...field };
+    if (field.type && objectTypes.has(field.type)) {
+      const obj = objectTypes.get(field.type);
+      expanded.type = "object", expanded.fields = expandFields(obj.fields ?? [], objectTypes, depth - 1);
+    }
+    return Array.isArray(field.of) && (expanded.of = field.of.map((item) => {
+      const itemType = item?.type;
+      if (itemType && objectTypes.has(itemType)) {
+        const obj = objectTypes.get(itemType);
+        return {
+          ...item,
+          type: "object",
+          fields: expandFields(obj.fields ?? [], objectTypes, depth - 1)
+        };
+      }
+      return item;
+    })), expanded;
+  });
+}
+function collectReferences(fields, path, included, trackPaths, outgoing, outgoingPaths, addIncoming, sourceType) {
+  for (const field of fields) {
+    const fieldPath = path ? `${path}.${field.name}` : field.name;
+    if (field.type === "reference" && field.to)
+      for (const target of field.to) {
+        const t = target.type;
+        !t || !included(t) || (outgoing.add(t), trackPaths && (outgoingPaths.push({ type: t, path: fieldPath }), addIncoming(t, sourceType, fieldPath)));
+      }
+    if (field.fields?.length && collectReferences(
+      field.fields,
+      fieldPath,
+      included,
+      trackPaths,
+      outgoing,
+      outgoingPaths,
+      addIncoming,
+      sourceType
+    ), Array.isArray(field.of))
+      for (const item of field.of)
+        if (item?.type === "reference" && Array.isArray(item.to))
+          for (const target of item.to) {
+            const t = target.type;
+            if (!t || !included(t)) continue;
+            outgoing.add(t);
+            const arrayPath = `${fieldPath}[]`;
+            trackPaths && (outgoingPaths.push({ type: t, path: arrayPath }), addIncoming(t, sourceType, arrayPath));
+          }
+        else Array.isArray(item?.fields) && collectReferences(
+          item.fields,
+          `${fieldPath}[]`,
+          included,
+          trackPaths,
+          outgoing,
+          outgoingPaths,
+          addIncoming,
+          sourceType
+        );
+  }
+}
+function processSchema(schema, options) {
+  const trackPaths = SCHEMA_CONSTANTS.DEFAULT_OPTIONS.trackPaths, includeList = resolveFilterSync(options?.filter), includeSet = includeList?.length ? new Set(includeList) : null, included = (name) => !includeSet || includeSet.has(name), maxDepth = SCHEMA_CONSTANTS.DEFAULT_OPTIONS.maxExpansionDepth, documentTypes = /* @__PURE__ */ new Map(), objectTypes = /* @__PURE__ */ new Map();
+  for (const type of schema)
+    if (type.type === "document") {
+      if (!included(type.name)) continue;
+      documentTypes.set(type.name, {
+        name: type.name,
+        title: type.title,
+        description: type.description,
+        deprecated: type.deprecated,
+        titleField: SCHEMA_CONSTANTS.DEFAULTS.titleField,
+        fields: type.fields ?? [],
+        outgoingReferences: [],
+        incomingReferences: []
+      });
+    } else type.type === "object" && objectTypes.set(type.name, type);
+  for (const doc of documentTypes.values())
+    doc.fields = expandFields(doc.fields, objectTypes, maxDepth);
+  const incomingMap = /* @__PURE__ */ new Map(), incomingSimple = /* @__PURE__ */ new Map(), addIncoming = (targetType, sourceType, fieldPath) => {
+    incomingSimple.has(targetType) || incomingSimple.set(targetType, /* @__PURE__ */ new Set()), incomingSimple.get(targetType).add(sourceType), incomingMap.has(targetType) || incomingMap.set(targetType, /* @__PURE__ */ new Map());
+    const sourceMap = incomingMap.get(targetType);
+    sourceMap.has(sourceType) || sourceMap.set(sourceType, /* @__PURE__ */ new Set()), sourceMap.get(sourceType).add(fieldPath);
+  };
+  for (const [docName, doc] of documentTypes) {
+    const outgoing = /* @__PURE__ */ new Set(), outgoingPaths = [];
+    if (collectReferences(
+      doc.fields,
+      "",
+      included,
+      trackPaths,
+      outgoing,
+      outgoingPaths,
+      addIncoming,
+      docName
+    ), !trackPaths)
+      for (const targetType of outgoing)
+        incomingSimple.has(targetType) || incomingSimple.set(targetType, /* @__PURE__ */ new Set()), incomingSimple.get(targetType).add(docName);
+    doc.outgoingReferences = Array.from(outgoing), trackPaths && (doc.outgoingReferencePaths = outgoingPaths);
+  }
+  for (const [targetType, sources] of incomingSimple) {
+    const target = documentTypes.get(targetType);
+    if (target && (target.incomingReferences = Array.from(sources), trackPaths && incomingMap.has(targetType))) {
+      const paths = [];
+      for (const [sourceType, fieldPaths] of incomingMap.get(targetType))
+        for (const p of fieldPaths)
+          paths.push({ type: sourceType, path: p });
+      target.incomingReferencePaths = paths;
+    }
+  }
+  for (const doc of documentTypes.values())
+    doc.titleField = findTitleField(doc.fields);
+  return { documentTypes, objectTypes };
+}
+const BUILT_IN_TYPE_FIELDS = {
+  slug: {
+    current: { name: "current", type: "string" },
+    _type: { name: "_type", type: "string" }
+  },
+  geopoint: {
+    lat: { name: "lat", type: "number" },
+    lng: { name: "lng", type: "number" },
+    alt: { name: "alt", type: "number" },
+    _type: { name: "_type", type: "string" }
+  },
+  reference: {
+    _ref: { name: "_ref", type: "string" },
+    _type: { name: "_type", type: "string" },
+    _weak: { name: "_weak", type: "boolean" }
+  },
+  image: {
+    asset: { name: "asset", type: "reference" },
+    hotspot: {
+      name: "hotspot",
+      type: "object",
+      fields: [
+        { name: "x", type: "number" },
+        { name: "y", type: "number" },
+        { name: "height", type: "number" },
+        { name: "width", type: "number" }
+      ]
+    },
+    crop: {
+      name: "crop",
+      type: "object",
+      fields: [
+        { name: "top", type: "number" },
+        { name: "bottom", type: "number" },
+        { name: "left", type: "number" },
+        { name: "right", type: "number" }
+      ]
+    },
+    _type: { name: "_type", type: "string" }
+  },
+  file: {
+    asset: { name: "asset", type: "reference" },
+    _type: { name: "_type", type: "string" }
+  },
+  block: {
+    style: { name: "style", type: "string" },
+    listItem: { name: "listItem", type: "string" },
+    level: { name: "level", type: "number" },
+    children: {
+      name: "children",
+      type: "array",
+      of: [{ name: "span", type: "span" }]
+    },
+    markDefs: {
+      name: "markDefs",
+      type: "array",
+      of: [{ name: "object", type: "object" }]
+    },
+    _type: { name: "_type", type: "string" }
+  },
+  span: {
+    text: { name: "text", type: "string" },
+    marks: {
+      name: "marks",
+      type: "array",
+      of: [{ name: "string", type: "string" }]
+    },
+    _type: { name: "_type", type: "string" }
+  }
+}, DEFAULT_LINK_ANNOTATION = {
+  name: "link",
+  type: "object",
+  fields: [
+    { name: "href", type: "string" },
+    { name: "blank", type: "boolean" }
+  ]
+}, ARRAY_ITEM_SYSTEM_FIELDS = {
+  _key: { name: "_key", type: "string" },
+  _type: { name: "_type", type: "string" }
+};
+function parseOfIndexSyntax(segment) {
+  const match = segment.match(/^of\[(\d+)\]$/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function parseArrayNotation(segment) {
+  const match = segment.match(/^([^[]+)\[.*\]$/);
+  return match ? { fieldName: match[1], isArray: !0 } : null;
+}
+function createNotFoundMarker() {
+  return { name: "", type: "notfound", fields: [] };
+}
+function navigateToOfIndex(node, index) {
+  return !node.of || !Array.isArray(node.of) || index < 0 || index >= node.of.length ? null : node.of[index];
+}
+function navigateToSchemaProperty(node, propertyName, isLastSegment) {
+  if (!node || typeof node != "object" || !(propertyName in node))
+    return { result: null };
+  const propertyValue = node[propertyName];
+  return isLastSegment ? Array.isArray(propertyValue) ? {
+    result: {
+      name: propertyName,
+      type: "array",
+      of: propertyValue
+    }
+  } : {
+    result: {
+      name: propertyName,
+      type: typeof propertyValue == "object" && propertyValue !== null ? "object" : typeof propertyValue,
+      ...propertyValue
+    }
+  } : typeof propertyValue == "object" && propertyValue !== null ? Array.isArray(propertyValue) ? {
+    result: null,
+    continueWith: {
+      type: "array",
+      of: propertyValue
+    }
+  } : {
+    result: null,
+    continueWith: propertyValue
+  } : { result: null };
+}
+function resolveArrayFieldOf(field, schema) {
+  if (field.of) return field.of;
+  if (field.type) {
+    const referencedType = schema.find((t) => t.name === field.type);
+    if (referencedType?.of)
+      return referencedType.of;
+  }
+  return null;
+}
+function createArrayTypeFromField(field, schema) {
+  if (field.type) {
+    const arrayType = schema.find((t) => t.name === field.type);
+    if (arrayType) return arrayType;
+  }
+  return {
+    ...field,
+    name: field.name,
+    type: "array"
+  };
+}
+function filterToPath(type, path, schema) {
+  const segments = path.split(/\.(?![^[]*\])/);
+  if (segments.length === 1 && segments[0].startsWith("of[")) {
+    const index = parseOfIndexSyntax(segments[0]);
+    if (index !== null)
+      return navigateToOfIndex(type, index) || { ...type, fields: [], of: void 0 };
+  }
+  let currentNode = type, currentFields = type.fields;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i], ofIndex = parseOfIndexSyntax(segment);
+    if (ofIndex !== null) {
+      const item = navigateToOfIndex(currentNode, ofIndex);
+      if (item) {
+        if (i === segments.length - 1)
+          return item;
+        currentNode = item, currentFields = currentNode.fields;
+        continue;
+      }
+      return { ...type, fields: [], of: void 0 };
+    }
+    const arrayNotation = parseArrayNotation(segment), fieldName = arrayNotation ? arrayNotation.fieldName : segment, field = currentFields?.find((f) => f.name === fieldName);
+    if (!field) {
+      const isLastSegment = i === segments.length - 1, propertyNav = navigateToSchemaProperty(currentNode, fieldName, isLastSegment);
+      if (propertyNav.result)
+        return propertyNav.result;
+      if (propertyNav.continueWith) {
+        currentNode = propertyNav.continueWith, currentFields = currentNode.fields;
+        continue;
+      }
+      return createNotFoundMarker();
+    }
+    if (i === segments.length - 1)
+      return arrayNotation ? (segment.match(/\[(\d+)\]$/), createArrayTypeFromField(field, schema)) : { ...type, fields: [field] };
+    if (arrayNotation) {
+      const fieldOf = resolveArrayFieldOf(field, schema);
+      if (!fieldOf)
+        return { ...type, fields: [] };
+      currentNode = createArrayTypeFromField(field, schema);
+      const nextSegment = segments[i + 1];
+      if (!nextSegment)
+        continue;
+      const nextOfIndex = parseOfIndexSyntax(nextSegment);
+      if (nextOfIndex !== null) {
+        const item = navigateToOfIndex(currentNode, nextOfIndex);
+        if (item) {
+          if (i + 1 === segments.length - 1)
+            return item;
+          currentNode = item, currentFields = item.fields, i++;
+          continue;
+        } else
+          return { ...type, fields: [], of: void 0 };
+      }
+      const arrayItemByType = fieldOf.find(
+        (item) => item.name === nextSegment || item.type === nextSegment
+      );
+      if (arrayItemByType) {
+        if (i + 1 === segments.length - 1)
+          return { ...type, fields: [{ ...field, of: [arrayItemByType] }] };
+        if (arrayItemByType.fields) {
+          currentFields = arrayItemByType.fields, i++;
+          continue;
+        } else
+          return { ...type, fields: [] };
+      }
+      const matchingFields = [];
+      for (const item of fieldOf) {
+        const itemAsType = item;
+        if (itemAsType.fields && Array.isArray(itemAsType.fields)) {
+          const matchingField = itemAsType.fields.find((f) => f.name === nextSegment);
+          matchingField && matchingFields.push({
+            typeName: itemAsType.name || itemAsType.type,
+            field: matchingField
+          });
+        }
+      }
+      if (matchingFields.length === 0)
+        return { ...type, fields: [] };
+      if (i + 1 === segments.length - 1)
+        if (matchingFields.length === 1) {
+          const match = matchingFields[0], syntheticArrayField = {
+            ...field,
+            of: [
+              {
+                name: match.typeName,
+                type: "object",
+                fields: [match.field]
+                // The matched field
+              }
+            ]
+          };
+          return { ...type, fields: [syntheticArrayField] };
+        } else {
+          const syntheticArrayField = {
+            ...field,
+            of: matchingFields.map((m) => ({
+              name: m.typeName,
+              type: "object",
+              fields: [m.field]
+            }))
+          };
+          return { ...type, fields: [syntheticArrayField] };
+        }
+      currentFields = matchingFields[0].field.fields, i++;
+    } else if (field.fields)
+      currentFields = field.fields;
+    else
+      return { ...type, fields: [] };
+  }
+  return { ...type, fields: [] };
+}
+function toSchemaPath(path) {
+  return path ? path.replace(/\[append:\d+\]/g, "").replace(/\[_key\s*==\s*["'][^"']*["']\]/g, "").replace(/\[\d+\]/g, "").replace(/\[\]/g, "").replace(/\.{2,}/g, ".").replace(/^\.+|\.+$/g, "") : "";
+}
+const BASE_PRIMITIVES = ["string", "number", "boolean", "date", "datetime", "text", "url", "email"], BLOCK_TYPES = ["block", "reference"];
+function isPrimitiveType(typeName, options = {}) {
+  return typeName ? options.includeBlockTypes ? BASE_PRIMITIVES.includes(typeName) || BLOCK_TYPES.includes(typeName) : BASE_PRIMITIVES.includes(typeName) : !1;
+}
+function isBuiltInType(type) {
+  return BUILT_IN_TYPES.has(type);
+}
+const BUILT_IN_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "number",
+  "boolean",
+  "array",
+  "object",
+  "reference",
+  "image",
+  "file",
+  "date",
+  "datetime",
+  "url",
+  "slug",
+  "block",
+  "geopoint"
+]);
+function isGenericObject(node) {
+  if (typeof node != "object" || node === null || Array.isArray(node)) return !1;
+  const obj = node;
+  return !obj.fields && !(obj.type === "array" && Array.isArray(obj.of));
+}
+function resolveFieldSchemaAllUnions(path, typeSchema, schema) {
+  const pathParts = toSchemaPath(path).split(".").filter(Boolean);
+  let currentSchemas = [typeSchema];
+  for (let i = 0; i < pathParts.length; i++) {
+    const part = pathParts[i], isLastPart = i === pathParts.length - 1, nextSchemas = [];
+    for (const currentSchema of currentSchemas) {
+      if (!currentSchema?.fields || !Array.isArray(currentSchema.fields))
+        continue;
+      const field = currentSchema.fields.find((f) => f.name === part);
+      if (field)
+        if (field.type === "array" && field.of && field.of.length > 0)
+          for (const itemSchema of field.of) {
+            const itemType = typeof itemSchema.type == "string" ? itemSchema.type : void 0;
+            if (isLastPart && (itemType === "image" || itemType === "file"))
+              nextSchemas.push(itemSchema);
+            else if (itemType && !isBuiltInType(itemType)) {
+              const foundSchema = schema.find((s) => s.name === itemType);
+              foundSchema && nextSchemas.push(foundSchema);
+            } else itemSchema.fields && nextSchemas.push(itemSchema);
+          }
+        else if (field.type && !isBuiltInType(field.type)) {
+          const foundSchema = schema.find((s) => s.name === field.type);
+          if (foundSchema)
+            if (foundSchema.type === "array" && foundSchema.of && foundSchema.of.length > 0)
+              for (const itemSchema of foundSchema.of) {
+                const itemType = typeof itemSchema.type == "string" ? itemSchema.type : void 0;
+                if (isLastPart && (itemType === "image" || itemType === "file"))
+                  nextSchemas.push(itemSchema);
+                else if (itemType && !isBuiltInType(itemType)) {
+                  const itemFoundSchema = schema.find((s) => s.name === itemType);
+                  itemFoundSchema && nextSchemas.push(itemFoundSchema);
+                } else itemSchema.fields && nextSchemas.push(itemSchema);
+              }
+            else
+              nextSchemas.push(foundSchema);
+        } else
+          nextSchemas.push(field);
+    }
+    currentSchemas = nextSchemas;
+  }
+  return currentSchemas;
+}
+function getBuiltInFieldSchema(segment, currentSchema) {
+  if (!currentSchema?.type || !BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment])
+    return null;
+  let builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment];
+  if (currentSchema.type === "block" && segment === "children" && currentSchema.of && (builtInField = {
+    ...builtInField,
+    of: [...builtInField.of || [], ...currentSchema.of]
+  }), currentSchema.type === "block" && segment === "markDefs") {
+    const annotations = currentSchema.marks?.annotations;
+    annotations ? builtInField = {
+      ...builtInField,
+      of: [...builtInField.of || [], ...annotations]
+    } : builtInField = {
+      ...builtInField,
+      of: [...builtInField.of || [], DEFAULT_LINK_ANNOTATION]
+    };
+  }
+  return builtInField;
+}
+function findSchemaInUnionArray(segment, arraySchema, allSchemas, isLastSegment) {
+  if (!arraySchema.of || arraySchema.of.length === 0)
+    return { schema: null, earlyReturn: null };
+  for (const itemSchema of arraySchema.of) {
+    if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[segment]) {
+      const builtInField = BUILT_IN_TYPE_FIELDS[itemSchema.type][segment];
+      return isLastSegment ? { schema: null, earlyReturn: builtInField } : { schema: builtInField, earlyReturn: null };
+    }
+    if (itemSchema.fields?.some((f) => f.name === segment))
+      return { schema: itemSchema, earlyReturn: null };
+    if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {
+      const referencedSchema2 = allSchemas.find((s) => s.name === itemSchema.type);
+      if (referencedSchema2?.fields?.some((f) => f.name === segment))
+        return { schema: referencedSchema2, earlyReturn: null };
+    }
+  }
+  const firstItem = arraySchema.of[0];
+  if (firstItem.fields)
+    return { schema: firstItem, earlyReturn: null };
+  const referencedSchema = allSchemas.find((s) => s.name === firstItem.type);
+  return referencedSchema?.fields ? { schema: referencedSchema, earlyReturn: null } : { schema: null, earlyReturn: null };
+}
+function resolveCurrentSchema(segment, currentSchema, allSchemas, isLastSegment) {
+  if (!currentSchema?.type)
+    return { schema: null, earlyReturn: null };
+  if (currentSchema.type === "array" && currentSchema.of && currentSchema.of.length > 0)
+    return findSchemaInUnionArray(segment, currentSchema, allSchemas, isLastSegment);
+  const referencedSchema = allSchemas.find((s) => s.name === currentSchema.type);
+  if (referencedSchema?.fields)
+    return { schema: referencedSchema, earlyReturn: null };
+  if (BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {
+    const builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment];
+    return isLastSegment ? { schema: null, earlyReturn: builtInField } : { schema: builtInField, earlyReturn: null };
+  }
+  return { schema: null, earlyReturn: null };
+}
+function getNextSchemaForField(field, nextSegment, allSchemas) {
+  let resolvedField = field;
+  if (field.type && !isPrimitiveType(field.type) && field.type !== "array") {
+    const referencedSchema = allSchemas.find((s) => s.name === field.type);
+    referencedSchema && (resolvedField = referencedSchema);
+  }
+  if (resolvedField.type === "array" && resolvedField.of && resolvedField.of.length > 0) {
+    for (const itemSchema of resolvedField.of) {
+      if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[nextSegment] || itemSchema.fields?.some((f) => f.name === nextSegment))
+        return itemSchema;
+      if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {
+        const refSchema = allSchemas.find((s) => s.name === itemSchema.type);
+        if (refSchema?.fields?.some((f) => f.name === nextSegment))
+          return refSchema;
+      }
+    }
+    return resolvedField.of[0];
+  }
+  return resolvedField;
+}
+function resolveFieldSchema(path, typeSchema, schema) {
+  const segments = toSchemaPath(path).split(".").filter(Boolean);
+  let currentSchema = typeSchema;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i], isLastSegment = i === segments.length - 1;
+    if (ARRAY_ITEM_SYSTEM_FIELDS[segment])
+      return ARRAY_ITEM_SYSTEM_FIELDS[segment];
+    const builtInField = getBuiltInFieldSchema(segment, currentSchema);
+    if (builtInField) {
+      if (isLastSegment) return builtInField;
+      currentSchema = builtInField;
+      continue;
+    }
+    if (!currentSchema?.fields) {
+      const resolved = resolveCurrentSchema(segment, currentSchema, schema, isLastSegment);
+      if (resolved.earlyReturn) return resolved.earlyReturn;
+      if (!resolved.schema) return null;
+      currentSchema = resolved.schema;
+      const resolvedBuiltInField = getBuiltInFieldSchema(segment, currentSchema);
+      if (resolvedBuiltInField) {
+        if (isLastSegment) return resolvedBuiltInField;
+        currentSchema = resolvedBuiltInField;
+        continue;
+      }
+    }
+    if (!currentSchema?.fields) return null;
+    const field = currentSchema.fields.find((f) => f.name === segment);
+    if (!field) return null;
+    if (isLastSegment) return field;
+    currentSchema = getNextSchemaForField(field, segments[i + 1], schema);
+  }
+  return currentSchema || null;
+}
+function shouldSkipType(typeName) {
+  return SCHEMA_CONSTANTS.SKIP_PATTERNS.test(typeName);
+}
+function fullSchema(schema, options) {
+  const { type: typeName, path, sizeThreshold = 200 * 1024 } = options, type = schema.find((t) => t.name === typeName);
+  if (!type) {
+    const documentTypes = schema.filter((t) => t.type === "document" && !shouldSkipType(t.name)).map((t) => t.name).sort().slice(0, 10);
+    return {
+      _error: !0,
+      message: `Type "${typeName}" not found`,
+      availableTypes: documentTypes
+    };
+  }
+  const targetNode = path ? filterToPath(type, path, schema) : type;
+  if (path) {
+    if (targetNode.type === "notfound")
+      return {
+        _error: !0,
+        message: `Path "${path}" not found in type "${typeName}"`,
+        type: typeName,
+        path
+      };
+    const originalHadFields = type.fields && type.fields.length > 0, resultHasFields = targetNode.fields && targetNode.fields.length > 0, resultHasOf = targetNode.of && targetNode.of.length > 0, resultIsDifferent = targetNode !== type, hasJustTypeProperty = targetNode.type && Object.keys(targetNode).length <= 2, hasPropertyContent = resultIsDifferent && Object.keys(targetNode).length > 2, resultHasContent = resultHasFields || resultHasOf || targetNode.validation || targetNode.options || targetNode.to || resultIsDifferent && hasJustTypeProperty || hasPropertyContent;
+    if (resultIsDifferent && !resultHasContent || !resultIsDifferent && originalHadFields && !resultHasFields && !resultHasOf)
+      return {
+        _error: !0,
+        message: `Path "${path}" not found in type "${typeName}"`,
+        type: typeName,
+        path
+      };
+  }
+  const rawSubtree = extractRawSubtree(targetNode), jsonString = JSON.stringify(rawSubtree, null, 2);
+  return new TextEncoder().encode(jsonString).length <= sizeThreshold ? rawSubtree : generateLargeNodeNavigator(targetNode, path, typeName);
+}
+function extractRawSubtree(node) {
+  const cleaned = JSON.parse(JSON.stringify(node));
+  return cleaned.fields && Array.isArray(cleaned.fields) && (cleaned.fields = cleaned.fields.filter((field) => !shouldSkipType(field.name))), cleaned;
+}
+function generateLargeNodeNavigator(node, currentPath, rootTypeName) {
+  const children = [];
+  if ((node.type === "array" || node.of) && Array.isArray(node.of) && node.of.length > 0)
+    node.of.forEach((item, index) => {
+      const itemType = item.name || item.title || (item.type && item.type !== "object" ? item.type : null) || item.type || "unknown";
+      children.push({
+        type: String(itemType),
+        path: currentPath ? `${currentPath}.of[${index}]` : `of[${index}]`
+      });
+    });
+  else if (node.fields && Array.isArray(node.fields))
+    node.fields.forEach((field) => {
+      if (shouldSkipType(field.name)) return;
+      const childPath = currentPath ? `${currentPath}.${field.name}` : field.name;
+      if (field.type === "array" && field.of && Array.isArray(field.of)) {
+        const arrayPath = `${childPath}[]`;
+        field.of.forEach((item) => {
+          if (item.name || item.type) {
+            const itemType = String(item.name || item.type);
+            isPrimitiveType(itemType, { includeBlockTypes: !0 }) || children.push({ type: itemType, path: `${arrayPath}.${itemType}` });
+          }
+        }), field.of.length > 0 && children.push({ type: "array", path: arrayPath });
+      } else field.type === "object" || field.fields ? children.push({ type: field.type || "object", path: childPath }) : field.type && !isPrimitiveType(field.type, { includeBlockTypes: !0 }) && children.push({ type: field.type, path: childPath });
+    });
+  else if (isGenericObject(node)) {
+    const nodeObj = node, skipKeys = /* @__PURE__ */ new Set(["type", "name", "_type", "_key"]);
+    for (const key of Object.keys(nodeObj)) {
+      if (skipKeys.has(key)) continue;
+      const value = nodeObj[key], childPath = currentPath ? `${currentPath}.${key}` : key;
+      let propertyType = "unknown";
+      Array.isArray(value) ? propertyType = "array" : typeof value == "object" && value !== null ? propertyType = "object" : propertyType = typeof value, children.push({ type: propertyType, path: childPath });
+    }
+  }
+  return {
+    _rawLargeNode: !0,
+    name: currentPath || rootTypeName,
+    type: node.type || "object",
+    children,
+    hint: "This node is large. Fetch a specific child path to drill in."
+  };
+}
+const InOutCountsSchema = z.object({
+  incoming: z.record(z.union([z.number(), z.literal("unknown")])),
+  outgoing: z.record(z.union([z.number(), z.literal("unknown")]))
+}), DatasetStatsSchema = z.object({
+  documentCount: z.record(z.number()).optional(),
+  referenceCount: z.record(InOutCountsSchema).optional()
+});
+async function resolveFilter(schema, filter) {
+  if (!filter) return;
+  if (Array.isArray(filter)) return filter.length > 0 ? filter : void 0;
+  const result = await getFilteredDocumentTypes(schema, filter);
+  return result.length > 0 ? result : void 0;
+}
+async function getFilteredDocumentTypes(schema, filter) {
+  if (!filter || !filter.read && !filter.write) return [];
+  const allDocTypes = schema.filter((s) => s.type === "document").map((s) => s.name);
+  if (allDocTypes.length === 0) return [];
+  const combined = /* @__PURE__ */ new Set();
+  if (filter.read)
+    for (const type of await filterTypesByExpression(filter.read, allDocTypes))
+      combined.add(type);
+  if (filter.write)
+    for (const type of await filterTypesByExpression(filter.write, allDocTypes))
+      combined.add(type);
+  return combined.size === allDocTypes.length ? [] : Array.from(combined);
+}
+async function filterTypesByExpression(filterExpr, allTypes) {
+  if (!filterExpr?.trim() || allTypes.length === 0)
+    return new Set(allTypes);
+  try {
+    const { parse } = await import("groq-js"), ast = parse(filterExpr), matching = allTypes.filter((type) => evaluateForType(ast, type) !== !1);
+    return matching.length > 0 ? new Set(matching) : new Set(allTypes);
+  } catch {
+    return new Set(allTypes);
+  }
+}
+function prop(node, key) {
+  return node[key];
+}
+function child(node, key) {
+  return prop(node, key);
+}
+function evaluateForType(node, type) {
+  if (!node || typeof node != "object") return null;
+  switch (node.type) {
+    case "OpCall":
+      return evaluateOpCall(node, type);
+    case "And": {
+      const left = evaluateForType(child(node, "left"), type), right = evaluateForType(child(node, "right"), type);
+      return left === !1 || right === !1 ? !1 : left === !0 && right === !0 ? !0 : null;
+    }
+    case "Or": {
+      const left = evaluateForType(child(node, "left"), type), right = evaluateForType(child(node, "right"), type);
+      return left === !0 || right === !0 ? !0 : left === !1 && right === !1 ? !1 : null;
+    }
+    case "Not": {
+      const inner = evaluateForType(child(node, "base"), type);
+      return inner === null ? null : !inner;
+    }
+    case "Group":
+      return evaluateForType(child(node, "base"), type);
+    default:
+      return null;
+  }
+}
+function evaluateOpCall(node, type) {
+  const op = prop(node, "op"), left = child(node, "left"), right = child(node, "right");
+  if (!isTypeAttribute(left)) return null;
+  const rightType = right.type;
+  if (op === "==" && rightType === "Value") {
+    const val = prop(right, "value");
+    return typeof val == "string" ? type === val : null;
+  }
+  if (op === "!=" && rightType === "Value") {
+    const val = prop(right, "value");
+    return typeof val == "string" ? type !== val : null;
+  }
+  if (op === "in" && rightType === "Array") {
+    const values = extractStringValues(right);
+    return values ? values.includes(type) : null;
+  }
+  return null;
+}
+function isTypeAttribute(node) {
+  return node?.type === "AccessAttribute" && prop(node, "name") === "_type";
+}
+function extractStringValues(arrayNode) {
+  const elements = prop(arrayNode, "elements");
+  if (!elements) return null;
+  const values = [];
+  for (const el of elements) {
+    if (el.type !== "ArrayElement" || el.isSplat) return null;
+    const val = el.value;
+    if (val?.type !== "Value") return null;
+    const v = prop(val, "value");
+    if (typeof v != "string") return null;
+    values.push(v);
+  }
+  return values;
+}
+const SIMPLE_TYPE_MAP = {
+  document: "object",
+  crossDatasetReference: "reference"
+}, KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "image",
+  "file",
+  "array",
+  "object",
+  "reference",
+  "block",
+  "slug",
+  "geopoint",
+  "span",
+  "url",
+  "email",
+  "color"
+]);
+function getSimpleFieldType(field) {
+  return SIMPLE_TYPE_MAP[field.type] ?? (KNOWN_TYPES.has(field.type) ? field.type : "object");
+}
+function normalize(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function getEnumValues(field) {
+  const list = field.options?.list;
+  return !Array.isArray(list) || list.length === 0 ? null : list.map(
+    (item) => typeof item == "string" ? item : item.value
+  ).filter(Boolean);
+}
+function formatTypeString(field, maxEnumValues) {
+  const enumValues = getEnumValues(field);
+  if (!enumValues) return getSimpleFieldType(field);
+  const shown = enumValues.slice(0, maxEnumValues), overflow = enumValues.length - maxEnumValues;
+  return shown.join("|") + (overflow > 0 ? `|...${overflow} more` : "");
+}
+function formatDescription(field, includeDescription, maxLen) {
+  return !includeDescription || !field.title || normalize(field.title) === normalize(field.name) ? "" : `: ${field.title.length > maxLen ? `${field.title.slice(0, maxLen)}...` : field.title}`;
+}
+function formatFieldNamesWithTypes(fields, options) {
+  const {
+    showAll,
+    maxCount,
+    includeDescription = !1,
+    includeHidden = !1,
+    includeDeprecated = !1,
+    maxEnumValues = SCHEMA_CONSTANTS.DEFAULTS.maxEnumValues,
+    maxDescriptionLength = SCHEMA_CONSTANTS.DEFAULTS.maxDescriptionLength
+  } = options ?? {}, filtered = fields.filter((f) => !(!includeDeprecated && f.deprecated || !includeHidden && f.hidden)), limit = showAll ? filtered.length : maxCount ?? SCHEMA_CONSTANTS.DEFAULTS.maxFieldsInSummary;
+  return filtered.slice(0, limit).map((f) => {
+    const typeStr = formatTypeString(f, maxEnumValues), desc = formatDescription(f, includeDescription, maxDescriptionLength);
+    return `${f.name}<${typeStr}>${desc}`;
+  }).join(", ");
+}
+function formatReferenceCount(count) {
+  return typeof count == "number" && count > 0 ? `\xD7${count}` : "";
+}
+function formatDocumentCount(count, hasDocumentCounts) {
+  return hasDocumentCounts ? String(count ?? 0) : "unknown";
+}
+function calculateMaxDepth(fields, objectTypes, currentDepth = 1, visited = /* @__PURE__ */ new Set()) {
+  let max = currentDepth;
+  for (const field of fields) {
+    field.fields?.length && (max = Math.max(max, calculateMaxDepth(field.fields, objectTypes, currentDepth + 1, visited)));
+    const checkObjectType = (typeName) => {
+      if (!typeName || visited.has(typeName)) return;
+      const obj = objectTypes.get(typeName);
+      obj?.fields?.length && (visited.add(typeName), max = Math.max(max, calculateMaxDepth(obj.fields, objectTypes, currentDepth + 1, visited)));
+    };
+    if (checkObjectType(field.type), Array.isArray(field.of))
+      for (const item of field.of)
+        checkObjectType(item?.type);
+  }
+  return max;
+}
+function formatRefsWithCounts(doc, referenceCount) {
+  const counts = referenceCount ?? {}, outgoing = [...doc.outgoingReferencePaths ?? []].sort((a, b) => `${a.path}->${a.type}`.localeCompare(`${b.path}->${b.type}`)).map((r) => {
+    const pathKey = `${r.path}->${r.type}`, refCount = counts[doc.name]?.outgoing?.[pathKey];
+    return typeof refCount != "number" || refCount <= 0 ? null : `${pathKey}${formatReferenceCount(refCount)}`;
+  }).filter(Boolean).join(", ") || "";
+  if (doc.incomingReferences.length === 0) return { outgoing, incoming: "" };
+  const incomingParts = [];
+  for (const sourceType of [...doc.incomingReferences].sort()) {
+    const sourceCounts = counts[sourceType];
+    let total = 0;
+    if (sourceCounts?.outgoing) {
+      const suffix = `->${doc.name}`;
+      for (const [pathKey, pathCount] of Object.entries(sourceCounts.outgoing))
+        pathKey.endsWith(suffix) && typeof pathCount == "number" && pathCount > 0 && (total += pathCount);
+    }
+    total > 0 && incomingParts.push(`${sourceType}${formatReferenceCount(total)}`);
+  }
+  return { outgoing, incoming: incomingParts.join(", ") };
+}
+function formatRefsSimple(doc) {
+  return {
+    outgoing: doc.outgoingReferences.length > 0 ? [...doc.outgoingReferences].sort().join(", ") : "",
+    incoming: doc.incomingReferences.length > 0 ? [...doc.incomingReferences].sort().join(", ") : ""
+  };
+}
+function formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats) {
+  if (shouldSkipType(name)) return null;
+  const { documentCount, referenceCount } = datasetStats ?? {}, hasDocumentCounts = !!documentCount, count = documentCount?.[name] ?? 0;
+  if (documentCount && documentCount[name] === 0) return null;
+  const useCount = formatDocumentCount(count, hasDocumentCounts);
+  if (doc.deprecated)
+    return `- ${name} (DEPRECATED: "${doc.deprecated.reason}", count: ${useCount})`;
+  const refs = referenceCount ? formatRefsWithCounts(doc, referenceCount) : formatRefsSimple(doc), depth = calculateMaxDepth(doc.fields, objectTypes), fieldNames = formatFieldNamesWithTypes(doc.fields, fieldOptions), indent = "  ", parts = [`- ${name} (title: ${doc.titleField}, depth: ${depth}, count: ${useCount})`];
+  if (doc.description) {
+    const maxLen = SCHEMA_CONSTANTS.DEFAULTS.maxDocDescriptionLength, desc = doc.description.length > maxLen ? `${doc.description.slice(0, maxLen)}...` : doc.description;
+    parts.push(`${indent}- description: ${desc}`);
+  }
+  return parts.push(`${indent}- fields: ${fieldNames}`), refs.outgoing && parts.push(`${indent}- references: ${refs.outgoing}`), refs.incoming && parts.push(`${indent}- referenced by: ${refs.incoming}`), parts.join(`
+`);
+}
+function formatCompressedSchema(documentTypes, objectTypes, fieldOptions, datasetStats) {
+  return [...documentTypes.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, doc]) => formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats)).filter(Boolean).join(`
+`);
+}
+async function compressedSchema(types, options = {}) {
+  const includeTypes = await resolveFilter(types, options.filter), { documentTypes, objectTypes } = processSchema(types, {
+    filter: includeTypes
+  });
+  return formatCompressedSchema(
+    documentTypes,
+    objectTypes,
+    options.fields ?? {},
+    options.datasetStats
+  );
+}
+export {
+  ARRAY_ITEM_SYSTEM_FIELDS,
+  BUILT_IN_TYPE_FIELDS,
+  DEFAULT_LINK_ANNOTATION,
+  DatasetStatsSchema,
+  SCHEMA_CONSTANTS,
+  compressedSchema,
+  fetchDatasetStats,
+  fetchSchemaByDescriptorId,
+  filterToPath,
+  fullSchema,
+  isBuiltInType,
+  isGenericObject,
+  isPrimitiveType,
+  resolveFieldSchema as navigateToFieldSchema,
+  resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions,
+  processSchema,
+  resolveFieldSchema,
+  resolveFieldSchemaAllUnions,
+  shouldSkipType,
+  toSchemaPath
+};
+//# sourceMappingURL=index.js.map