@sanity/agent-schema 0.0.4 → 0.2.0

package/dist/index.d.ts

@@ -1,171 +1,5 @@
+import { _ as SchemaFieldDisplayOptions, a as ValidateValueFn, b as SchemaTypes, c as ValidationErrorCode, d as DatasetStats, f as DatasetStatsSchema, g as ProcessedDocumentType, h as ManifestSchemaType, i as PatchOperations, l as ValidationResult, m as ManifestField, n as InsertOperation, o as ValidationContext, p as LexiconResponse, r as LocalizationConfig, s as ValidationError, t as FieldSchemaLookupResult, u as CompressedSchemaOptions, v as SchemaFilter, y as SchemaProcessorOptions } from "./_chunks-dts/types.js";
 import { SanityClient } from "@sanity/client";
-import { z } from "zod";
-type ManifestSerializable = string | number | boolean | {
-  [k: string]: ManifestSerializable;
-} | ManifestSerializable[];
-type ManifestSchemaType = {
-  type: string;
-  name: string;
-  title?: string;
-  description?: string;
-  deprecated?: {
-    reason: string;
-  };
-  readOnly?: boolean | 'conditional';
-  hidden?: boolean | 'conditional';
-  validation?: ManifestValidationGroup[];
-  fields?: ManifestField[];
-  to?: ManifestReferenceMember[];
-  of?: ManifestArrayMember[];
-  preview?: {
-    select: Record<string, string>;
-  };
-  fieldsets?: ManifestFieldset[];
-  options?: Record<string, ManifestSerializable>;
-  marks?: {
-    annotations?: ManifestArrayMember[];
-    decorators?: ManifestTitledValue[];
-  };
-  lists?: ManifestTitledValue[];
-  styles?: ManifestTitledValue[];
-  [index: string]: unknown;
-};
-type ManifestFieldset = {
-  name: string;
-  title?: string;
-  [index: string]: ManifestSerializable | undefined;
-};
-type ManifestTitledValue = {
-  value: string;
-  title?: string;
-};
-type ManifestField = ManifestSchemaType & {
-  fieldset?: string;
-};
-type ManifestArrayMember = Omit<ManifestSchemaType, 'name'> & {
-  name?: string;
-};
-type ManifestReferenceMember = Omit<ManifestSchemaType, 'name'> & {
-  name?: string;
-};
-type ManifestValidationGroup = {
-  rules: ManifestValidationRule[];
-  message?: string;
-  level?: 'error' | 'warning' | 'info';
-};
-type ManifestValidationRule = {
-  flag: 'presence' | string;
-  constraint?: 'required' | ManifestSerializable;
-  [index: string]: ManifestSerializable | undefined;
-};
-type HoistedEntry = {
-  name: string;
-  typeDef: TypeDef;
-  groups?: unknown;
-  fieldset?: unknown;
-};
-type HoistedMarker = {
-  __type: 'hoisted';
-  key: string;
-};
-type InlineOrHoisted = {
-  name: string;
-  typeDef: TypeDef;
-} | HoistedMarker;
-type LexiconResponse = {
-  types: Record<string, TypeDef>;
-  hoisted: Record<string, HoistedEntry>;
-  registries?: string[];
-};
-type TypeDef = {
-  extends: string;
-  fields?: InlineOrHoisted[];
-  to?: Array<{
-    name: string;
-  }>;
-  of?: InlineOrHoisted[];
-  fieldsets?: string[];
-  validation?: unknown;
-  [key: string]: unknown;
-};
-declare const DatasetStatsSchema: z.ZodObject<{
-  documentCount: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-  referenceCount: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-    incoming: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>>;
-    outgoing: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>>;
-  }, "strip", z.ZodTypeAny, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }>>>;
-}, "strip", z.ZodTypeAny, {
-  documentCount?: Record<string, number> | undefined;
-  referenceCount?: Record<string, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }> | undefined;
-}, {
-  documentCount?: Record<string, number> | undefined;
-  referenceCount?: Record<string, {
-    incoming: Record<string, number | "unknown">;
-    outgoing: Record<string, number | "unknown">;
-  }> | undefined;
-}>;
-type DatasetStats = z.infer<typeof DatasetStatsSchema>;
-type ReferenceInfo = {
-  type: string;
-  path: string;
-};
-type ProcessedDocumentType = {
-  name: string;
-  title?: string;
-  description?: string;
-  deprecated?: {
-    reason: string;
-  };
-  liveEdit?: boolean;
-  titleField: string;
-  fields: ManifestField[];
-  outgoingReferences: string[];
-  incomingReferences: string[];
-  outgoingReferencePaths?: ReferenceInfo[];
-  incomingReferencePaths?: ReferenceInfo[];
-};
-type SchemaTypes = {
-  documentTypes: Map<string, ProcessedDocumentType>;
-  objectTypes: Map<string, ManifestSchemaType>;
-};
-/**
- * Filter document types by GROQ expressions or an explicit list.
- * - `{ read?, write? }` — GROQ boolean expressions (requires groq-js peer dep).
- *   Types matching either expression are included (union).
- * - `string[]` — explicit list of document type names to include.
- * - `undefined` / empty — include all document types.
- */
-type SchemaFilter = {
-  read?: string;
-  write?: string;
-} | string[];
-type SchemaFieldDisplayOptions = {
-  showAll?: boolean;
-  maxCount?: number;
-  includeDescription?: boolean;
-  includeHidden?: boolean;
-  includeDeprecated?: boolean;
-  maxEnumValues?: number;
-  maxDescriptionLength?: number;
-};
-type CompressedSchemaOptions = {
-  datasetStats?: DatasetStats;
-  filter?: SchemaFilter;
-  fields?: SchemaFieldDisplayOptions;
-};
-type SchemaProcessorOptions = {
-  filter?: SchemaFilter;
-  fields?: SchemaFieldDisplayOptions;
-};
 type DatasetStatsResult = {
   status: 'ready';
   stats: DatasetStats;
@@ -353,5 +187,5 @@ declare function shouldSkipType(typeName: string): boolean;
  * a pre-resolved `string[]` of document type names.
  */
 declare function compressedSchema(types: ManifestSchemaType[], options?: CompressedSchemaOptions): Promise<string>;
-export { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, type CompressedSchemaOptions, DEFAULT_LINK_ANNOTATION, type DatasetStats, DatasetStatsSchema, type FetchSchemaOptions, type FullSchemaOptions, type ManifestField, type ManifestSchemaType, type ProcessedDocumentType, SCHEMA_CONSTANTS, type SchemaCache, type SchemaFieldDisplayOptions, type SchemaFilter, type SchemaTypes, compressedSchema, fetchDatasetStats, fetchSchemaByDescriptorId, filterToPath, fullSchema, isBuiltInType, isGenericObject, isPrimitiveType, resolveFieldSchema as navigateToFieldSchema, resolveFieldSchema, resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions, resolveFieldSchemaAllUnions, processSchema, shouldSkipType, toSchemaPath };
+export { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, type CompressedSchemaOptions, DEFAULT_LINK_ANNOTATION, type DatasetStats, DatasetStatsSchema, type FetchSchemaOptions, type FieldSchemaLookupResult, type FullSchemaOptions, type InsertOperation, type LocalizationConfig, type ManifestField, type ManifestSchemaType, type PatchOperations, type ProcessedDocumentType, SCHEMA_CONSTANTS, type SchemaCache, type SchemaFieldDisplayOptions, type SchemaFilter, type SchemaTypes, type ValidateValueFn, type ValidationContext, type ValidationError, type ValidationErrorCode, type ValidationResult, compressedSchema, fetchDatasetStats, fetchSchemaByDescriptorId, filterToPath, fullSchema, isBuiltInType, isGenericObject, isPrimitiveType, resolveFieldSchema as navigateToFieldSchema, resolveFieldSchema, resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions, resolveFieldSchemaAllUnions, processSchema, shouldSkipType, toSchemaPath };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/fetchDatasetStats.ts","../src/fetchSchemaByDescriptorId.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/fullSchema.ts","../src/constants.ts","../src/utils.ts","../src/index.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/fetchDatasetStats.ts","../src/fetchSchemaByDescriptorId.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/fullSchema.ts","../src/constants.ts","../src/utils.ts","../src/index.ts"],"mappings":";;KAGK,kBAAA;EAAuB,MAAA;EAAiB,KAAA,EAAO,YAAA;AAAA;EAAmB,MAAA;AAAA;AAAA,KAElE,wBAAA;EACH,cAAA;EACA,SAAA;EACA,OAAA;AAAA;AAL2E;;;;;;;;;AAAA,iBAiBvD,iBAAA,CACpB,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,wBAAA,GACR,OAAA,CAAQ,kBAAA;;AAtBmC;;;KCelC,WAAA;EACV,GAAA,GAAM,YAAA,aAAyB,OAAA,CAAQ,eAAA;EACvC,GAAA,GAAM,YAAA,UAAsB,QAAA,EAAU,eAAA,KAAoB,OAAA;AAAA;AAAA,KAmBhD,kBAAA;EDlCiE;;AAAA;;;ECwC3E,KAAA,aAAkB,WAAA,EDrClB;ECuCA,KAAA;AAAA;;;ADzBF;;;;;;;iBCqCsB,yBAAA,CACpB,MAAA,EAAQ,YAAA,EACR,YAAA,UACA,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,kBAAA;;;AD5DmC;;iBEqJ9B,aAAA,CACd,MAAA,EAAQ,kBAAA,IACR,OAAA,GAAU,sBAAA,GACT,WAAA;;;AFxJ2C;;cGKjC,oBAAA,EAAsB,MAAA,SAAe,MAAA,SAAe,kBAAA;;;;;cA2EpD,uBAAA,EAAyB,kBAAA;;;AH9EuC;cG0FhE,wBAAA,EAA0B,MAAA,SAAe,kBAAA;;;;;;;;;AH1FuB;;;;;;iBI+J7D,YAAA,CACd,IAAA,EAAM,kBAAA,EACN,IAAA,UACA,MAAA,EAAQ,kBAAA,KACP,kBAAA;;;AJrK2C;;;iBKQ9B,2BAAA,CACd,IAAA,UACA,UAAA,EAAY,kBAAA,EACZ,MAAA,EAAQ,kBAAA,KACP,kBAAA;;;ALZ2C;;;;;;iBMyK9B,kBAAA,CACd,IAAA,UACA,UAAA,EAAY,kBAAA,EACZ,MAAA,EAAQ,kBAAA,KACP,kBAAA;;;;AN7K2C;;;;;;;;;;iBOY9B,YAAA,CAAa,IAAA;;;;APZiB;;;;iBQU9B,eAAA,CACd,QAAA,sBACA,OAAA;EAAW,iBAAA;AAAA;;;;ARVgE;iBQuB7D,aAAA,CAAc,IAAA;;;;;;;iBA4Bd,eAAA,CAAgB,IAAA;AAAA,KCjDpB,iBAAA;wDAEV,IAAA,UTJqB;ESMrB,IAAA,WTN8D;ESQ9D,aAAA;AAAA;AAAA,KAGG,kBAAA;EACH,aAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA,EAAU,KAAA;IAAQ,IAAA;IAAc,IAAA;EAAA;EAChC,IAAA;AAAA;;;;ATCF;;;;;;;;iBSagB,UAAA,CACd,MAAA,EAAQ,kBAAA,IACR,OAAA,EAAS,iBAAA,GACR,MAAA,oBAA0B,kBAAA;AAAA,cCpChB,gBAAA;EAAA,wBAkBH,MAAA;EAAA;;;;;;;;;;;;;;iBChBM,cAAA,CAAe,QAAA;;;;;;;AXkB/B;;;iBYmFsB,gBAAA,CACpB,KAAA,EAAO,kBAAA,IACP,OAAA,GAAS,uBAAA,GACR,OAAA"}

package/dist/index.js

@@ -1,3 +1,6 @@
+import { convertToDefinition } from "@sanity/schema-descriptor-utils";
+import { isPrimitiveType, isGenericObject } from "./_chunks-es/navigateToField.js";
+import { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, DEFAULT_LINK_ANNOTATION, isBuiltInType, resolveFieldSchema, resolveFieldSchemaAllUnions, resolveFieldSchema as resolveFieldSchema2, resolveFieldSchemaAllUnions as resolveFieldSchemaAllUnions2, toSchemaPath } from "./_chunks-es/navigateToField.js";
 import { z } from "zod";
 async function fetchDatasetStats(client, options) {
   const { organizationId, projectId, dataset } = options, response = await client.request({
@@ -5,116 +8,8 @@ async function fetchDatasetStats(client, options) {
   });
   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;
-    let marks;
-    if (type === "block" && fields) {
-      const markDefsOf = fields.find((f) => isHoistedMarker(f) ? !1 : f.name === "markDefs")?.typeDef?.of;
-      markDefsOf && markDefsOf.length > 0 && (marks = {
-        annotations: markDefsOf.map(convertArrayElement)
-      });
-    }
-    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,
-      marks,
-      ...decodeWithMarkers(rest)
-    });
-  }
-  const types = [];
-  for (const [name, typeDef] of Object.entries(input.types))
-    types.push(convertTypeDef(name, typeDef));
-  return types;
+function convert(input) {
+  return convertToDefinition(input).types;
 }
 const DEFAULT_TTL_MS = 300 * 1e3, memoryCache = /* @__PURE__ */ new Map();
 function getFromMemoryCache(descriptorId) {
@@ -134,16 +29,16 @@ 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);
+    if (hit) return convert(hit);
   } else if (cache) {
     const hit = await cache.get(descriptorId);
-    if (hit) return convertToDefinition(hit);
+    if (hit) return convert(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);
+  }), convert(response);
 }
 const SCHEMA_CONSTANTS = {
   SKIP_PATTERNS: /^(system\.|sanity\.|assist\.|media\.|mux\.)/,
@@ -288,86 +183,6 @@ function processSchema(schema, options) {
     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;
@@ -539,188 +354,6 @@ function filterToPath(type, path, schema) {
   }
   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);
 }
@@ -1005,14 +638,14 @@ function formatRefsSimple(doc) {
     incoming: doc.incomingReferences.length > 0 ? [...doc.incomingReferences].sort().join(", ") : ""
   };
 }
-function formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats) {
+function formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats, includeEmpty = !1) {
   if (shouldSkipType(name)) return null;
-  const { documentCount, referenceCount } = datasetStats ?? {}, hasDocumentCounts = !!documentCount, count = documentCount?.[name] ?? 0;
-  if (documentCount && documentCount[name] === 0) return null;
+  const { documentCount, referenceCount } = datasetStats ?? {}, hasDocumentCounts = !!documentCount, count = documentCount?.[name] ?? 0, isExplicitZero = !!documentCount && documentCount[name] === 0;
+  if (isExplicitZero && !includeEmpty) 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 = "  ", liveEditFlag = doc.liveEdit ? "liveEdit, " : "", parts = [
+  const refs = referenceCount && !isExplicitZero ? formatRefsWithCounts(doc, referenceCount) : formatRefsSimple(doc), depth = calculateMaxDepth(doc.fields, objectTypes), fieldNames = formatFieldNamesWithTypes(doc.fields, fieldOptions), indent = "  ", liveEditFlag = doc.liveEdit ? "liveEdit, " : "", parts = [
     `- ${name} (${liveEditFlag}title: ${doc.titleField}, depth: ${depth}, count: ${useCount})`
   ];
   if (doc.description) {
@@ -1022,8 +655,10 @@ function formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats) {
   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(`
+function formatCompressedSchema(documentTypes, objectTypes, fieldOptions, datasetStats, includeEmpty) {
+  return [...documentTypes.entries()].sort(([a], [b]) => a.localeCompare(b)).map(
+    ([name, doc]) => formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats, includeEmpty)
+  ).filter(Boolean).join(`
 `);
 }
 async function compressedSchema(types, options = {}) {
@@ -1034,7 +669,8 @@ async function compressedSchema(types, options = {}) {
     documentTypes,
     objectTypes,
     options.fields ?? {},
-    options.datasetStats
+    options.datasetStats,
+    options.includeEmpty
   );
 }
 export {
@@ -1054,8 +690,8 @@ export {
   resolveFieldSchema as navigateToFieldSchema,
   resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions,
   processSchema,
-  resolveFieldSchema,
-  resolveFieldSchemaAllUnions,
+  resolveFieldSchema2 as resolveFieldSchema,
+  resolveFieldSchemaAllUnions2 as resolveFieldSchemaAllUnions,
   shouldSkipType,
   toSchemaPath
 };