@sanity/agent-schema 0.0.2 → 0.0.4

package/README.md

@@ -1,14 +1,16 @@
 # @sanity/agent-schema
 
-Schema processing utilities for Sanity Agent. Parses Lexicon schemas, compresses them for LLM context, provides full JSON views for schema explorers, and navigates schema trees for validation and mutation agents.
+Schema utilities for Sanity Agent. Fetches Lexicon schemas, compresses them for LLM context windows, provides full JSON views for schema explorers, and resolves field definitions for validation and mutation agents.
 
 ## Install
 
-```bash
-pnpm add @sanity/agent-schema
+```sh
+pnpm add @sanity/agent-schema @sanity/client groq-js
 ```
 
-## Quick start
+## Getting started
+
+The most common workflow: fetch a schema, optionally enrich it with dataset stats, and compress it into text for an LLM.
 
 ```ts
 import {
@@ -17,10 +19,13 @@ import {
   compressedSchema,
 } from "@sanity/agent-schema";
 
-// 1. Fetch and parse the schema
+// 1. Fetch and parse the schema from Lexicon
+//    The `lexiconClient` should target the Lexicon API host.
+//    `descriptorId` identifies a specific schema version (typically from an application resource).
 const types = await fetchSchemaByDescriptorId(lexiconClient, descriptorId);
 
-// 2. Optionally fetch dataset stats (enriches output with counts)
+// 2. Optionally fetch dataset stats (document/reference counts)
+//    The `agentClient` should target the agent API host with `useProjectHostname: false`.
 const statsResult = await fetchDatasetStats(agentClient, {
   organizationId,
   projectId,
@@ -34,7 +39,128 @@ const text = await compressedSchema(types, {
 });
 ```
 
-## API
+The result is a compact text summary of your document types, fields, references, and counts — ready to drop into an LLM system prompt.
+
+## Usage
+
+### Compress a schema for LLM context
+
+`compressedSchema` is the main entry point for generating LLM-ready text. It accepts parsed schema types and returns a compact summary.
+
+```ts
+import { compressedSchema } from "@sanity/agent-schema";
+
+// Filter by GROQ expression
+const text = await compressedSchema(types, {
+  filter: { read: '_type in ["post", "author"]' },
+});
+
+// Filter by explicit type list
+const text = await compressedSchema(types, {
+  filter: ["post", "author"],
+});
+
+// All options
+const text = await compressedSchema(types, {
+  filter: { read: '_type == "post"', write: '_type == "draft"' },
+  datasetStats,
+  fields: { maxCount: 5, includeDescription: true },
+});
+```
+
+### Browse full schema JSON
+
+`fullSchema` returns the complete JSON structure of a type — every field, nested object, validation rule, and option. Used by schema explorer tools.
+
+```ts
+import { fullSchema } from "@sanity/agent-schema";
+
+// Get the entire type
+fullSchema(types, { type: "post" });
+// => { name: "post", type: "document", fields: [...] }
+
+// Zoom into a specific field path
+fullSchema(types, { type: "post", path: "content[].codeBlock" });
+// => { name: "codeBlock", type: "object", fields: [...] }
+```
+
+Large types automatically return a navigator object with child paths to drill into, instead of blowing up the response. Control this with `sizeThreshold` (default 200KB).
+
+### Resolve a field at a path
+
+`resolveFieldSchema` answers "what type is the value at this path?" — used by validators and mutation code.
+
+```ts
+import { resolveFieldSchema } from "@sanity/agent-schema";
+
+resolveFieldSchema("content[0].text", postSchema, allTypes);
+// => { name: "text", type: "string" }
+
+resolveFieldSchema("tags", postSchema, allTypes);
+// => { name: "tags", type: "array", of: [...] }
+
+resolveFieldSchema("nonexistent.path", postSchema, allTypes);
+// => null
+```
+
+For union arrays where the same path exists in multiple item types, use `resolveFieldSchemaAllUnions` to get all matches:
+
+```ts
+import { resolveFieldSchemaAllUnions } from "@sanity/agent-schema";
+
+resolveFieldSchemaAllUnions("content", postSchema, allTypes);
+// => [blockSchema, imageSchema, codeSchema]
+```
+
+### Process schema for custom tooling
+
+`processSchema` is the core transformation step. It categorizes types, expands inline object references, computes bidirectional reference graphs, and identifies title fields. This is what `compressedSchema` uses internally.
+
+```ts
+import { processSchema } from "@sanity/agent-schema";
+
+const { documentTypes, objectTypes } = processSchema(types, {
+  filter: ["post", "author"],
+});
+
+// documentTypes: Map<string, ProcessedDocumentType>
+// objectTypes: Map<string, ManifestSchemaType>
+
+for (const [name, doc] of documentTypes) {
+  console.log(doc.titleField); // "title"
+  console.log(doc.outgoingReferences); // ["author", "category"]
+  console.log(doc.incomingReferences); // ["comment"]
+  console.log(doc.outgoingReferencePaths); // [{ type: "author", path: "author" }]
+}
+```
+
+Use this when you need the processed data structures without the text formatting — for custom schema visualizations, reference analysis, or building infrastructure like document counters.
+
+## Architecture
+
+```
+fetchSchemaByDescriptorId()                fetchDatasetStats()
+         │                                          │
+         ▼                                          ▼
+  ManifestSchemaType[]                      DatasetStatsResult
+         │                                          │
+         ├──► compressedSchema()  ◄─────────────────┘
+         │        ──► text summary of all types
+         │
+         ├──► fullSchema()
+         │        ──► JSON subtree of one type (all fields expanded)
+         │
+         ├──► resolveFieldSchema()
+         │        ──► single field definition at a path
+         │
+         ├──► resolveFieldSchemaAllUnions()
+         │        ──► same, all union branches
+         │
+         └──► processSchema()
+                  ──► categorize types, expand fields, compute refs
+```
+
+## API reference
 
 ### Fetch
 
@@ -42,11 +168,13 @@ const text = await compressedSchema(types, {
 
 Fetches a schema from the Lexicon API and returns parsed `ManifestSchemaType[]`.
 
+The `client` should be a `@sanity/client` instance configured for the Lexicon API host. The `descriptorId` identifies a specific schema version — typically obtained from an application resource.
+
 ```ts
 const types = await fetchSchemaByDescriptorId(client, descriptorId);
 ```
 
-Enable caching with `{ cache: true }` (in-memory, 5 min TTL) or a custom adapter:
+**Caching:** Pass `{ cache: true }` for a built-in in-memory cache (5 min TTL), or provide a custom adapter:
 
 ```ts
 // Built-in memory cache
@@ -61,9 +189,16 @@ const types = await fetchSchemaByDescriptorId(client, id, {
 });
 ```
 
+| Option  | Type                     | Default  | Description                                               |
+| ------- | ------------------------ | -------- | --------------------------------------------------------- |
+| `cache` | `boolean \| SchemaCache` |          | Enable caching. `true` for in-memory, or a custom adapter |
+| `ttlMs` | `number`                 | `300000` | Cache TTL in ms (only applies to built-in memory cache)   |
+
 #### `fetchDatasetStats(client, options)`
 
-Fetches document and reference counts from the agent API. Returns `{ status: 'ready', stats }` or `{ status: 'processing' }` if still being computed.
+Fetches document and reference counts from the agent API. Returns `{ status: 'ready', stats }` or `{ status: 'processing' }` if stats are still being computed.
+
+The `client` should be configured to point at the agent API host (e.g. `api.sanity.io`) with `useProjectHostname: false`.
 
 ```ts
 const result = await fetchDatasetStats(client, {
@@ -82,28 +217,7 @@ if (result.status === "ready") {
 
 #### `compressedSchema(types, options?)`
 
-The main entry point. Takes parsed types and returns compact text for agents.
-
-The `filter` option controls which document types to include. Pass a GROQ filter (requires `groq-js` peer dep) or an explicit list of type names:
-
-```ts
-// GROQ filter — types are inferred from the expression
-await compressedSchema(types, {
-  filter: { read: '_type in ["post", "author"]' },
-});
-
-// Explicit type list
-await compressedSchema(types, {
-  filter: ["post", "author"],
-});
-
-// All options
-await compressedSchema(types, {
-  filter: { read: '_type == "post"', write: '_type == "draft"' },
-  datasetStats,
-  fields: { maxCount: 5, includeDescription: true },
-});
-```
+Generates compressed text for agent consumption. Processes the schema, applies filters, and formats the output.
 
 | Option         | Type                        | Description                                   |
 | -------------- | --------------------------- | --------------------------------------------- |
@@ -127,78 +241,76 @@ await compressedSchema(types, {
 
 #### `fullSchema(types, options)`
 
-Returns a **JSON subtree** of a schema type — everything inside it (all fields, nested objects, validation rules, options). Used by schema explorer tools to let the LLM browse type structures.
+Returns the complete JSON structure for a schema type, optionally scoped to a field path.
 
-Without `path`, you get the entire type. With `path`, you get the subtree rooted at that field — still the full structure from that point down, just scoped to a smaller starting point. This is useful because some types are huge; `path` lets you zoom in.
+Without `path`, you get the entire type. With `path`, you get the subtree rooted at that field. This is useful because some types are huge — `path` lets you zoom in without fetching the whole thing.
 
-```ts
-import { fullSchema } from "@sanity/agent-schema";
+When the output exceeds `sizeThreshold`, a navigator object is returned instead with child paths to drill into:
 
-fullSchema(types, { type: "post" });
-// Returns: { name: "post", type: "document", fields: [
-//   { name: "title", type: "string" },
-//   { name: "content", type: "array", of: [
-//     { name: "block", type: "block", marks: {...}, styles: [...], ... },
-//     { name: "codeBlock", type: "object", fields: [
-//       { name: "language", type: "string", options: { list: [...] } },
-//       { name: "code", type: "text" },
-//     ]},
-//   ]},
-//   ... every field, fully expanded ...
-// ]}
-
-// Same structure, just starting from content[].codeBlock instead of the root
-fullSchema(types, { type: "post", path: "content[].codeBlock" });
-// Returns: { name: "codeBlock", type: "object", fields: [
-//   { name: "language", type: "string", options: { list: [...] } },
-//   { name: "code", type: "text" },
-// ]}
+```ts
+// Navigator shape (returned when output is too large)
+{
+  _rawLargeNode: true,
+  name: "post",
+  type: "document",
+  children: [
+    { type: "array", path: "content[]" },
+    { type: "object", path: "metadata" },
+  ],
+  hint: "This node is large. Fetch a specific child path to drill in."
+}
 ```
 
-If the output exceeds `sizeThreshold`, a navigator object is returned instead with child paths to drill into.
-
 | Option          | Type     | Default  | Description                                           |
 | --------------- | -------- | -------- | ----------------------------------------------------- |
 | `type`          | `string` | required | Document type name to return                          |
 | `path`          | `string` |          | Field path — returns the subtree from this point down |
 | `sizeThreshold` | `number` | `200KB`  | Byte limit before returning a navigator instead       |
 
-### Navigate
+### Process
 
-#### `resolveFieldSchema(path, typeSchema, schema)`
+#### `processSchema(types, options?)`
+
+Processes raw `ManifestSchemaType[]` into categorized, enriched data structures. This is the core transformation that `compressedSchema` uses internally.
 
-Returns the **single field definition** at the end of a path. No subtree, no nested fields — just the node itself. Used by validators and mutation code that need to answer "what type is the value at this path?"
+Returns a `SchemaTypes` object:
 
 ```ts
-import { resolveFieldSchema } from "@sanity/agent-schema";
+type SchemaTypes = {
+  documentTypes: Map<string, ProcessedDocumentType>;
+  objectTypes: Map<string, ManifestSchemaType>;
+};
+```
 
-resolveFieldSchema("content[0].text", postSchema, allTypes);
-// Returns: { name: "text", type: "string" }
-//
-// Compare with fullSchema — that would return the entire content array
-// with all its item types expanded. This just tells you "it's a string."
+Each `ProcessedDocumentType` contains:
+
+| Property                 | Type               | Description                        |
+| ------------------------ | ------------------ | ---------------------------------- |
+| `name`                   | `string`           | Document type name                 |
+| `title`                  | `string?`          | Human-readable title               |
+| `description`            | `string?`          | Type description                   |
+| `deprecated`             | `object?`          | Deprecation info with reason       |
+| `titleField`             | `string`           | Best candidate for display title   |
+| `fields`                 | `ManifestField[]`  | Expanded field definitions         |
+| `outgoingReferences`     | `string[]`         | Types this document references     |
+| `incomingReferences`     | `string[]`         | Types that reference this document |
+| `outgoingReferencePaths` | `ReferenceInfo[]?` | Outgoing refs with field paths     |
+| `incomingReferencePaths` | `ReferenceInfo[]?` | Incoming refs with field paths     |
+
+| Option   | Type                        | Description                             |
+| -------- | --------------------------- | --------------------------------------- |
+| `filter` | `SchemaFilter`              | GROQ filter or `string[]` of type names |
+| `fields` | `SchemaFieldDisplayOptions` | Field display options                   |
 
-resolveFieldSchema("tags", postSchema, allTypes);
-// Returns: { name: "tags", type: "array", of: [...] }
-//
-// You get the field node, not the expanded contents of every array item.
+### Navigate
 
-resolveFieldSchema("nonexistent.path", postSchema, allTypes);
-// Returns: null
-```
+#### `resolveFieldSchema(path, typeSchema, schema)`
 
-Handles nested objects, array indices, built-in type fields (`slug.current`, `block.children`), and type references.
+Returns the single field definition at the end of a path. Handles nested objects, array indices, built-in type fields (`slug.current`, `block.children`), and type references. Returns `null` if the path doesn't resolve.
 
 #### `resolveFieldSchemaAllUnions(path, typeSchema, schema)`
 
-Same as `resolveFieldSchema`, but when the path crosses a union array, returns the field definition from **every** item type instead of just the first match.
-
-```ts
-import { resolveFieldSchemaAllUnions } from "@sanity/agent-schema";
-
-resolveFieldSchemaAllUnions("content", postSchema, allTypes);
-// Returns: [blockSchema, imageSchema, codeSchema]
-```
+Same as `resolveFieldSchema`, but when the path crosses a union array, returns the field definition from every item type instead of just the first match.
 
 #### `filterToPath(type, path, schema)`
 
@@ -221,57 +333,77 @@ toSchemaPath('content[_key=="abc"].children[0].text');
 // "content.children.text"
 ```
 
-#### Type helpers
+### Type helpers
+
+#### `isPrimitiveType(type, options?)`
+
+Returns `true` for primitive types (`string`, `number`, `boolean`, `text`, `url`, `date`, `datetime`). Pass `{ includeBlockTypes: true }` to also include `block` and `span`.
+
+#### `isBuiltInType(type)`
+
+Returns `true` for Sanity built-in types (`image`, `file`, `slug`, `geopoint`, `reference`, `block`, `span`).
+
+#### `isGenericObject(node)`
+
+Returns `true` for object-like schema nodes without a `fields` array.
+
+#### `shouldSkipType(typeName)`
+
+Returns `true` for internal types that should be excluded from processing (types matching `system.*`, `sanity.*`, `assist.*`, `media.*`, `mux.*`).
+
+### Constants
+
+#### `BUILT_IN_TYPE_FIELDS`
+
+Maps built-in type names to their implicit field definitions:
 
 ```ts
-import {
-  isPrimitiveType,
-  isBuiltInType,
-  isGenericObject,
-} from "@sanity/agent-schema";
+import { BUILT_IN_TYPE_FIELDS } from "@sanity/agent-schema";
 
-isPrimitiveType("string"); // true
-isPrimitiveType("block", { includeBlockTypes: true }); // true
-isBuiltInType("image"); // true
-isGenericObject(node); // true for object-like nodes without fields array
+BUILT_IN_TYPE_FIELDS.slug.current; // { name: "current", type: "string" }
+BUILT_IN_TYPE_FIELDS.image.asset; // { name: "asset", type: "reference" }
+BUILT_IN_TYPE_FIELDS.block.children; // { name: "children", type: "array", of: [...] }
 ```
 
-#### Constants
+Supported types: `slug`, `geopoint`, `reference`, `image`, `file`, `block`, `span`.
+
+#### `ARRAY_ITEM_SYSTEM_FIELDS`
+
+System fields present on all array items:
 
 ```ts
-import {
-  BUILT_IN_TYPE_FIELDS,
-  ARRAY_ITEM_SYSTEM_FIELDS,
-} from "@sanity/agent-schema";
+import { ARRAY_ITEM_SYSTEM_FIELDS } from "@sanity/agent-schema";
 
-BUILT_IN_TYPE_FIELDS.slug.current; // { name: "current", type: "string" }
 ARRAY_ITEM_SYSTEM_FIELDS._key; // { name: "_key", type: "string" }
+ARRAY_ITEM_SYSTEM_FIELDS._type; // { name: "_type", type: "string" }
 ```
 
-## Types
+#### `DEFAULT_LINK_ANNOTATION`
 
-| Type                        | Description                                                     |
-| --------------------------- | --------------------------------------------------------------- |
-| `ManifestSchemaType`        | A parsed schema type (document, object, array, etc.)            |
-| `ManifestField`             | A field definition (ManifestSchemaType with optional fieldset)  |
-| `DatasetStats`              | `{ documentCount?, referenceCount? }`                           |
-| `CompressedSchemaOptions`   | Options for `compressedSchema()` (filter, datasetStats, fields) |
-| `SchemaFilter`              | `{ read?, write? }` GROQ filter or `string[]` of type names     |
-| `FullSchemaOptions`         | Options for `fullSchema()`                                      |
-| `SchemaFieldDisplayOptions` | Options for field display in `compressedSchema`                 |
-| `SchemaCache`               | Cache adapter for `fetchSchemaByDescriptorId`                   |
+The default link annotation Sanity adds to Portable Text blocks when no `marks.annotations` are declared.
 
-## Architecture
+#### `SCHEMA_CONSTANTS`
 
-```
-fetchSchemaByDescriptorId()         fetchDatasetStats()
-         │                                   │
-         ▼                                   │
-  ManifestSchemaType[]                       │
-         │                                   │
-         ├──► compressedSchema()               ──► text summary of all types
-         ├──► fullSchema()                     ──► JSON subtree of one type (all fields expanded)
-         ├──► resolveFieldSchema()              ──► single field definition at a path
-         ├──► resolveFieldSchemaAllUnions()      ──► same, all union branches
-         └──► processSchema()                  ──► categorize types, expand fields, compute refs
-```
+Internal constants used by the schema processor (skip patterns, title field candidates, default limits). Exported for consumers that need to extend the defaults.
+
+## Types
+
+| Type                        | Description                                                           |
+| --------------------------- | --------------------------------------------------------------------- |
+| `ManifestSchemaType`        | A parsed schema type (document, object, array, etc.)                  |
+| `ManifestField`             | A field definition (`ManifestSchemaType` with optional `fieldset`)    |
+| `DatasetStats`              | `{ documentCount?, referenceCount? }`                                 |
+| `DatasetStatsSchema`        | Zod schema for runtime validation of `DatasetStats`                   |
+| `CompressedSchemaOptions`   | Options for `compressedSchema()`                                      |
+| `SchemaFilter`              | `{ read?, write? }` GROQ filter or `string[]` of type names           |
+| `SchemaFieldDisplayOptions` | Field display options for `compressedSchema`                          |
+| `FullSchemaOptions`         | Options for `fullSchema()`                                            |
+| `SchemaCache`               | Cache adapter for `fetchSchemaByDescriptorId`                         |
+| `FetchSchemaOptions`        | Options for `fetchSchemaByDescriptorId`                               |
+| `ProcessedDocumentType`     | A document type after processing (fields expanded, refs computed)     |
+| `SchemaTypes`               | Return type of `processSchema` (`documentTypes` + `objectTypes` Maps) |
+| `SchemaProcessorOptions`    | Options for `processSchema()`                                         |
+
+### Deprecated aliases
+
+`navigateToFieldSchema` and `navigateToFieldSchemaAllUnions` are deprecated aliases for `resolveFieldSchema` and `resolveFieldSchemaAllUnions`. They will be removed in the next minor version.

package/dist/index.d.ts

@@ -125,6 +125,7 @@ type ProcessedDocumentType = {
   deprecated?: {
     reason: string;
   };
+  liveEdit?: boolean;
   titleField: string;
   fields: ManifestField[];
   outgoingReferences: string[];

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/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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"}

package/dist/index.js

@@ -92,6 +92,13 @@ function convertToDefinition(input) {
   );
   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,
@@ -100,6 +107,7 @@ function convertToDefinition(input) {
       of: of ? of.map(convertArrayElement) : void 0,
       to: to?.map(({ name: toName }) => mutableSqueeze({ type: toName })),
       validation,
+      marks,
       ...decodeWithMarkers(rest)
     });
   }
@@ -236,6 +244,7 @@ function processSchema(schema, options) {
         title: type.title,
         description: type.description,
         deprecated: type.deprecated,
+        liveEdit: type.liveEdit === !0 ? !0 : void 0,
         titleField: SCHEMA_CONSTANTS.DEFAULTS.titleField,
         fields: type.fields ?? [],
         outgoingReferences: [],
@@ -1003,7 +1012,9 @@ function formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats) {
   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})`];
+  const refs = referenceCount ? 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) {
     const maxLen = SCHEMA_CONSTANTS.DEFAULTS.maxDocDescriptionLength, desc = doc.description.length > maxLen ? `${doc.description.slice(0, maxLen)}...` : doc.description;
     parts.push(`${indent}- description: ${desc}`);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/fetchDatasetStats.ts","../src/convertToDefinition.ts","../src/fetchSchemaByDescriptorId.ts","../src/constants.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/utils.ts","../src/fullSchema.ts","../src/types.ts","../src/filterDocumentTypes.ts","../src/formatFields.ts","../src/formatSchema.ts","../src/index.ts"],"sourcesContent":["import type { SanityClient } from '@sanity/client'\nimport type { DatasetStats } from './types.js'\n\ntype DatasetStatsResult = { status: 'ready'; stats: DatasetStats } | { status: 'processing' }\n\ntype FetchDatasetStatsOptions = {\n  organizationId: string\n  projectId: string\n  dataset: string\n}\n\n/**\n * Fetches dataset stats (document counts, reference counts) from the agent API.\n *\n * Returns `{ status: 'processing' }` if stats are still being computed (HTTP 202).\n * The caller should retry after a short delay.\n *\n * The `client` should be configured to point at the agent API host\n * (e.g. `api.sanity.io`) with `useProjectHostname: false`.\n */\nexport async function fetchDatasetStats(\n  client: SanityClient,\n  options: FetchDatasetStatsOptions,\n): Promise<DatasetStatsResult> {\n  const { organizationId, projectId, dataset } = options\n\n  const response = await client.request<DatasetStats | { status: string }>({\n    uri: `/agent/${organizationId}/dataset-stats/${projectId}/${dataset}`,\n  })\n\n  if ('status' in response && response.status === 'processing') {\n    return { status: 'processing' }\n  }\n\n  return { status: 'ready', stats: response as DatasetStats }\n}\n","import type {\n  HoistedEntry,\n  HoistedMarker,\n  InlineOrHoisted,\n  LexiconResponse,\n  ManifestSchemaType,\n  TypeDef,\n} from './types.js'\n\nfunction isHoistedMarker(x: unknown): x is HoistedMarker {\n  if (x === null || typeof x !== 'object') return false\n  const obj = x as Record<string, unknown>\n  return obj.__type === 'hoisted' && typeof obj.key === 'string'\n}\n\nfunction mapperWithHoisting<U>(\n  hoisted: Record<string, HoistedEntry>,\n  map: (input: HoistedEntry) => U,\n): (input: InlineOrHoisted) => U {\n  const cache = new Map<string, U>()\n  return (entry) => {\n    if (isHoistedMarker(entry)) {\n      let result = cache.get(entry.key)\n      if (!result) {\n        const value = hoisted[entry.key]\n        if (!value) throw new Error(`Unknown hoisted key: ${entry.key}`)\n        result = map(value)\n        cache.set(entry.key, result)\n      }\n      return result\n    }\n    return map(entry as HoistedEntry)\n  }\n}\n\nconst STOP = Symbol('STOP')\n\nfunction decodeWithMarkers<T>(x: T): T | undefined {\n  const result = decodeWithMarkersOrStop(x)\n  if (result === STOP) return undefined\n  return result as T\n}\n\nfunction decodeWithMarkersOrStop(x: unknown): unknown {\n  if (x === null || x === undefined || typeof x !== 'object') return x\n\n  if (Array.isArray(x)) {\n    const result = []\n    for (const item of x) {\n      const decoded = decodeWithMarkers(item)\n      if (decoded === STOP) return STOP\n      result.push(decoded)\n    }\n    return result\n  }\n\n  if ('__type' in x) {\n    const typed = x as Record<string, unknown>\n    switch (typed.__type) {\n      case 'function':\n      case 'jsx':\n      case 'unknown':\n      case 'cyclic':\n      case 'maxDepth':\n        return STOP\n      case 'number':\n        return Number(typed.value)\n      case 'undefined':\n        return undefined\n      case 'object':\n        return decodeWithMarkersOrStop(typed.value)\n      default:\n        throw new Error(`unknown type: ${typed.__type}`)\n    }\n  }\n\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(x as Record<string, unknown>)) {\n    const decoded = decodeWithMarkers(value)\n    result[key] = decoded\n  }\n  return result\n}\n\nfunction mutableSqueeze<T extends Record<string, unknown>>(obj: T): T {\n  for (const [key, value] of Object.entries(obj)) {\n    if (value === undefined) delete obj[key]\n  }\n  return obj\n}\n\n/** Types whose raw `fields` array should be stripped during conversion. */\nconst STRIP_FIELDS_TYPES = new Set([\n  'block',\n  'reference',\n  'globalDocumentReference',\n  'crossDatasetReference',\n])\n\n/**\n * Converts a Lexicon schema descriptor response into an array of ManifestSchemaType.\n *\n * The Lexicon API returns a compact representation with hoisted (deduplicated) values.\n * This function expands the hoisted references and converts the compact TypeDef format\n * into the full ManifestSchemaType format used throughout the agent system.\n */\nexport function convertToDefinition(input: LexiconResponse): ManifestSchemaType[] {\n  if (!input?.types || Object.keys(input.types).length === 0) {\n    return []\n  }\n\n  const hoisted = input.hoisted ?? {}\n\n  const convertField = mapperWithHoisting(hoisted, (field) => ({\n    groups: field.groups,\n    fieldset: field.fieldset,\n    ...convertTypeDef(field.name, field.typeDef),\n  }))\n\n  const convertArrayElement = mapperWithHoisting(hoisted, (element) =>\n    convertTypeDef(element.name, element.typeDef),\n  )\n\n  function convertTypeDef(name: string, typeDef: TypeDef): Record<string, unknown> {\n    const { extends: type, fields, fieldsets, to, of, validation, ...rest } = typeDef\n\n    return mutableSqueeze({\n      name,\n      type,\n      fields: fields && !STRIP_FIELDS_TYPES.has(type) ? fields.map(convertField) : undefined,\n      fieldsets: (fieldsets?.length || 0) > 0 ? fieldsets : undefined,\n      of: of ? of.map(convertArrayElement) : undefined,\n      to: to?.map(({ name: toName }) => mutableSqueeze({ type: toName })),\n      validation,\n      ...decodeWithMarkers(rest),\n    })\n  }\n\n  const types: ManifestSchemaType[] = []\n  for (const [name, typeDef] of Object.entries(input.types)) {\n    types.push(convertTypeDef(name, typeDef) as ManifestSchemaType)\n  }\n  return types\n}\n","import type { SanityClient } from '@sanity/client'\nimport { convertToDefinition } from './convertToDefinition.js'\nimport type { LexiconResponse, ManifestSchemaType } from './types.js'\n\nconst DEFAULT_TTL_MS = 5 * 60 * 1000 // 5 minutes\n\ntype CacheEntry = { response: LexiconResponse; expiresAt: number }\n\n/**\n * Cache adapter for raw Lexicon API responses.\n * Wire this to any backing store (Redis, in-memory Map, etc.).\n */\nexport type SchemaCache = {\n  get: (descriptorId: string) => Promise<LexiconResponse | null | undefined>\n  set: (descriptorId: string, response: LexiconResponse) => Promise<void>\n}\n\nconst memoryCache = new Map<string, CacheEntry>()\n\nfunction getFromMemoryCache(descriptorId: string): LexiconResponse | undefined {\n  const entry = memoryCache.get(descriptorId)\n  if (!entry) return undefined\n  if (Date.now() > entry.expiresAt) {\n    memoryCache.delete(descriptorId)\n    return undefined\n  }\n  return entry.response\n}\n\nfunction setInMemoryCache(descriptorId: string, response: LexiconResponse, ttl: number): void {\n  memoryCache.set(descriptorId, { response, expiresAt: Date.now() + ttl })\n}\n\nexport type FetchSchemaOptions = {\n  /**\n   * Enable caching of raw Lexicon responses.\n   * - `true` uses a built-in in-memory cache with a 5-minute TTL\n   * - A `SchemaCache` adapter delegates to any external store (Redis, etc.)\n   */\n  cache?: boolean | SchemaCache\n  /** Cache TTL in milliseconds (default 5 min). Only applies to the built-in memory cache. */\n  ttlMs?: number\n}\n\n/**\n * Fetches and parses a schema from the Lexicon descriptor API.\n *\n * Takes a configured `@sanity/client` instance (which handles auth, host, timeouts)\n * and a descriptor ID. Returns the fully parsed ManifestSchemaType array.\n *\n * Pass `{ cache: true }` to enable in-memory caching (5 min TTL),\n * or provide a custom `SchemaCache` adapter for external stores.\n */\nexport async function fetchSchemaByDescriptorId(\n  client: SanityClient,\n  descriptorId: string,\n  options?: FetchSchemaOptions,\n): Promise<ManifestSchemaType[]> {\n  const { cache, ttlMs = DEFAULT_TTL_MS } = options ?? {}\n\n  // Check cache\n  if (cache === true) {\n    const hit = getFromMemoryCache(descriptorId)\n    if (hit) return convertToDefinition(hit)\n  } else if (cache) {\n    const hit = await cache.get(descriptorId)\n    if (hit) return convertToDefinition(hit)\n  }\n\n  const response = await client.request<LexiconResponse>({\n    uri: `/descriptors/schemas/${descriptorId}`,\n  })\n\n  // Populate cache\n  if (cache === true) {\n    setInMemoryCache(descriptorId, response, ttlMs)\n  } else if (cache) {\n    await cache.set(descriptorId, response).catch(() => {})\n  }\n\n  return convertToDefinition(response)\n}\n","export const SCHEMA_CONSTANTS = {\n  SKIP_PATTERNS: /^(system\\.|sanity\\.|assist\\.|media\\.|mux\\.)/,\n\n  TITLE_FIELD_CANDIDATES: ['title', 'name', 'heading', 'label'] as const,\n\n  DEFAULT_OPTIONS: {\n    trackPaths: true as boolean,\n    maxExpansionDepth: 1 as number,\n  },\n\n  DEFAULTS: {\n    titleField: 'title',\n    fallbackTitleField: '_id',\n    maxFieldsInSummary: 10 as number,\n    maxEnumValues: 10 as number,\n    maxDescriptionLength: 50 as number,\n    maxDocDescriptionLength: 512 as number,\n  },\n} as const\n","import { SCHEMA_CONSTANTS } from './constants.js'\nimport type {\n  ManifestSchemaType,\n  ProcessedDocumentType,\n  ReferenceInfo,\n  SchemaField,\n  SchemaFilter,\n  SchemaProcessorOptions,\n  SchemaTypes,\n} from './types.js'\n\n/**\n * Synchronously resolves a SchemaFilter to a string array.\n * Only handles the string[] case — GROQ filter objects must be\n * pre-resolved via `resolveFilter()` before calling `processSchema`.\n */\nfunction resolveFilterSync(filter: SchemaFilter | undefined): string[] | undefined {\n  if (!filter) return undefined\n  if (Array.isArray(filter)) return filter.length > 0 ? filter : undefined\n  // GROQ filter object — caller should have pre-resolved via resolveFilter()\n  // Ignore silently to avoid breaking sync callers\n  return undefined\n}\n\nconst TITLE_FIELD_CANDIDATES = SCHEMA_CONSTANTS.TITLE_FIELD_CANDIDATES\n\nfunction isTextLike(type: string): boolean {\n  return type === 'string' || type === 'text'\n}\n\nfunction findTitleField(fields: SchemaField[]): string {\n  for (const candidate of TITLE_FIELD_CANDIDATES) {\n    if (fields.some((f) => f.name === candidate && isTextLike(f.type))) return candidate\n  }\n\n  if (fields.some((f) => f.name === 'title')) return 'title'\n\n  const firstText = fields.find((f) => isTextLike(f.type))\n  return firstText?.name ?? SCHEMA_CONSTANTS.DEFAULTS.fallbackTitleField\n}\n\nfunction expandFields(\n  fields: SchemaField[],\n  objectTypes: Map<string, ManifestSchemaType>,\n  depth: number,\n): SchemaField[] {\n  if (depth <= 0) return fields\n\n  return fields.map((field) => {\n    const expanded = { ...field }\n\n    if (field.type && objectTypes.has(field.type)) {\n      const obj = objectTypes.get(field.type)!\n      expanded.type = 'object'\n      expanded.fields = expandFields(obj.fields ?? [], objectTypes, depth - 1)\n    }\n\n    if (Array.isArray(field.of)) {\n      expanded.of = field.of.map((item: Record<string, unknown>) => {\n        const itemType = item?.type as string | undefined\n        if (itemType && objectTypes.has(itemType)) {\n          const obj = objectTypes.get(itemType)!\n          return {\n            ...item,\n            type: 'object',\n            fields: expandFields((obj.fields ?? []) as SchemaField[], objectTypes, depth - 1),\n          }\n        }\n        return item\n      })\n    }\n\n    return expanded\n  })\n}\n\ntype RefTarget = { type?: string }\n\nfunction collectReferences(\n  fields: SchemaField[],\n  path: string,\n  included: (name: string) => boolean,\n  trackPaths: boolean,\n  outgoing: Set<string>,\n  outgoingPaths: ReferenceInfo[],\n  addIncoming: (targetType: string, sourceType: string, fieldPath: string) => void,\n  sourceType: string,\n): void {\n  for (const field of fields) {\n    const fieldPath = path ? `${path}.${field.name}` : field.name\n\n    if (field.type === 'reference' && field.to) {\n      for (const target of field.to as RefTarget[]) {\n        const t = target.type\n        if (!t || !included(t)) continue\n        outgoing.add(t)\n        if (trackPaths) {\n          outgoingPaths.push({ type: t, path: fieldPath })\n          addIncoming(t, sourceType, fieldPath)\n        }\n      }\n    }\n\n    if (field.fields?.length) {\n      collectReferences(\n        field.fields,\n        fieldPath,\n        included,\n        trackPaths,\n        outgoing,\n        outgoingPaths,\n        addIncoming,\n        sourceType,\n      )\n    }\n\n    if (Array.isArray(field.of)) {\n      for (const item of field.of as Record<string, unknown>[]) {\n        if (item?.type === 'reference' && Array.isArray(item.to)) {\n          for (const target of item.to as RefTarget[]) {\n            const t = target.type\n            if (!t || !included(t)) continue\n            outgoing.add(t)\n            const arrayPath = `${fieldPath}[]`\n            if (trackPaths) {\n              outgoingPaths.push({ type: t, path: arrayPath })\n              addIncoming(t, sourceType, arrayPath)\n            }\n          }\n        } else if (Array.isArray(item?.fields)) {\n          collectReferences(\n            item.fields as SchemaField[],\n            `${fieldPath}[]`,\n            included,\n            trackPaths,\n            outgoing,\n            outgoingPaths,\n            addIncoming,\n            sourceType,\n          )\n        }\n      }\n    }\n  }\n}\n\n/**\n * Processes a ManifestSchemaType[] into categorized document/object types\n * with expanded fields, computed references, and identified title fields.\n */\nexport function processSchema(\n  schema: ManifestSchemaType[],\n  options?: SchemaProcessorOptions,\n): SchemaTypes {\n  const trackPaths = SCHEMA_CONSTANTS.DEFAULT_OPTIONS.trackPaths\n  const includeList = resolveFilterSync(options?.filter)\n  const includeSet = includeList?.length ? new Set(includeList) : null\n  const included = (name: string) => !includeSet || includeSet.has(name)\n\n  const maxDepth = SCHEMA_CONSTANTS.DEFAULT_OPTIONS.maxExpansionDepth\n\n  // 1. Categorize into document vs object types\n  const documentTypes = new Map<string, ProcessedDocumentType>()\n  const objectTypes = new Map<string, ManifestSchemaType>()\n\n  for (const type of schema) {\n    if (type.type === 'document') {\n      if (!included(type.name)) continue\n      documentTypes.set(type.name, {\n        name: type.name,\n        title: type.title,\n        description: type.description,\n        deprecated: type.deprecated,\n        titleField: SCHEMA_CONSTANTS.DEFAULTS.titleField,\n        fields: type.fields ?? [],\n        outgoingReferences: [],\n        incomingReferences: [],\n      })\n    } else if (type.type === 'object') {\n      objectTypes.set(type.name, type)\n    }\n  }\n\n  // 2. Expand object type references in document fields\n  for (const doc of documentTypes.values()) {\n    doc.fields = expandFields(doc.fields, objectTypes, maxDepth)\n  }\n\n  // 3. Compute references (outgoing + incoming)\n  // incoming tracker: targetType -> Map<sourceType, Set<path>>\n  const incomingMap = new Map<string, Map<string, Set<string>>>()\n  // simple incoming: targetType -> Set<sourceType>\n  const incomingSimple = new Map<string, Set<string>>()\n\n  const addIncoming = (targetType: string, sourceType: string, fieldPath: string) => {\n    if (!incomingSimple.has(targetType)) incomingSimple.set(targetType, new Set())\n    incomingSimple.get(targetType)!.add(sourceType)\n\n    if (!incomingMap.has(targetType)) incomingMap.set(targetType, new Map())\n    const sourceMap = incomingMap.get(targetType)!\n    if (!sourceMap.has(sourceType)) sourceMap.set(sourceType, new Set())\n    sourceMap.get(sourceType)!.add(fieldPath)\n  }\n\n  for (const [docName, doc] of documentTypes) {\n    const outgoing = new Set<string>()\n    const outgoingPaths: ReferenceInfo[] = []\n\n    collectReferences(\n      doc.fields,\n      '',\n      included,\n      trackPaths,\n      outgoing,\n      outgoingPaths,\n      addIncoming,\n      docName,\n    )\n\n    // Also track simple incoming for non-trackPaths mode\n    if (!trackPaths) {\n      for (const targetType of outgoing) {\n        if (!incomingSimple.has(targetType)) incomingSimple.set(targetType, new Set())\n        incomingSimple.get(targetType)!.add(docName)\n      }\n    }\n\n    doc.outgoingReferences = Array.from(outgoing)\n    if (trackPaths) doc.outgoingReferencePaths = outgoingPaths\n  }\n\n  // Apply incoming references to target documents\n  for (const [targetType, sources] of incomingSimple) {\n    const target = documentTypes.get(targetType)\n    if (!target) continue\n    target.incomingReferences = Array.from(sources)\n\n    if (trackPaths && incomingMap.has(targetType)) {\n      const paths: ReferenceInfo[] = []\n      for (const [sourceType, fieldPaths] of incomingMap.get(targetType)!) {\n        for (const p of fieldPaths) {\n          paths.push({ type: sourceType, path: p })\n        }\n      }\n      target.incomingReferencePaths = paths\n    }\n  }\n\n  // 4. Identify title fields\n  for (const doc of documentTypes.values()) {\n    doc.titleField = findTitleField(doc.fields)\n  }\n\n  return { documentTypes, objectTypes }\n}\n\n/**\n * Expands fields for a single type at a given depth.\n * Used by getTypeSignature to expand on-demand.\n */\nexport function expandFieldsForType(\n  fields: SchemaField[],\n  objectTypes: Map<string, ManifestSchemaType>,\n  depth: number,\n): SchemaField[] {\n  return expandFields(fields, objectTypes, depth)\n}\n","import type { ManifestSchemaType } from '../types.js'\n\n/**\n * Built-in Sanity type fields that exist implicitly (not in schema).\n * Maps type name to field definitions.\n */\nexport const BUILT_IN_TYPE_FIELDS: Record<string, Record<string, ManifestSchemaType>> = {\n  slug: {\n    current: { name: 'current', type: 'string' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  geopoint: {\n    lat: { name: 'lat', type: 'number' } as ManifestSchemaType,\n    lng: { name: 'lng', type: 'number' } as ManifestSchemaType,\n    alt: { name: 'alt', type: 'number' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  reference: {\n    _ref: { name: '_ref', type: 'string' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n    _weak: { name: '_weak', type: 'boolean' } as ManifestSchemaType,\n  },\n  image: {\n    asset: { name: 'asset', type: 'reference' } as ManifestSchemaType,\n    hotspot: {\n      name: 'hotspot',\n      type: 'object',\n      fields: [\n        { name: 'x', type: 'number' },\n        { name: 'y', type: 'number' },\n        { name: 'height', type: 'number' },\n        { name: 'width', type: 'number' },\n      ],\n    } as ManifestSchemaType,\n    crop: {\n      name: 'crop',\n      type: 'object',\n      fields: [\n        { name: 'top', type: 'number' },\n        { name: 'bottom', type: 'number' },\n        { name: 'left', type: 'number' },\n        { name: 'right', type: 'number' },\n      ],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  file: {\n    asset: { name: 'asset', type: 'reference' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  block: {\n    style: { name: 'style', type: 'string' } as ManifestSchemaType,\n    listItem: { name: 'listItem', type: 'string' } as ManifestSchemaType,\n    level: { name: 'level', type: 'number' } as ManifestSchemaType,\n    children: {\n      name: 'children',\n      type: 'array',\n      of: [{ name: 'span', type: 'span' }],\n    } as ManifestSchemaType,\n    markDefs: {\n      name: 'markDefs',\n      type: 'array',\n      of: [{ name: 'object', type: 'object' }],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  span: {\n    text: { name: 'text', type: 'string' } as ManifestSchemaType,\n    marks: {\n      name: 'marks',\n      type: 'array',\n      of: [{ name: 'string', type: 'string' }],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n}\n\n/**\n * Default annotation type for Portable Text blocks.\n * Sanity implicitly includes \"link\" when no marks.annotations are declared.\n */\nexport const DEFAULT_LINK_ANNOTATION: ManifestSchemaType = {\n  name: 'link',\n  type: 'object',\n  fields: [\n    { name: 'href', type: 'string' },\n    { name: 'blank', type: 'boolean' },\n  ],\n} as ManifestSchemaType\n\n/**\n * System fields that exist on all array items.\n */\nexport const ARRAY_ITEM_SYSTEM_FIELDS: Record<string, ManifestSchemaType> = {\n  _key: { name: '_key', type: 'string' } as ManifestSchemaType,\n  _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n}\n","/**\n * Filter schema types to specific field paths.\n * Used for displaying filtered views of schema types.\n */\n\nimport type { ManifestField, ManifestSchemaType } from '../types.js'\n\n/**\n * Parse of[N] syntax from a path segment\n */\nfunction parseOfIndexSyntax(segment: string): number | null {\n  const match = segment.match(/^of\\[(\\d+)\\]$/)\n  if (!match) return null\n  return parseInt(match[1], 10)\n}\n\n/**\n * Parse array notation from a path segment.\n * Handles both numeric indices [0] and _key selectors [_key==\"value\"].\n */\nfunction parseArrayNotation(segment: string): { fieldName: string; isArray: true } | null {\n  // Match field name followed by any bracket notation: field[...] or field[_key==\"...\"]\n  const match = segment.match(/^([^[]+)\\[.*\\]$/)\n  if (!match) return null\n  return { fieldName: match[1], isArray: true }\n}\n\n/**\n * Create a \"not found\" marker for path navigation errors\n */\nfunction createNotFoundMarker(): ManifestSchemaType {\n  return { name: '', type: 'notfound', fields: [] } as ManifestSchemaType\n}\n\n/**\n * Navigate to an of[N] index in an array type\n */\nfunction navigateToOfIndex(node: ManifestSchemaType, index: number): ManifestSchemaType | null {\n  if (!node.of || !Array.isArray(node.of)) return null\n  if (index < 0 || index >= node.of.length) return null\n  return node.of[index] as ManifestSchemaType\n}\n\n/**\n * Navigate to a property of a schema node (not a field, but a schema property like marks, styles, etc.)\n */\nfunction navigateToSchemaProperty(\n  node: ManifestSchemaType,\n  propertyName: string,\n  isLastSegment: boolean,\n): { result: ManifestSchemaType | null; continueWith?: ManifestSchemaType } {\n  if (!node || typeof node !== 'object' || !(propertyName in node)) {\n    return { result: null }\n  }\n\n  const propertyValue = (node as Record<string, unknown>)[propertyName]\n\n  // If this is the last segment, wrap and return the property\n  if (isLastSegment) {\n    // For arrays, preserve the array structure\n    if (Array.isArray(propertyValue)) {\n      return {\n        result: {\n          name: propertyName,\n          type: 'array',\n          of: propertyValue,\n        } as ManifestSchemaType,\n      }\n    }\n\n    // For objects, spread the properties\n    return {\n      result: {\n        name: propertyName,\n        type:\n          typeof propertyValue === 'object' && propertyValue !== null\n            ? 'object'\n            : typeof propertyValue,\n        ...(propertyValue as Record<string, unknown>),\n      } as ManifestSchemaType,\n    }\n  }\n\n  // Not last segment - try to navigate deeper\n  if (typeof propertyValue === 'object' && propertyValue !== null) {\n    // For arrays, wrap them so of[N] navigation works\n    if (Array.isArray(propertyValue)) {\n      return {\n        result: null,\n        continueWith: {\n          type: 'array',\n          of: propertyValue,\n        } as ManifestSchemaType,\n      }\n    }\n\n    // For objects, continue navigation\n    return {\n      result: null,\n      continueWith: propertyValue as ManifestSchemaType,\n    }\n  }\n\n  return { result: null }\n}\n\n/**\n * Resolve the 'of' array for an array field, looking up referenced types if needed\n */\nfunction resolveArrayFieldOf(\n  field: ManifestField,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType[] | null {\n  // First check if field has inline 'of'\n  if (field.of) return field.of as ManifestSchemaType[]\n\n  // Field references another type - look it up in schema\n  if (field.type) {\n    const referencedType = schema.find((t) => t.name === field.type)\n    if (referencedType?.of) {\n      return referencedType.of as ManifestSchemaType[]\n    }\n  }\n\n  return null\n}\n\n/**\n * Create an array type node from a field (for navigation purposes)\n */\nfunction createArrayTypeFromField(\n  field: ManifestField,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType {\n  // Try to find the referenced array type\n  if (field.type) {\n    const arrayType = schema.find((t) => t.name === field.type)\n    if (arrayType) return arrayType\n  }\n\n  // Create inline array type\n  return {\n    ...field,\n    name: field.name,\n    type: 'array',\n  } as ManifestSchemaType\n}\n\n/**\n * Filter a schema type to a specific field path.\n * Supports complex path navigation including:\n * - Dot notation: \"author.person\"\n * - Array notation: \"content[]\"\n * - Array item navigation: \"content[].image\"\n * - of[N] indexed navigation: \"of[0]\", \"content.of[1]\"\n * - Property navigation: \"of[0].marks\", \"of[0].marks.annotations\"\n *\n * @param type - The schema type to filter\n * @param path - The path to filter to\n * @param schema - Full schema array to resolve type references\n * @returns A modified type containing only the specified field path, or a not-found marker\n */\nexport function filterToPath(\n  type: ManifestSchemaType,\n  path: string,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType {\n  // Parse the path segments - split on dots that are NOT inside brackets\n  const segments = path.split(/\\.(?![^[]*\\])/)\n\n  // Handle direct of[N] access on array types (e.g., type=\"arrayType\", path=\"of[0]\")\n  if (segments.length === 1 && segments[0].startsWith('of[')) {\n    const index = parseOfIndexSyntax(segments[0])\n    if (index !== null) {\n      const item = navigateToOfIndex(type, index)\n      if (item) return item\n      // Index out of bounds\n      return { ...type, fields: [], of: undefined }\n    }\n  }\n\n  // Start with the type's fields or of array\n  let currentNode: ManifestSchemaType = type\n  let currentFields: ManifestField[] | undefined = type.fields\n\n  // Navigate to the target field\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    // Check for of[N] syntax for navigating array type definitions\n    const ofIndex = parseOfIndexSyntax(segment)\n    if (ofIndex !== null) {\n      const item = navigateToOfIndex(currentNode, ofIndex)\n\n      if (item) {\n        // If this is the last segment, return this item\n        if (i === segments.length - 1) {\n          return item\n        }\n\n        // Otherwise, navigate into this item\n        currentNode = item\n        currentFields = currentNode.fields\n        continue\n      }\n\n      // Index out of bounds or not an array type\n      return { ...type, fields: [], of: undefined }\n    }\n\n    // Handle regular field access or array notation: \"field[]\" or \"field[index]\"\n    const arrayNotation = parseArrayNotation(segment)\n    const fieldName = arrayNotation ? arrayNotation.fieldName : segment\n\n    // Try to find as a field first\n    const field: ManifestField | undefined = currentFields?.find((f) => f.name === fieldName)\n\n    if (!field) {\n      // Not a field - check if it's a property of the current schema node\n      // This allows navigation like of[0].marks or of[0].styles\n      const isLastSegment = i === segments.length - 1\n      const propertyNav = navigateToSchemaProperty(currentNode, fieldName, isLastSegment)\n\n      if (propertyNav.result) {\n        return propertyNav.result\n      }\n\n      if (propertyNav.continueWith) {\n        currentNode = propertyNav.continueWith\n        currentFields = currentNode.fields\n        continue\n      }\n\n      // Field not found and not a property - return not found marker\n      return createNotFoundMarker()\n    }\n\n    // If this is the last segment, we found our target\n    if (i === segments.length - 1) {\n      // Check if this is array notation (field[])\n      if (arrayNotation) {\n        const indexMatch = segment.match(/\\[(\\d+)\\]$/)\n        if (indexMatch) {\n          // This is field[N] syntax - not supported yet, treat as field[]\n        }\n\n        // For array notation (field[]), return the array type directly\n        // This prevents path recursion in navigator (e.g., content[].content[])\n        return createArrayTypeFromField(field, schema)\n      }\n      // Return a modified type with only this field\n      return { ...type, fields: [field] }\n    }\n\n    // Navigate deeper\n    if (arrayNotation) {\n      // For arrays, look in the 'of' items using helper\n      const fieldOf = resolveArrayFieldOf(field, schema)\n\n      if (!fieldOf) {\n        // No array items found\n        return { ...type, fields: [] }\n      }\n\n      // Update currentNode to be the array field's type for of[N] navigation\n      currentNode = createArrayTypeFromField(field, schema)\n\n      const nextSegment = segments[i + 1]\n      if (!nextSegment) {\n        // Path ends with [] - can't navigate further in this loop\n        continue\n      }\n\n      // CASE 0: Check if nextSegment is of[N] syntax - this allows content[].of[0] navigation\n      const nextOfIndex = parseOfIndexSyntax(nextSegment)\n      if (nextOfIndex !== null) {\n        // Navigate to the of[N] item in the array type\n        const item = navigateToOfIndex(currentNode, nextOfIndex)\n        if (item) {\n          // Check if this is the last segment\n          if (i + 1 === segments.length - 1) {\n            // Return the array item directly\n            return item\n          }\n          // More segments after of[N] - continue navigation from this item\n          currentNode = item\n          currentFields = item.fields\n          i++ // Consume the of[N] segment\n          continue\n        } else {\n          // Index out of bounds\n          return { ...type, fields: [], of: undefined }\n        }\n      }\n\n      // CASE 1: Check if nextSegment matches an array item TYPE NAME\n      const arrayItemByType = fieldOf.find(\n        (item) => item.name === nextSegment || item.type === nextSegment,\n      )\n\n      if (arrayItemByType) {\n        // Found a matching type!\n        // Check if this is the LAST segment in the path\n        if (i + 1 === segments.length - 1) {\n          // This IS the final destination - return the matched type\n          // Whether or not it has fields, we return it\n          return { ...type, fields: [{ ...field, of: [arrayItemByType] }] }\n        }\n\n        // More segments after this - need to navigate into the type's fields\n        if (arrayItemByType.fields) {\n          currentFields = arrayItemByType.fields\n          i++ // Consume the type name segment\n          continue\n        } else {\n          // Type has no fields (primitive) but path continues - error\n          return { ...type, fields: [] }\n        }\n      }\n\n      // CASE 2: nextSegment is not a type name - try to find it as a FIELD NAME across all array item types\n      const matchingFields: Array<{ typeName: string; field: ManifestField }> = []\n      for (const item of fieldOf) {\n        const itemAsType = item as ManifestSchemaType\n        if (itemAsType.fields && Array.isArray(itemAsType.fields)) {\n          const matchingField = itemAsType.fields.find((f: ManifestField) => f.name === nextSegment)\n          if (matchingField) {\n            matchingFields.push({\n              typeName: (itemAsType.name || itemAsType.type) as string,\n              field: matchingField,\n            })\n          }\n        }\n      }\n\n      if (matchingFields.length === 0) {\n        // Field not found in any array item type\n        return { ...type, fields: [] }\n      }\n\n      // Found field(s) - if this is the last segment, return the matches\n      if (i + 1 === segments.length - 1) {\n        // This is the last segment - return the matching field(s)\n        // If only one match, we can return it directly as nested under the array\n        // If multiple matches from different array types, show all of them\n        if (matchingFields.length === 1) {\n          // Single match - create array field with nested fields showing the matched field\n          const match = matchingFields[0]\n          const syntheticArrayField: ManifestField = {\n            ...field,\n            of: [\n              {\n                name: match.typeName,\n                type: 'object',\n                fields: [match.field], // The matched field\n              },\n            ],\n          }\n          return { ...type, fields: [syntheticArrayField] }\n        } else {\n          // Multiple matches - show all matching fields from different types\n          const syntheticArrayField: ManifestField = {\n            ...field,\n            of: matchingFields.map((m) => ({\n              name: m.typeName,\n              type: 'object',\n              fields: [m.field],\n            })),\n          }\n          return { ...type, fields: [syntheticArrayField] }\n        }\n      }\n\n      // More segments after this - continue navigation from the first match\n      // (In practice, multiple matches with further navigation is complex - we'll use first match)\n      currentFields = matchingFields[0].field.fields\n      i++ // Consume the field name segment\n    } else if (field.fields) {\n      // For objects, look in fields\n      currentFields = field.fields\n    } else {\n      // Can't navigate deeper\n      return { ...type, fields: [] }\n    }\n  }\n\n  return { ...type, fields: [] }\n}\n","/**\n * Convert a document path string to a schema path string.\n * Strips array indices, _key selectors, and internal markers.\n *\n * Examples:\n * - `\"content[_key==\\\"abc\\\"].children[0].text\"` → `\"content.children.text\"`\n * - `\"tags[0]\"` → `\"tags\"`\n * - `\"seo.image.asset\"` → `\"seo.image.asset\"`\n * - `\"items[append:3]\"` → `\"items\"`\n *\n * This is a self-contained implementation that avoids depending on\n * `@sanity/types` for path segment parsing.\n */\nexport function toSchemaPath(path: string): string {\n  if (!path) return ''\n\n  return (\n    path\n      // Strip internal markers: [append:N]\n      .replace(/\\[append:\\d+\\]/g, '')\n      // Strip _key selectors: [_key==\"value\"] or [_key=='value']\n      .replace(/\\[_key\\s*==\\s*[\"'][^\"']*[\"']\\]/g, '')\n      // Strip numeric indices: [0], [123]\n      .replace(/\\[\\d+\\]/g, '')\n      // Strip empty brackets: []\n      .replace(/\\[\\]/g, '')\n      // Collapse any resulting double dots\n      .replace(/\\.{2,}/g, '.')\n      // Trim leading/trailing dots\n      .replace(/^\\.+|\\.+$/g, '')\n  )\n}\n","const BASE_PRIMITIVES = ['string', 'number', 'boolean', 'date', 'datetime', 'text', 'url', 'email']\n\nconst BLOCK_TYPES = ['block', 'reference']\n\n/**\n * Check if a type name represents a primitive type.\n *\n * When `includeBlockTypes` is true, 'block' and 'reference' are also\n * considered primitive (useful for navigator/large-node detection where\n * you don't want to drill into these).\n */\nexport function isPrimitiveType(\n  typeName: string | undefined,\n  options: { includeBlockTypes?: boolean } = {},\n): boolean {\n  if (!typeName) return false\n  if (options.includeBlockTypes) {\n    return BASE_PRIMITIVES.includes(typeName) || BLOCK_TYPES.includes(typeName)\n  }\n  return BASE_PRIMITIVES.includes(typeName)\n}\n\n/**\n * Check if a type is a built-in Sanity type (superset of primitives).\n * Includes complex built-in types like array, object, image, file, slug, etc.\n */\nexport function isBuiltInType(type: string): boolean {\n  return BUILT_IN_TYPES.has(type)\n}\n\nconst BUILT_IN_TYPES = new Set([\n  'string',\n  'text',\n  'number',\n  'boolean',\n  'array',\n  'object',\n  'reference',\n  'image',\n  'file',\n  'date',\n  'datetime',\n  'url',\n  'slug',\n  'block',\n  'geopoint',\n])\n\n/**\n * Check if a node is a generic object-like node.\n * Generic objects are objects that don't have a `fields` array and\n * aren't array types with `of`. These include block types and other\n * object-shaped schemas with properties like marks, lists, styles, etc.\n */\nexport function isGenericObject(node: unknown): boolean {\n  if (typeof node !== 'object' || node === null || Array.isArray(node)) return false\n  const obj = node as Record<string, unknown>\n  return !obj.fields && !(obj.type === 'array' && Array.isArray(obj.of))\n}\n","import type { ManifestSchemaType } from '../types.js'\nimport { toSchemaPath } from './path.js'\nimport { isBuiltInType } from './types.js'\n\n/**\n * Resolves a document path to field schemas, returning ALL possible schemas for union types.\n * This is important for arrays with multiple `of` types where a field might exist\n * in some but not all union types.\n */\nexport function resolveFieldSchemaAllUnions(\n  path: string,\n  typeSchema: ManifestSchemaType,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType[] {\n  const pathParts = toSchemaPath(path).split('.').filter(Boolean)\n\n  let currentSchemas: ManifestSchemaType[] = [typeSchema]\n\n  for (let i = 0; i < pathParts.length; i++) {\n    const part = pathParts[i]\n    const isLastPart = i === pathParts.length - 1\n    const nextSchemas: ManifestSchemaType[] = []\n\n    for (const currentSchema of currentSchemas) {\n      if (!currentSchema?.fields || !Array.isArray(currentSchema.fields)) {\n        continue\n      }\n\n      const field = currentSchema.fields.find((f) => f.name === part)\n      if (!field) continue\n\n      if (field.type === 'array' && field.of && field.of.length > 0) {\n        for (const itemSchema of field.of) {\n          const itemType = typeof itemSchema.type === 'string' ? itemSchema.type : undefined\n          if (isLastPart && (itemType === 'image' || itemType === 'file')) {\n            nextSchemas.push(itemSchema as ManifestSchemaType)\n          } else if (itemType && !isBuiltInType(itemType)) {\n            const foundSchema = schema.find((s) => s.name === itemType)\n            if (foundSchema) nextSchemas.push(foundSchema)\n          } else if ((itemSchema as ManifestSchemaType).fields) {\n            nextSchemas.push(itemSchema as ManifestSchemaType)\n          }\n        }\n      } else if (field.type && !isBuiltInType(field.type)) {\n        const foundSchema = schema.find((s) => s.name === field.type)\n        if (foundSchema) {\n          if (foundSchema.type === 'array' && foundSchema.of && foundSchema.of.length > 0) {\n            for (const itemSchema of foundSchema.of) {\n              const itemType = typeof itemSchema.type === 'string' ? itemSchema.type : undefined\n              if (isLastPart && (itemType === 'image' || itemType === 'file')) {\n                nextSchemas.push(itemSchema as ManifestSchemaType)\n              } else if (itemType && !isBuiltInType(itemType)) {\n                const itemFoundSchema = schema.find((s) => s.name === itemType)\n                if (itemFoundSchema) nextSchemas.push(itemFoundSchema)\n              } else if ((itemSchema as ManifestSchemaType).fields) {\n                nextSchemas.push(itemSchema as ManifestSchemaType)\n              }\n            }\n          } else {\n            nextSchemas.push(foundSchema)\n          }\n        }\n      } else {\n        nextSchemas.push(field as ManifestSchemaType)\n      }\n    }\n\n    currentSchemas = nextSchemas\n  }\n\n  return currentSchemas\n}\n","import type { ManifestField, ManifestSchemaType } from '../types.js'\nimport {\n  ARRAY_ITEM_SYSTEM_FIELDS,\n  BUILT_IN_TYPE_FIELDS,\n  DEFAULT_LINK_ANNOTATION,\n} from './constants.js'\nimport { toSchemaPath } from './path.js'\nimport { isPrimitiveType } from './types.js'\n\ninterface SchemaResolutionResult {\n  schema: ManifestSchemaType | null\n  earlyReturn: ManifestSchemaType | null\n}\n\nfunction getBuiltInFieldSchema(\n  segment: string,\n  currentSchema: ManifestSchemaType,\n): ManifestSchemaType | null {\n  if (!currentSchema?.type || !BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {\n    return null\n  }\n\n  let builtInField: ManifestSchemaType = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment]\n\n  // For block.children, merge in block.of (inline objects) from the schema\n  if (currentSchema.type === 'block' && segment === 'children' && currentSchema.of) {\n    builtInField = {\n      ...builtInField,\n      of: [...(builtInField.of || []), ...(currentSchema.of as ManifestSchemaType[])],\n    }\n  }\n\n  // For block.markDefs, merge in block.marks.annotations from the schema\n  // If no annotations are declared, add default \"link\" annotation (Sanity built-in)\n  if (currentSchema.type === 'block' && segment === 'markDefs') {\n    const annotations = (\n      currentSchema as ManifestSchemaType & { marks?: { annotations?: ManifestSchemaType[] } }\n    ).marks?.annotations\n    if (annotations) {\n      builtInField = {\n        ...builtInField,\n        of: [...(builtInField.of || []), ...annotations],\n      }\n    } else {\n      builtInField = {\n        ...builtInField,\n        of: [...(builtInField.of || []), DEFAULT_LINK_ANNOTATION],\n      }\n    }\n  }\n\n  return builtInField\n}\n\nfunction findSchemaInUnionArray(\n  segment: string,\n  arraySchema: ManifestSchemaType,\n  allSchemas: ManifestSchemaType[],\n  isLastSegment: boolean,\n): SchemaResolutionResult {\n  if (!arraySchema.of || arraySchema.of.length === 0) {\n    return { schema: null, earlyReturn: null }\n  }\n\n  for (const itemSchema of arraySchema.of as ManifestSchemaType[]) {\n    if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[segment]) {\n      const builtInField = BUILT_IN_TYPE_FIELDS[itemSchema.type][segment]\n      if (isLastSegment) {\n        return { schema: null, earlyReturn: builtInField }\n      }\n      return { schema: builtInField, earlyReturn: null }\n    }\n\n    if (itemSchema.fields?.some((f) => f.name === segment)) {\n      return { schema: itemSchema, earlyReturn: null }\n    }\n\n    if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {\n      const referencedSchema = allSchemas.find((s) => s.name === itemSchema.type)\n      if (referencedSchema?.fields?.some((f) => f.name === segment)) {\n        return { schema: referencedSchema, earlyReturn: null }\n      }\n    }\n  }\n\n  const firstItem = arraySchema.of[0] as ManifestSchemaType\n  if (firstItem.fields) {\n    return { schema: firstItem, earlyReturn: null }\n  }\n\n  const referencedSchema = allSchemas.find((s) => s.name === firstItem.type)\n  if (referencedSchema?.fields) {\n    return { schema: referencedSchema, earlyReturn: null }\n  }\n\n  return { schema: null, earlyReturn: null }\n}\n\nfunction resolveCurrentSchema(\n  segment: string,\n  currentSchema: ManifestSchemaType,\n  allSchemas: ManifestSchemaType[],\n  isLastSegment: boolean,\n): SchemaResolutionResult {\n  if (!currentSchema?.type) {\n    return { schema: null, earlyReturn: null }\n  }\n\n  if (currentSchema.type === 'array' && currentSchema.of && currentSchema.of.length > 0) {\n    return findSchemaInUnionArray(segment, currentSchema, allSchemas, isLastSegment)\n  }\n\n  const referencedSchema = allSchemas.find((s) => s.name === currentSchema.type)\n  if (referencedSchema?.fields) {\n    return { schema: referencedSchema, earlyReturn: null }\n  }\n\n  if (BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {\n    const builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment]\n    if (isLastSegment) {\n      return { schema: null, earlyReturn: builtInField }\n    }\n    return { schema: builtInField, earlyReturn: null }\n  }\n\n  return { schema: null, earlyReturn: null }\n}\n\nfunction getNextSchemaForField(\n  field: ManifestField,\n  nextSegment: string,\n  allSchemas: ManifestSchemaType[],\n): ManifestSchemaType {\n  let resolvedField: ManifestSchemaType = field as ManifestSchemaType\n  if (field.type && !isPrimitiveType(field.type) && field.type !== 'array') {\n    const referencedSchema = allSchemas.find((s) => s.name === field.type)\n    if (referencedSchema) {\n      resolvedField = referencedSchema\n    }\n  }\n\n  if (resolvedField.type === 'array' && resolvedField.of && resolvedField.of.length > 0) {\n    for (const itemSchema of resolvedField.of as ManifestSchemaType[]) {\n      if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[nextSegment]) {\n        return itemSchema\n      }\n      if (itemSchema.fields?.some((f) => f.name === nextSegment)) {\n        return itemSchema\n      }\n      if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {\n        const refSchema = allSchemas.find((s) => s.name === itemSchema.type)\n        if (refSchema?.fields?.some((f) => f.name === nextSegment)) {\n          return refSchema\n        }\n      }\n    }\n    return resolvedField.of[0] as ManifestSchemaType\n  }\n\n  return resolvedField\n}\n\n/**\n * Resolves a document path to the field schema at that location.\n * Handles nested paths like \"author.name\" and array paths like \"tags[0]\".\n *\n * Returns the field schema at the path, NOT navigating into arrays.\n * For \"tags\" (an array field), returns the array field schema (with 'of').\n * For \"tags[0].foo\", returns the \"foo\" field from the array item schema.\n */\nexport function resolveFieldSchema(\n  path: string,\n  typeSchema: ManifestSchemaType,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType | null {\n  const segments = toSchemaPath(path).split('.').filter(Boolean)\n\n  let currentSchema: ManifestSchemaType | undefined = typeSchema\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n    const isLastSegment = i === segments.length - 1\n\n    if (ARRAY_ITEM_SYSTEM_FIELDS[segment]) {\n      return ARRAY_ITEM_SYSTEM_FIELDS[segment]\n    }\n\n    const builtInField = getBuiltInFieldSchema(segment, currentSchema!)\n    if (builtInField) {\n      if (isLastSegment) return builtInField\n      currentSchema = builtInField\n      continue\n    }\n\n    if (!currentSchema?.fields) {\n      const resolved = resolveCurrentSchema(segment, currentSchema!, schema, isLastSegment)\n      if (resolved.earlyReturn) return resolved.earlyReturn\n      if (!resolved.schema) return null\n      currentSchema = resolved.schema\n\n      const resolvedBuiltInField = getBuiltInFieldSchema(segment, currentSchema)\n      if (resolvedBuiltInField) {\n        if (isLastSegment) return resolvedBuiltInField\n        currentSchema = resolvedBuiltInField\n        continue\n      }\n    }\n\n    if (!currentSchema?.fields) return null\n\n    const field = currentSchema.fields.find((f) => f.name === segment)\n    if (!field) return null\n    if (isLastSegment) return field\n\n    currentSchema = getNextSchemaForField(field, segments[i + 1], schema)\n  }\n\n  return currentSchema || null\n}\n","import { SCHEMA_CONSTANTS } from './constants.js'\n\nexport function shouldSkipType(typeName: string): boolean {\n  return SCHEMA_CONSTANTS.SKIP_PATTERNS.test(typeName)\n}\n","import { filterToPath } from './navigate/filterToPath.js'\nimport { isGenericObject, isPrimitiveType } from './navigate/types.js'\nimport type { ManifestField, ManifestSchemaType } from './types.js'\nimport { shouldSkipType } from './utils.js'\n\nexport type FullSchemaOptions = {\n  /** The document type name to return (e.g. \"post\"). */\n  type: string\n  /** Optional field path to scope the result (e.g. \"content\" or \"content[].codeBlock\"). */\n  path?: string\n  /** Size threshold in bytes before returning a navigator instead of the full JSON (default 200KB). */\n  sizeThreshold?: number\n}\n\ntype LargeNodeNavigator = {\n  _rawLargeNode: true\n  name: string\n  type: string\n  children: Array<{ type: string; path: string }>\n  hint: string\n}\n\n/**\n * Returns the complete JSON structure for a specific document type, optionally\n * scoped to a field path. Internal/system types are filtered out.\n *\n * When the JSON output exceeds `sizeThreshold`, a navigator object is returned\n * instead — listing child paths the caller can drill into.\n *\n * This is the counterpart to `compressedSchema`:\n * - `compressedSchema` → lossy text summary for LLM context windows\n * - `fullSchema` → complete JSON for schema explorer tools and mutation agents\n */\nexport function fullSchema(\n  schema: ManifestSchemaType[],\n  options: FullSchemaOptions,\n): Record<string, unknown> | LargeNodeNavigator {\n  const { type: typeName, path, sizeThreshold = 200 * 1024 } = options\n\n  const type = schema.find((t) => t.name === typeName)\n  if (!type) {\n    const documentTypes = schema\n      .filter((t) => t.type === 'document' && !shouldSkipType(t.name))\n      .map((t) => t.name)\n      .sort()\n      .slice(0, 10)\n\n    return {\n      _error: true,\n      message: `Type \"${typeName}\" not found`,\n      availableTypes: documentTypes,\n    }\n  }\n\n  const targetNode = path ? filterToPath(type, path, schema) : type\n\n  if (path) {\n    if (targetNode.type === 'notfound') {\n      return {\n        _error: true,\n        message: `Path \"${path}\" not found in type \"${typeName}\"`,\n        type: typeName,\n        path,\n      }\n    }\n\n    const originalHadFields = type.fields && type.fields.length > 0\n    const resultHasFields = targetNode.fields && targetNode.fields.length > 0\n    const resultHasOf = targetNode.of && targetNode.of.length > 0\n    const resultIsDifferent = targetNode !== type\n\n    const hasJustTypeProperty = targetNode.type && Object.keys(targetNode).length <= 2\n    const hasPropertyContent = resultIsDifferent && Object.keys(targetNode).length > 2\n    const resultHasContent =\n      resultHasFields ||\n      resultHasOf ||\n      targetNode.validation ||\n      targetNode.options ||\n      targetNode.to ||\n      (resultIsDifferent && hasJustTypeProperty) ||\n      hasPropertyContent\n\n    const pathNotFound =\n      (resultIsDifferent && !resultHasContent) ||\n      (!resultIsDifferent && originalHadFields && !resultHasFields && !resultHasOf)\n\n    if (pathNotFound) {\n      return {\n        _error: true,\n        message: `Path \"${path}\" not found in type \"${typeName}\"`,\n        type: typeName,\n        path,\n      }\n    }\n  }\n\n  const rawSubtree = extractRawSubtree(targetNode)\n\n  const jsonString = JSON.stringify(rawSubtree, null, 2)\n  const sizeInBytes = new TextEncoder().encode(jsonString).length\n\n  if (sizeInBytes <= sizeThreshold) {\n    return rawSubtree\n  }\n\n  return generateLargeNodeNavigator(targetNode, path, typeName)\n}\n\nfunction extractRawSubtree(node: ManifestSchemaType): Record<string, unknown> {\n  const cleaned = JSON.parse(JSON.stringify(node))\n\n  if (cleaned.fields && Array.isArray(cleaned.fields)) {\n    cleaned.fields = cleaned.fields.filter((field: ManifestField) => !shouldSkipType(field.name))\n  }\n\n  return cleaned\n}\n\nfunction generateLargeNodeNavigator(\n  node: ManifestSchemaType,\n  currentPath: string | undefined,\n  rootTypeName: string,\n): LargeNodeNavigator {\n  const children: Array<{ type: string; path: string }> = []\n\n  if ((node.type === 'array' || node.of) && Array.isArray(node.of) && node.of.length > 0) {\n    node.of.forEach((item: Record<string, unknown>, index: number) => {\n      const itemType =\n        item.name ||\n        item.title ||\n        (item.type && item.type !== 'object' ? item.type : null) ||\n        item.type ||\n        'unknown'\n\n      children.push({\n        type: String(itemType),\n        path: currentPath ? `${currentPath}.of[${index}]` : `of[${index}]`,\n      })\n    })\n  } else if (node.fields && Array.isArray(node.fields)) {\n    node.fields.forEach((field: ManifestField) => {\n      if (shouldSkipType(field.name)) return\n\n      const childPath = currentPath ? `${currentPath}.${field.name}` : field.name\n\n      if (field.type === 'array' && field.of && Array.isArray(field.of)) {\n        const arrayPath = `${childPath}[]`\n\n        field.of.forEach((item: Record<string, unknown>) => {\n          if (item.name || item.type) {\n            const itemType = String(item.name || item.type)\n            if (!isPrimitiveType(itemType, { includeBlockTypes: true })) {\n              children.push({ type: itemType, path: `${arrayPath}.${itemType}` })\n            }\n          }\n        })\n\n        if (field.of.length > 0) {\n          children.push({ type: 'array', path: arrayPath })\n        }\n      } else if (field.type === 'object' || field.fields) {\n        children.push({ type: field.type || 'object', path: childPath })\n      } else if (field.type && !isPrimitiveType(field.type, { includeBlockTypes: true })) {\n        children.push({ type: field.type, path: childPath })\n      }\n    })\n  } else if (isGenericObject(node)) {\n    const nodeObj = node as Record<string, unknown>\n    const skipKeys = new Set(['type', 'name', '_type', '_key'])\n\n    for (const key of Object.keys(nodeObj)) {\n      if (skipKeys.has(key)) continue\n\n      const value = nodeObj[key]\n      const childPath = currentPath ? `${currentPath}.${key}` : key\n\n      let propertyType = 'unknown'\n      if (Array.isArray(value)) propertyType = 'array'\n      else if (typeof value === 'object' && value !== null) propertyType = 'object'\n      else propertyType = typeof value\n\n      children.push({ type: propertyType, path: childPath })\n    }\n  }\n\n  return {\n    _rawLargeNode: true,\n    name: currentPath || rootTypeName,\n    type: node.type || 'object',\n    children,\n    hint: 'This node is large. Fetch a specific child path to drill in.',\n  }\n}\n","import { z } from 'zod'\n\n// =============================================================================\n// Schema Descriptor Types (Lexicon API response)\n// =============================================================================\n\ntype ManifestSerializable =\n  | string\n  | number\n  | boolean\n  | { [k: string]: ManifestSerializable }\n  | ManifestSerializable[]\n\nexport type ManifestSchemaType = {\n  type: string\n  name: string\n  title?: string\n  description?: string\n  deprecated?: { reason: string }\n  readOnly?: boolean | 'conditional'\n  hidden?: boolean | 'conditional'\n  validation?: ManifestValidationGroup[]\n  fields?: ManifestField[]\n  to?: ManifestReferenceMember[]\n  of?: ManifestArrayMember[]\n  preview?: { select: Record<string, string> }\n  fieldsets?: ManifestFieldset[]\n  options?: Record<string, ManifestSerializable>\n  // Portable text\n  marks?: {\n    annotations?: ManifestArrayMember[]\n    decorators?: ManifestTitledValue[]\n  }\n  lists?: ManifestTitledValue[]\n  styles?: ManifestTitledValue[]\n  // Userland (assignable to ManifestSerializable | undefined)\n  [index: string]: unknown\n}\n\ntype ManifestFieldset = {\n  name: string\n  title?: string\n  [index: string]: ManifestSerializable | undefined\n}\n\ntype ManifestTitledValue = {\n  value: string\n  title?: string\n}\n\nexport type ManifestField = ManifestSchemaType & { fieldset?: string }\n\ntype ManifestArrayMember = Omit<ManifestSchemaType, 'name'> & { name?: string }\n\ntype ManifestReferenceMember = Omit<ManifestSchemaType, 'name'> & { name?: string }\n\ntype ManifestValidationGroup = {\n  rules: ManifestValidationRule[]\n  message?: string\n  level?: 'error' | 'warning' | 'info'\n}\n\ntype ManifestValidationRule = {\n  flag: 'presence' | string\n  constraint?: 'required' | ManifestSerializable\n  [index: string]: ManifestSerializable | undefined\n}\n\n// =============================================================================\n// Lexicon Descriptor Types (raw API response before conversion)\n// =============================================================================\n\nexport type HoistedEntry = {\n  name: string\n  typeDef: TypeDef\n  groups?: unknown\n  fieldset?: unknown\n}\n\nexport type HoistedMarker = {\n  __type: 'hoisted'\n  key: string\n}\n\nexport type InlineOrHoisted = { name: string; typeDef: TypeDef } | HoistedMarker\n\nexport type LexiconResponse = {\n  types: Record<string, TypeDef>\n  hoisted: Record<string, HoistedEntry>\n  registries?: string[]\n}\n\nexport type TypeDef = {\n  extends: string\n  fields?: InlineOrHoisted[]\n  to?: Array<{ name: string }>\n  of?: InlineOrHoisted[]\n  fieldsets?: string[]\n  validation?: unknown\n  [key: string]: unknown\n}\n\n// =============================================================================\n// Dataset Stats Types\n// =============================================================================\n\nconst InOutCountsSchema = z.object({\n  incoming: z.record(z.union([z.number(), z.literal('unknown')])),\n  outgoing: z.record(z.union([z.number(), z.literal('unknown')])),\n})\n\nexport const DatasetStatsSchema = z.object({\n  documentCount: z.record(z.number()).optional(),\n  referenceCount: z.record(InOutCountsSchema).optional(),\n})\n\nexport type DatasetStats = z.infer<typeof DatasetStatsSchema>\nexport type InOutCounts = z.infer<typeof InOutCountsSchema>\n\n// =============================================================================\n// Schema Processing Types\n// =============================================================================\n\nexport type SchemaField = ManifestField\n\nexport type ReferenceInfo = {\n  type: string\n  path: string\n}\n\nexport type ProcessedDocumentType = {\n  name: string\n  title?: string\n  description?: string\n  deprecated?: { reason: string }\n  titleField: string\n  fields: ManifestField[]\n  outgoingReferences: string[]\n  incomingReferences: string[]\n  outgoingReferencePaths?: ReferenceInfo[]\n  incomingReferencePaths?: ReferenceInfo[]\n}\n\nexport type SchemaTypes = {\n  documentTypes: Map<string, ProcessedDocumentType>\n  objectTypes: Map<string, ManifestSchemaType>\n}\n\n// =============================================================================\n// Options\n// =============================================================================\n\n/**\n * Filter document types by GROQ expressions or an explicit list.\n * - `{ read?, write? }` — GROQ boolean expressions (requires groq-js peer dep).\n *   Types matching either expression are included (union).\n * - `string[]` — explicit list of document type names to include.\n * - `undefined` / empty — include all document types.\n */\nexport type SchemaFilter = { read?: string; write?: string } | string[]\n\nexport type SchemaFieldDisplayOptions = {\n  showAll?: boolean\n  maxCount?: number\n  includeDescription?: boolean\n  includeHidden?: boolean\n  includeDeprecated?: boolean\n  maxEnumValues?: number\n  maxDescriptionLength?: number\n}\n\nexport type CompressedSchemaOptions = {\n  datasetStats?: DatasetStats\n  filter?: SchemaFilter\n  fields?: SchemaFieldDisplayOptions\n}\n\nexport type SchemaProcessorOptions = {\n  filter?: SchemaFilter\n  fields?: SchemaFieldDisplayOptions\n}\n","import type { ExprNode } from 'groq-js'\n\nimport type { ManifestSchemaType, SchemaFilter } from './types.js'\n\ntype GroqFilter = { read?: string; write?: string }\n\n/**\n * Resolves a `SchemaFilter` into a string array of document type names.\n * - `string[]` is returned as-is\n * - `{ read?, write? }` GROQ expressions are evaluated against the schema\n * - `undefined` returns `undefined` (no filtering)\n *\n * An empty result means \"include everything\".\n */\nexport async function resolveFilter(\n  schema: ManifestSchemaType[],\n  filter: SchemaFilter | undefined,\n): Promise<string[] | undefined> {\n  if (!filter) return undefined\n  if (Array.isArray(filter)) return filter.length > 0 ? filter : undefined\n  const result = await getFilteredDocumentTypes(schema, filter)\n  return result.length > 0 ? result : undefined\n}\n\n/**\n * Extracts document type names to include based on read/write GROQ filter expressions.\n * Returns the union of types allowed by either filter.\n *\n * Returns an empty array when no filtering is needed (no filter, or filter matches all types).\n * Consumers should treat an empty result as \"include everything\".\n */\nexport async function getFilteredDocumentTypes(\n  schema: ManifestSchemaType[],\n  filter: GroqFilter | undefined,\n): Promise<string[]> {\n  if (!filter || (!filter.read && !filter.write)) return []\n\n  const allDocTypes = schema.filter((s) => s.type === 'document').map((s) => s.name)\n  if (allDocTypes.length === 0) return []\n\n  const combined = new Set<string>()\n\n  if (filter.read) {\n    for (const type of await filterTypesByExpression(filter.read, allDocTypes)) {\n      combined.add(type)\n    }\n  }\n\n  if (filter.write) {\n    for (const type of await filterTypesByExpression(filter.write, allDocTypes)) {\n      combined.add(type)\n    }\n  }\n\n  // If the union covers all types, no filtering is needed\n  if (combined.size === allDocTypes.length) return []\n\n  return Array.from(combined)\n}\n\n/**\n * Filters document type names by evaluating a GROQ boolean expression.\n * Best-effort: returns all types when inference is not possible.\n *\n * Supports `_type == \"x\"`, `_type != \"x\"`, `_type in [...]`,\n * and boolean combinations (&&, ||, !).\n */\nexport async function filterTypesByExpression(\n  filterExpr: string | undefined,\n  allTypes: string[],\n): Promise<Set<string>> {\n  if (!filterExpr?.trim() || allTypes.length === 0) {\n    return new Set(allTypes)\n  }\n\n  try {\n    const { parse } = await import('groq-js')\n    const ast = parse(filterExpr)\n    const matching = allTypes.filter((type) => evaluateForType(ast, type) !== false)\n    return matching.length > 0 ? new Set(matching) : new Set(allTypes)\n  } catch {\n    return new Set(allTypes)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// AST evaluation — uses `unknown` accessors to avoid coupling to groq-js internals\n// ---------------------------------------------------------------------------\n\ntype Node = ExprNode | Record<string, unknown>\n\nfunction prop(node: Node, key: string): unknown {\n  return (node as Record<string, unknown>)[key]\n}\n\nfunction child(node: Node, key: string): Node {\n  return prop(node, key) as Node\n}\n\nfunction evaluateForType(node: Node, type: string): boolean | null {\n  if (!node || typeof node !== 'object') return null\n  const kind = (node as { type?: string }).type\n\n  switch (kind) {\n    case 'OpCall':\n      return evaluateOpCall(node, type)\n\n    case 'And': {\n      const left = evaluateForType(child(node, 'left'), type)\n      const right = evaluateForType(child(node, 'right'), type)\n      if (left === false || right === false) return false\n      if (left === true && right === true) return true\n      return null\n    }\n\n    case 'Or': {\n      const left = evaluateForType(child(node, 'left'), type)\n      const right = evaluateForType(child(node, 'right'), type)\n      if (left === true || right === true) return true\n      if (left === false && right === false) return false\n      return null\n    }\n\n    case 'Not': {\n      const inner = evaluateForType(child(node, 'base'), type)\n      return inner === null ? null : !inner\n    }\n\n    case 'Group':\n      return evaluateForType(child(node, 'base'), type)\n\n    default:\n      return null\n  }\n}\n\nfunction evaluateOpCall(node: Node, type: string): boolean | null {\n  const op = prop(node, 'op') as string\n  const left = child(node, 'left')\n  const right = child(node, 'right')\n\n  if (!isTypeAttribute(left)) return null\n\n  const rightType = (right as { type?: string }).type\n\n  if (op === '==' && rightType === 'Value') {\n    const val = prop(right, 'value')\n    return typeof val === 'string' ? type === val : null\n  }\n\n  if (op === '!=' && rightType === 'Value') {\n    const val = prop(right, 'value')\n    return typeof val === 'string' ? type !== val : null\n  }\n\n  if (op === 'in' && rightType === 'Array') {\n    const values = extractStringValues(right)\n    return values ? values.includes(type) : null\n  }\n\n  return null\n}\n\nfunction isTypeAttribute(node: Node): boolean {\n  return (node as { type?: string })?.type === 'AccessAttribute' && prop(node, 'name') === '_type'\n}\n\nfunction extractStringValues(arrayNode: Node): string[] | null {\n  const elements = prop(arrayNode, 'elements') as\n    | Array<{ type: string; value?: Node; isSplat?: boolean }>\n    | undefined\n  if (!elements) return null\n  const values: string[] = []\n  for (const el of elements) {\n    if (el.type !== 'ArrayElement' || el.isSplat) return null\n    const val = el.value as Node | undefined\n    if ((val as { type?: string })?.type !== 'Value') return null\n    const v = prop(val!, 'value')\n    if (typeof v !== 'string') return null\n    values.push(v)\n  }\n  return values\n}\n","import { SCHEMA_CONSTANTS } from './constants.js'\nimport type { SchemaField, SchemaFieldDisplayOptions } from './types.js'\n\nconst SIMPLE_TYPE_MAP: Record<string, string> = {\n  document: 'object',\n  crossDatasetReference: 'reference',\n}\n\nconst KNOWN_TYPES = new Set([\n  'string',\n  'text',\n  'number',\n  'boolean',\n  'date',\n  'datetime',\n  'image',\n  'file',\n  'array',\n  'object',\n  'reference',\n  'block',\n  'slug',\n  'geopoint',\n  'span',\n  'url',\n  'email',\n  'color',\n])\n\nfunction getSimpleFieldType(field: SchemaField): string {\n  return SIMPLE_TYPE_MAP[field.type] ?? (KNOWN_TYPES.has(field.type) ? field.type : 'object')\n}\n\nfunction normalize(s: string): string {\n  return s.toLowerCase().replace(/[^a-z0-9]/g, '')\n}\n\nfunction getEnumValues(field: SchemaField): string[] | null {\n  const list = (field.options as Record<string, unknown> | undefined)?.list\n  if (!Array.isArray(list) || list.length === 0) return null\n  return list\n    .map((item: unknown) =>\n      typeof item === 'string' ? item : (item as Record<string, string>).value,\n    )\n    .filter(Boolean)\n}\n\nfunction formatTypeString(field: SchemaField, maxEnumValues: number): string {\n  const enumValues = getEnumValues(field)\n  if (!enumValues) return getSimpleFieldType(field)\n\n  const shown = enumValues.slice(0, maxEnumValues)\n  const overflow = enumValues.length - maxEnumValues\n  return shown.join('|') + (overflow > 0 ? `|...${overflow} more` : '')\n}\n\nfunction formatDescription(\n  field: SchemaField,\n  includeDescription: boolean,\n  maxLen: number,\n): string {\n  if (!includeDescription || !field.title) return ''\n  if (normalize(field.title) === normalize(field.name)) return ''\n  const desc = field.title.length > maxLen ? `${field.title.slice(0, maxLen)}...` : field.title\n  return `: ${desc}`\n}\n\nexport function formatFieldNamesWithTypes(\n  fields: SchemaField[],\n  options?: SchemaFieldDisplayOptions,\n): string {\n  const {\n    showAll,\n    maxCount,\n    includeDescription = false,\n    includeHidden = false,\n    includeDeprecated = false,\n    maxEnumValues = SCHEMA_CONSTANTS.DEFAULTS.maxEnumValues,\n    maxDescriptionLength = SCHEMA_CONSTANTS.DEFAULTS.maxDescriptionLength,\n  } = options ?? {}\n\n  const filtered = fields.filter((f) => {\n    if (!includeDeprecated && f.deprecated) return false\n    if (!includeHidden && f.hidden) return false\n    return true\n  })\n\n  const limit = showAll\n    ? filtered.length\n    : (maxCount ?? SCHEMA_CONSTANTS.DEFAULTS.maxFieldsInSummary)\n\n  return filtered\n    .slice(0, limit)\n    .map((f) => {\n      const typeStr = formatTypeString(f, maxEnumValues)\n      const desc = formatDescription(f, includeDescription, maxDescriptionLength)\n      return `${f.name}<${typeStr}>${desc}`\n    })\n    .join(', ')\n}\n","import { SCHEMA_CONSTANTS } from './constants.js'\nimport { formatFieldNamesWithTypes } from './formatFields.js'\nimport type {\n  DatasetStats,\n  ManifestSchemaType,\n  ProcessedDocumentType,\n  SchemaField,\n  SchemaFieldDisplayOptions,\n} from './types.js'\nimport { shouldSkipType } from './utils.js'\n\nfunction formatReferenceCount(count: number | 'unknown'): string {\n  return typeof count === 'number' && count > 0 ? `×${count}` : ''\n}\n\nfunction formatDocumentCount(count: number | undefined, hasDocumentCounts: boolean): string {\n  return hasDocumentCounts ? String(count ?? 0) : 'unknown'\n}\n\nfunction calculateMaxDepth(\n  fields: SchemaField[],\n  objectTypes: Map<string, ManifestSchemaType>,\n  currentDepth: number = 1,\n  visited: Set<string> = new Set(),\n): number {\n  let max = currentDepth\n\n  for (const field of fields) {\n    if (field.fields?.length) {\n      max = Math.max(max, calculateMaxDepth(field.fields, objectTypes, currentDepth + 1, visited))\n    }\n\n    const checkObjectType = (typeName: string | undefined) => {\n      if (!typeName || visited.has(typeName)) return\n      const obj = objectTypes.get(typeName)\n      if (!obj?.fields?.length) return\n      visited.add(typeName)\n      max = Math.max(max, calculateMaxDepth(obj.fields, objectTypes, currentDepth + 1, visited))\n    }\n\n    checkObjectType(field.type)\n\n    if (Array.isArray(field.of)) {\n      for (const item of field.of) {\n        checkObjectType((item as Record<string, unknown>)?.type as string | undefined)\n      }\n    }\n  }\n\n  return max\n}\n\ntype RefInfo = { outgoing: string; incoming: string }\n\nfunction formatRefsWithCounts(\n  doc: ProcessedDocumentType,\n  referenceCount: DatasetStats['referenceCount'],\n): RefInfo {\n  const counts = referenceCount ?? {}\n\n  const outgoing =\n    [...(doc.outgoingReferencePaths ?? [])]\n      .sort((a, b) => `${a.path}->${a.type}`.localeCompare(`${b.path}->${b.type}`))\n      .map((r) => {\n        const pathKey = `${r.path}->${r.type}`\n        const refCount = counts[doc.name]?.outgoing?.[pathKey]\n        if (typeof refCount !== 'number' || refCount <= 0) return null\n        return `${pathKey}${formatReferenceCount(refCount)}`\n      })\n      .filter(Boolean)\n      .join(', ') || ''\n\n  if (doc.incomingReferences.length === 0) return { outgoing, incoming: '' }\n\n  const incomingParts: string[] = []\n  for (const sourceType of [...doc.incomingReferences].sort()) {\n    const sourceCounts = counts[sourceType]\n    let total = 0\n    if (sourceCounts?.outgoing) {\n      const suffix = `->${doc.name}`\n      for (const [pathKey, pathCount] of Object.entries(sourceCounts.outgoing)) {\n        if (pathKey.endsWith(suffix) && typeof pathCount === 'number' && pathCount > 0) {\n          total += pathCount\n        }\n      }\n    }\n    if (total > 0) incomingParts.push(`${sourceType}${formatReferenceCount(total)}`)\n  }\n\n  return { outgoing, incoming: incomingParts.join(', ') }\n}\n\nfunction formatRefsSimple(doc: ProcessedDocumentType): RefInfo {\n  return {\n    outgoing:\n      doc.outgoingReferences.length > 0 ? [...doc.outgoingReferences].sort().join(', ') : '',\n    incoming:\n      doc.incomingReferences.length > 0 ? [...doc.incomingReferences].sort().join(', ') : '',\n  }\n}\n\nfunction formatDocEntry(\n  name: string,\n  doc: ProcessedDocumentType,\n  objectTypes: Map<string, ManifestSchemaType>,\n  fieldOptions: SchemaFieldDisplayOptions,\n  datasetStats?: DatasetStats,\n): string | null {\n  if (shouldSkipType(name)) return null\n\n  const { documentCount, referenceCount } = datasetStats ?? {}\n  const hasDocumentCounts = !!documentCount\n  const count = documentCount?.[name] ?? 0\n\n  // Skip types with zero documents when we have counts\n  if (documentCount && documentCount[name] === 0) return null\n\n  const useCount = formatDocumentCount(count, hasDocumentCounts)\n\n  // Deprecated types get a condensed single-line entry\n  if (doc.deprecated) {\n    return `- ${name} (DEPRECATED: \"${doc.deprecated.reason}\", count: ${useCount})`\n  }\n\n  const refs = referenceCount ? formatRefsWithCounts(doc, referenceCount) : formatRefsSimple(doc)\n\n  const depth = calculateMaxDepth(doc.fields, objectTypes)\n  const fieldNames = formatFieldNamesWithTypes(doc.fields, fieldOptions)\n  const indent = '  '\n\n  const parts = [`- ${name} (title: ${doc.titleField}, depth: ${depth}, count: ${useCount})`]\n\n  if (doc.description) {\n    const maxLen = SCHEMA_CONSTANTS.DEFAULTS.maxDocDescriptionLength\n    const desc =\n      doc.description.length > maxLen ? `${doc.description.slice(0, maxLen)}...` : doc.description\n    parts.push(`${indent}- description: ${desc}`)\n  }\n\n  parts.push(`${indent}- fields: ${fieldNames}`)\n\n  if (refs.outgoing) parts.push(`${indent}- references: ${refs.outgoing}`)\n  if (refs.incoming) parts.push(`${indent}- referenced by: ${refs.incoming}`)\n\n  return parts.join('\\n')\n}\n\n/**\n * Generates a compressed text representation of processed schema types.\n * Document types are sorted alphabetically, filtered by dataset stats,\n * and formatted with field summaries and reference information.\n */\nexport function formatCompressedSchema(\n  documentTypes: Map<string, ProcessedDocumentType>,\n  objectTypes: Map<string, ManifestSchemaType>,\n  fieldOptions: SchemaFieldDisplayOptions,\n  datasetStats?: DatasetStats,\n): string {\n  return [...documentTypes.entries()]\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([name, doc]) => formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats))\n    .filter(Boolean)\n    .join('\\n')\n}\n","// ---------------------------------------------------------------------------\n// Fetch\n// ---------------------------------------------------------------------------\n\nexport { fetchDatasetStats } from './fetchDatasetStats.js'\nexport {\n  type FetchSchemaOptions,\n  fetchSchemaByDescriptorId,\n  type SchemaCache,\n} from './fetchSchemaByDescriptorId.js'\n\n// ---------------------------------------------------------------------------\n// Process\n// ---------------------------------------------------------------------------\n\nexport { processSchema } from './processSchema.js'\n\n// ---------------------------------------------------------------------------\n// Navigate\n// ---------------------------------------------------------------------------\n\nexport {\n  ARRAY_ITEM_SYSTEM_FIELDS,\n  BUILT_IN_TYPE_FIELDS,\n  DEFAULT_LINK_ANNOTATION,\n} from './navigate/constants.js'\nexport { filterToPath } from './navigate/filterToPath.js'\nexport {\n  resolveFieldSchemaAllUnions,\n  resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions,\n} from './navigate/navigateAllUnions.js'\n// Deprecated aliases — remove in next minor\nexport {\n  resolveFieldSchema,\n  resolveFieldSchema as navigateToFieldSchema,\n} from './navigate/navigateToField.js'\nexport { toSchemaPath } from './navigate/path.js'\nexport { isBuiltInType, isGenericObject, isPrimitiveType } from './navigate/types.js'\n\n// ---------------------------------------------------------------------------\n// Format\n// ---------------------------------------------------------------------------\n\nexport { type FullSchemaOptions, fullSchema } from './fullSchema.js'\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type {\n  CompressedSchemaOptions,\n  DatasetStats,\n  ManifestField,\n  ManifestSchemaType,\n  ProcessedDocumentType,\n  SchemaFieldDisplayOptions,\n  SchemaFilter,\n  SchemaTypes,\n} from './types.js'\nexport { DatasetStatsSchema } from './types.js'\n\n// ---------------------------------------------------------------------------\n// Utilities\n// ---------------------------------------------------------------------------\n\nexport { SCHEMA_CONSTANTS } from './constants.js'\nexport { shouldSkipType } from './utils.js'\n\n// ---------------------------------------------------------------------------\n// Convenience\n// ---------------------------------------------------------------------------\n\nimport { resolveFilter } from './filterDocumentTypes.js'\nimport { formatCompressedSchema } from './formatSchema.js'\nimport { processSchema } from './processSchema.js'\nimport type { CompressedSchemaOptions, ManifestSchemaType } from './types.js'\n\n/**\n * Generates a compressed text representation of a schema for agent consumption.\n *\n * Takes parsed schema types and returns compact text summarizing document types,\n * fields, references, and optionally document/reference counts.\n *\n * The `filter` option accepts either a GROQ filter `{ read?, write? }` or\n * a pre-resolved `string[]` of document type names.\n */\nexport async function compressedSchema(\n  types: ManifestSchemaType[],\n  options: CompressedSchemaOptions = {},\n): Promise<string> {\n  const includeTypes = await resolveFilter(types, options.filter)\n\n  const { documentTypes, objectTypes } = processSchema(types, {\n    filter: includeTypes,\n    fields: options.fields,\n  })\n\n  return formatCompressedSchema(\n    documentTypes,\n    objectTypes,\n    options.fields ?? {},\n    options.datasetStats,\n  )\n}\n"],"names":["result","referencedSchema","processSchema"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/fetchDatasetStats.ts","../src/convertToDefinition.ts","../src/fetchSchemaByDescriptorId.ts","../src/constants.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/utils.ts","../src/fullSchema.ts","../src/types.ts","../src/filterDocumentTypes.ts","../src/formatFields.ts","../src/formatSchema.ts","../src/index.ts"],"sourcesContent":["import type { SanityClient } from '@sanity/client'\nimport type { DatasetStats } from './types.js'\n\ntype DatasetStatsResult = { status: 'ready'; stats: DatasetStats } | { status: 'processing' }\n\ntype FetchDatasetStatsOptions = {\n  organizationId: string\n  projectId: string\n  dataset: string\n}\n\n/**\n * Fetches dataset stats (document counts, reference counts) from the agent API.\n *\n * Returns `{ status: 'processing' }` if stats are still being computed (HTTP 202).\n * The caller should retry after a short delay.\n *\n * The `client` should be configured to point at the agent API host\n * (e.g. `api.sanity.io`) with `useProjectHostname: false`.\n */\nexport async function fetchDatasetStats(\n  client: SanityClient,\n  options: FetchDatasetStatsOptions,\n): Promise<DatasetStatsResult> {\n  const { organizationId, projectId, dataset } = options\n\n  const response = await client.request<DatasetStats | { status: string }>({\n    uri: `/agent/${organizationId}/dataset-stats/${projectId}/${dataset}`,\n  })\n\n  if ('status' in response && response.status === 'processing') {\n    return { status: 'processing' }\n  }\n\n  return { status: 'ready', stats: response as DatasetStats }\n}\n","import type {\n  HoistedEntry,\n  HoistedMarker,\n  InlineOrHoisted,\n  LexiconResponse,\n  ManifestSchemaType,\n  TypeDef,\n} from './types.js'\n\nfunction isHoistedMarker(x: unknown): x is HoistedMarker {\n  if (x === null || typeof x !== 'object') return false\n  const obj = x as Record<string, unknown>\n  return obj.__type === 'hoisted' && typeof obj.key === 'string'\n}\n\nfunction mapperWithHoisting<U>(\n  hoisted: Record<string, HoistedEntry>,\n  map: (input: HoistedEntry) => U,\n): (input: InlineOrHoisted) => U {\n  const cache = new Map<string, U>()\n  return (entry) => {\n    if (isHoistedMarker(entry)) {\n      let result = cache.get(entry.key)\n      if (!result) {\n        const value = hoisted[entry.key]\n        if (!value) throw new Error(`Unknown hoisted key: ${entry.key}`)\n        result = map(value)\n        cache.set(entry.key, result)\n      }\n      return result\n    }\n    return map(entry as HoistedEntry)\n  }\n}\n\nconst STOP = Symbol('STOP')\n\nfunction decodeWithMarkers<T>(x: T): T | undefined {\n  const result = decodeWithMarkersOrStop(x)\n  if (result === STOP) return undefined\n  return result as T\n}\n\nfunction decodeWithMarkersOrStop(x: unknown): unknown {\n  if (x === null || x === undefined || typeof x !== 'object') return x\n\n  if (Array.isArray(x)) {\n    const result = []\n    for (const item of x) {\n      const decoded = decodeWithMarkers(item)\n      if (decoded === STOP) return STOP\n      result.push(decoded)\n    }\n    return result\n  }\n\n  if ('__type' in x) {\n    const typed = x as Record<string, unknown>\n    switch (typed.__type) {\n      case 'function':\n      case 'jsx':\n      case 'unknown':\n      case 'cyclic':\n      case 'maxDepth':\n        return STOP\n      case 'number':\n        return Number(typed.value)\n      case 'undefined':\n        return undefined\n      case 'object':\n        return decodeWithMarkersOrStop(typed.value)\n      default:\n        throw new Error(`unknown type: ${typed.__type}`)\n    }\n  }\n\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(x as Record<string, unknown>)) {\n    const decoded = decodeWithMarkers(value)\n    result[key] = decoded\n  }\n  return result\n}\n\nfunction mutableSqueeze<T extends Record<string, unknown>>(obj: T): T {\n  for (const [key, value] of Object.entries(obj)) {\n    if (value === undefined) delete obj[key]\n  }\n  return obj\n}\n\n/** Types whose raw `fields` array should be stripped during conversion. */\nconst STRIP_FIELDS_TYPES = new Set([\n  'block',\n  'reference',\n  'globalDocumentReference',\n  'crossDatasetReference',\n])\n\n/**\n * Converts a Lexicon schema descriptor response into an array of ManifestSchemaType.\n *\n * The Lexicon API returns a compact representation with hoisted (deduplicated) values.\n * This function expands the hoisted references and converts the compact TypeDef format\n * into the full ManifestSchemaType format used throughout the agent system.\n */\nexport function convertToDefinition(input: LexiconResponse): ManifestSchemaType[] {\n  if (!input?.types || Object.keys(input.types).length === 0) {\n    return []\n  }\n\n  const hoisted = input.hoisted ?? {}\n\n  const convertField = mapperWithHoisting(hoisted, (field) => ({\n    groups: field.groups,\n    fieldset: field.fieldset,\n    ...convertTypeDef(field.name, field.typeDef),\n  }))\n\n  const convertArrayElement = mapperWithHoisting(hoisted, (element) =>\n    convertTypeDef(element.name, element.typeDef),\n  )\n\n  function convertTypeDef(name: string, typeDef: TypeDef): Record<string, unknown> {\n    const { extends: type, fields, fieldsets, to, of, validation, ...rest } = typeDef\n\n    // For block types, extract markDefs.of into marks.annotations before\n    // stripping fields. The Lexicon format stores custom annotation types\n    // (e.g. clockStyle) as block.fields.markDefs.of items, but the agent\n    // system expects them in block.marks.annotations.\n    let marks: Record<string, unknown> | undefined\n    if (type === 'block' && fields) {\n      const markDefsField = fields.find((f) => {\n        if (isHoistedMarker(f)) return false\n        return (f as HoistedEntry).name === 'markDefs'\n      }) as HoistedEntry | undefined\n\n      const markDefsOf = markDefsField?.typeDef?.of\n      if (markDefsOf && markDefsOf.length > 0) {\n        marks = {\n          annotations: markDefsOf.map(convertArrayElement),\n        }\n      }\n    }\n\n    return mutableSqueeze({\n      name,\n      type,\n      fields: fields && !STRIP_FIELDS_TYPES.has(type) ? fields.map(convertField) : undefined,\n      fieldsets: (fieldsets?.length || 0) > 0 ? fieldsets : undefined,\n      of: of ? of.map(convertArrayElement) : undefined,\n      to: to?.map(({ name: toName }) => mutableSqueeze({ type: toName })),\n      validation,\n      marks,\n      ...decodeWithMarkers(rest),\n    })\n  }\n\n  const types: ManifestSchemaType[] = []\n  for (const [name, typeDef] of Object.entries(input.types)) {\n    types.push(convertTypeDef(name, typeDef) as ManifestSchemaType)\n  }\n  return types\n}\n","import type { SanityClient } from '@sanity/client'\nimport { convertToDefinition } from './convertToDefinition.js'\nimport type { LexiconResponse, ManifestSchemaType } from './types.js'\n\nconst DEFAULT_TTL_MS = 5 * 60 * 1000 // 5 minutes\n\ntype CacheEntry = { response: LexiconResponse; expiresAt: number }\n\n/**\n * Cache adapter for raw Lexicon API responses.\n * Wire this to any backing store (Redis, in-memory Map, etc.).\n */\nexport type SchemaCache = {\n  get: (descriptorId: string) => Promise<LexiconResponse | null | undefined>\n  set: (descriptorId: string, response: LexiconResponse) => Promise<void>\n}\n\nconst memoryCache = new Map<string, CacheEntry>()\n\nfunction getFromMemoryCache(descriptorId: string): LexiconResponse | undefined {\n  const entry = memoryCache.get(descriptorId)\n  if (!entry) return undefined\n  if (Date.now() > entry.expiresAt) {\n    memoryCache.delete(descriptorId)\n    return undefined\n  }\n  return entry.response\n}\n\nfunction setInMemoryCache(descriptorId: string, response: LexiconResponse, ttl: number): void {\n  memoryCache.set(descriptorId, { response, expiresAt: Date.now() + ttl })\n}\n\nexport type FetchSchemaOptions = {\n  /**\n   * Enable caching of raw Lexicon responses.\n   * - `true` uses a built-in in-memory cache with a 5-minute TTL\n   * - A `SchemaCache` adapter delegates to any external store (Redis, etc.)\n   */\n  cache?: boolean | SchemaCache\n  /** Cache TTL in milliseconds (default 5 min). Only applies to the built-in memory cache. */\n  ttlMs?: number\n}\n\n/**\n * Fetches and parses a schema from the Lexicon descriptor API.\n *\n * Takes a configured `@sanity/client` instance (which handles auth, host, timeouts)\n * and a descriptor ID. Returns the fully parsed ManifestSchemaType array.\n *\n * Pass `{ cache: true }` to enable in-memory caching (5 min TTL),\n * or provide a custom `SchemaCache` adapter for external stores.\n */\nexport async function fetchSchemaByDescriptorId(\n  client: SanityClient,\n  descriptorId: string,\n  options?: FetchSchemaOptions,\n): Promise<ManifestSchemaType[]> {\n  const { cache, ttlMs = DEFAULT_TTL_MS } = options ?? {}\n\n  // Check cache\n  if (cache === true) {\n    const hit = getFromMemoryCache(descriptorId)\n    if (hit) return convertToDefinition(hit)\n  } else if (cache) {\n    const hit = await cache.get(descriptorId)\n    if (hit) return convertToDefinition(hit)\n  }\n\n  const response = await client.request<LexiconResponse>({\n    uri: `/descriptors/schemas/${descriptorId}`,\n  })\n\n  // Populate cache\n  if (cache === true) {\n    setInMemoryCache(descriptorId, response, ttlMs)\n  } else if (cache) {\n    await cache.set(descriptorId, response).catch(() => {})\n  }\n\n  return convertToDefinition(response)\n}\n","export const SCHEMA_CONSTANTS = {\n  SKIP_PATTERNS: /^(system\\.|sanity\\.|assist\\.|media\\.|mux\\.)/,\n\n  TITLE_FIELD_CANDIDATES: ['title', 'name', 'heading', 'label'] as const,\n\n  DEFAULT_OPTIONS: {\n    trackPaths: true as boolean,\n    maxExpansionDepth: 1 as number,\n  },\n\n  DEFAULTS: {\n    titleField: 'title',\n    fallbackTitleField: '_id',\n    maxFieldsInSummary: 10 as number,\n    maxEnumValues: 10 as number,\n    maxDescriptionLength: 50 as number,\n    maxDocDescriptionLength: 512 as number,\n  },\n} as const\n","import { SCHEMA_CONSTANTS } from './constants.js'\nimport type {\n  ManifestSchemaType,\n  ProcessedDocumentType,\n  ReferenceInfo,\n  SchemaField,\n  SchemaFilter,\n  SchemaProcessorOptions,\n  SchemaTypes,\n} from './types.js'\n\n/**\n * Synchronously resolves a SchemaFilter to a string array.\n * Only handles the string[] case — GROQ filter objects must be\n * pre-resolved via `resolveFilter()` before calling `processSchema`.\n */\nfunction resolveFilterSync(filter: SchemaFilter | undefined): string[] | undefined {\n  if (!filter) return undefined\n  if (Array.isArray(filter)) return filter.length > 0 ? filter : undefined\n  // GROQ filter object — caller should have pre-resolved via resolveFilter()\n  // Ignore silently to avoid breaking sync callers\n  return undefined\n}\n\nconst TITLE_FIELD_CANDIDATES = SCHEMA_CONSTANTS.TITLE_FIELD_CANDIDATES\n\nfunction isTextLike(type: string): boolean {\n  return type === 'string' || type === 'text'\n}\n\nfunction findTitleField(fields: SchemaField[]): string {\n  for (const candidate of TITLE_FIELD_CANDIDATES) {\n    if (fields.some((f) => f.name === candidate && isTextLike(f.type))) return candidate\n  }\n\n  if (fields.some((f) => f.name === 'title')) return 'title'\n\n  const firstText = fields.find((f) => isTextLike(f.type))\n  return firstText?.name ?? SCHEMA_CONSTANTS.DEFAULTS.fallbackTitleField\n}\n\nfunction expandFields(\n  fields: SchemaField[],\n  objectTypes: Map<string, ManifestSchemaType>,\n  depth: number,\n): SchemaField[] {\n  if (depth <= 0) return fields\n\n  return fields.map((field) => {\n    const expanded = { ...field }\n\n    if (field.type && objectTypes.has(field.type)) {\n      const obj = objectTypes.get(field.type)!\n      expanded.type = 'object'\n      expanded.fields = expandFields(obj.fields ?? [], objectTypes, depth - 1)\n    }\n\n    if (Array.isArray(field.of)) {\n      expanded.of = field.of.map((item: Record<string, unknown>) => {\n        const itemType = item?.type as string | undefined\n        if (itemType && objectTypes.has(itemType)) {\n          const obj = objectTypes.get(itemType)!\n          return {\n            ...item,\n            type: 'object',\n            fields: expandFields((obj.fields ?? []) as SchemaField[], objectTypes, depth - 1),\n          }\n        }\n        return item\n      })\n    }\n\n    return expanded\n  })\n}\n\ntype RefTarget = { type?: string }\n\nfunction collectReferences(\n  fields: SchemaField[],\n  path: string,\n  included: (name: string) => boolean,\n  trackPaths: boolean,\n  outgoing: Set<string>,\n  outgoingPaths: ReferenceInfo[],\n  addIncoming: (targetType: string, sourceType: string, fieldPath: string) => void,\n  sourceType: string,\n): void {\n  for (const field of fields) {\n    const fieldPath = path ? `${path}.${field.name}` : field.name\n\n    if (field.type === 'reference' && field.to) {\n      for (const target of field.to as RefTarget[]) {\n        const t = target.type\n        if (!t || !included(t)) continue\n        outgoing.add(t)\n        if (trackPaths) {\n          outgoingPaths.push({ type: t, path: fieldPath })\n          addIncoming(t, sourceType, fieldPath)\n        }\n      }\n    }\n\n    if (field.fields?.length) {\n      collectReferences(\n        field.fields,\n        fieldPath,\n        included,\n        trackPaths,\n        outgoing,\n        outgoingPaths,\n        addIncoming,\n        sourceType,\n      )\n    }\n\n    if (Array.isArray(field.of)) {\n      for (const item of field.of as Record<string, unknown>[]) {\n        if (item?.type === 'reference' && Array.isArray(item.to)) {\n          for (const target of item.to as RefTarget[]) {\n            const t = target.type\n            if (!t || !included(t)) continue\n            outgoing.add(t)\n            const arrayPath = `${fieldPath}[]`\n            if (trackPaths) {\n              outgoingPaths.push({ type: t, path: arrayPath })\n              addIncoming(t, sourceType, arrayPath)\n            }\n          }\n        } else if (Array.isArray(item?.fields)) {\n          collectReferences(\n            item.fields as SchemaField[],\n            `${fieldPath}[]`,\n            included,\n            trackPaths,\n            outgoing,\n            outgoingPaths,\n            addIncoming,\n            sourceType,\n          )\n        }\n      }\n    }\n  }\n}\n\n/**\n * Processes a ManifestSchemaType[] into categorized document/object types\n * with expanded fields, computed references, and identified title fields.\n */\nexport function processSchema(\n  schema: ManifestSchemaType[],\n  options?: SchemaProcessorOptions,\n): SchemaTypes {\n  const trackPaths = SCHEMA_CONSTANTS.DEFAULT_OPTIONS.trackPaths\n  const includeList = resolveFilterSync(options?.filter)\n  const includeSet = includeList?.length ? new Set(includeList) : null\n  const included = (name: string) => !includeSet || includeSet.has(name)\n\n  const maxDepth = SCHEMA_CONSTANTS.DEFAULT_OPTIONS.maxExpansionDepth\n\n  // 1. Categorize into document vs object types\n  const documentTypes = new Map<string, ProcessedDocumentType>()\n  const objectTypes = new Map<string, ManifestSchemaType>()\n\n  for (const type of schema) {\n    if (type.type === 'document') {\n      if (!included(type.name)) continue\n      documentTypes.set(type.name, {\n        name: type.name,\n        title: type.title,\n        description: type.description,\n        deprecated: type.deprecated,\n        liveEdit: type.liveEdit === true ? true : undefined,\n        titleField: SCHEMA_CONSTANTS.DEFAULTS.titleField,\n        fields: type.fields ?? [],\n        outgoingReferences: [],\n        incomingReferences: [],\n      })\n    } else if (type.type === 'object') {\n      objectTypes.set(type.name, type)\n    }\n  }\n\n  // 2. Expand object type references in document fields\n  for (const doc of documentTypes.values()) {\n    doc.fields = expandFields(doc.fields, objectTypes, maxDepth)\n  }\n\n  // 3. Compute references (outgoing + incoming)\n  // incoming tracker: targetType -> Map<sourceType, Set<path>>\n  const incomingMap = new Map<string, Map<string, Set<string>>>()\n  // simple incoming: targetType -> Set<sourceType>\n  const incomingSimple = new Map<string, Set<string>>()\n\n  const addIncoming = (targetType: string, sourceType: string, fieldPath: string) => {\n    if (!incomingSimple.has(targetType)) incomingSimple.set(targetType, new Set())\n    incomingSimple.get(targetType)!.add(sourceType)\n\n    if (!incomingMap.has(targetType)) incomingMap.set(targetType, new Map())\n    const sourceMap = incomingMap.get(targetType)!\n    if (!sourceMap.has(sourceType)) sourceMap.set(sourceType, new Set())\n    sourceMap.get(sourceType)!.add(fieldPath)\n  }\n\n  for (const [docName, doc] of documentTypes) {\n    const outgoing = new Set<string>()\n    const outgoingPaths: ReferenceInfo[] = []\n\n    collectReferences(\n      doc.fields,\n      '',\n      included,\n      trackPaths,\n      outgoing,\n      outgoingPaths,\n      addIncoming,\n      docName,\n    )\n\n    // Also track simple incoming for non-trackPaths mode\n    if (!trackPaths) {\n      for (const targetType of outgoing) {\n        if (!incomingSimple.has(targetType)) incomingSimple.set(targetType, new Set())\n        incomingSimple.get(targetType)!.add(docName)\n      }\n    }\n\n    doc.outgoingReferences = Array.from(outgoing)\n    if (trackPaths) doc.outgoingReferencePaths = outgoingPaths\n  }\n\n  // Apply incoming references to target documents\n  for (const [targetType, sources] of incomingSimple) {\n    const target = documentTypes.get(targetType)\n    if (!target) continue\n    target.incomingReferences = Array.from(sources)\n\n    if (trackPaths && incomingMap.has(targetType)) {\n      const paths: ReferenceInfo[] = []\n      for (const [sourceType, fieldPaths] of incomingMap.get(targetType)!) {\n        for (const p of fieldPaths) {\n          paths.push({ type: sourceType, path: p })\n        }\n      }\n      target.incomingReferencePaths = paths\n    }\n  }\n\n  // 4. Identify title fields\n  for (const doc of documentTypes.values()) {\n    doc.titleField = findTitleField(doc.fields)\n  }\n\n  return { documentTypes, objectTypes }\n}\n\n/**\n * Expands fields for a single type at a given depth.\n * Used by getTypeSignature to expand on-demand.\n */\nexport function expandFieldsForType(\n  fields: SchemaField[],\n  objectTypes: Map<string, ManifestSchemaType>,\n  depth: number,\n): SchemaField[] {\n  return expandFields(fields, objectTypes, depth)\n}\n","import type { ManifestSchemaType } from '../types.js'\n\n/**\n * Built-in Sanity type fields that exist implicitly (not in schema).\n * Maps type name to field definitions.\n */\nexport const BUILT_IN_TYPE_FIELDS: Record<string, Record<string, ManifestSchemaType>> = {\n  slug: {\n    current: { name: 'current', type: 'string' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  geopoint: {\n    lat: { name: 'lat', type: 'number' } as ManifestSchemaType,\n    lng: { name: 'lng', type: 'number' } as ManifestSchemaType,\n    alt: { name: 'alt', type: 'number' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  reference: {\n    _ref: { name: '_ref', type: 'string' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n    _weak: { name: '_weak', type: 'boolean' } as ManifestSchemaType,\n  },\n  image: {\n    asset: { name: 'asset', type: 'reference' } as ManifestSchemaType,\n    hotspot: {\n      name: 'hotspot',\n      type: 'object',\n      fields: [\n        { name: 'x', type: 'number' },\n        { name: 'y', type: 'number' },\n        { name: 'height', type: 'number' },\n        { name: 'width', type: 'number' },\n      ],\n    } as ManifestSchemaType,\n    crop: {\n      name: 'crop',\n      type: 'object',\n      fields: [\n        { name: 'top', type: 'number' },\n        { name: 'bottom', type: 'number' },\n        { name: 'left', type: 'number' },\n        { name: 'right', type: 'number' },\n      ],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  file: {\n    asset: { name: 'asset', type: 'reference' } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  block: {\n    style: { name: 'style', type: 'string' } as ManifestSchemaType,\n    listItem: { name: 'listItem', type: 'string' } as ManifestSchemaType,\n    level: { name: 'level', type: 'number' } as ManifestSchemaType,\n    children: {\n      name: 'children',\n      type: 'array',\n      of: [{ name: 'span', type: 'span' }],\n    } as ManifestSchemaType,\n    markDefs: {\n      name: 'markDefs',\n      type: 'array',\n      of: [{ name: 'object', type: 'object' }],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n  span: {\n    text: { name: 'text', type: 'string' } as ManifestSchemaType,\n    marks: {\n      name: 'marks',\n      type: 'array',\n      of: [{ name: 'string', type: 'string' }],\n    } as ManifestSchemaType,\n    _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n  },\n}\n\n/**\n * Default annotation type for Portable Text blocks.\n * Sanity implicitly includes \"link\" when no marks.annotations are declared.\n */\nexport const DEFAULT_LINK_ANNOTATION: ManifestSchemaType = {\n  name: 'link',\n  type: 'object',\n  fields: [\n    { name: 'href', type: 'string' },\n    { name: 'blank', type: 'boolean' },\n  ],\n} as ManifestSchemaType\n\n/**\n * System fields that exist on all array items.\n */\nexport const ARRAY_ITEM_SYSTEM_FIELDS: Record<string, ManifestSchemaType> = {\n  _key: { name: '_key', type: 'string' } as ManifestSchemaType,\n  _type: { name: '_type', type: 'string' } as ManifestSchemaType,\n}\n","/**\n * Filter schema types to specific field paths.\n * Used for displaying filtered views of schema types.\n */\n\nimport type { ManifestField, ManifestSchemaType } from '../types.js'\n\n/**\n * Parse of[N] syntax from a path segment\n */\nfunction parseOfIndexSyntax(segment: string): number | null {\n  const match = segment.match(/^of\\[(\\d+)\\]$/)\n  if (!match) return null\n  return parseInt(match[1], 10)\n}\n\n/**\n * Parse array notation from a path segment.\n * Handles both numeric indices [0] and _key selectors [_key==\"value\"].\n */\nfunction parseArrayNotation(segment: string): { fieldName: string; isArray: true } | null {\n  // Match field name followed by any bracket notation: field[...] or field[_key==\"...\"]\n  const match = segment.match(/^([^[]+)\\[.*\\]$/)\n  if (!match) return null\n  return { fieldName: match[1], isArray: true }\n}\n\n/**\n * Create a \"not found\" marker for path navigation errors\n */\nfunction createNotFoundMarker(): ManifestSchemaType {\n  return { name: '', type: 'notfound', fields: [] } as ManifestSchemaType\n}\n\n/**\n * Navigate to an of[N] index in an array type\n */\nfunction navigateToOfIndex(node: ManifestSchemaType, index: number): ManifestSchemaType | null {\n  if (!node.of || !Array.isArray(node.of)) return null\n  if (index < 0 || index >= node.of.length) return null\n  return node.of[index] as ManifestSchemaType\n}\n\n/**\n * Navigate to a property of a schema node (not a field, but a schema property like marks, styles, etc.)\n */\nfunction navigateToSchemaProperty(\n  node: ManifestSchemaType,\n  propertyName: string,\n  isLastSegment: boolean,\n): { result: ManifestSchemaType | null; continueWith?: ManifestSchemaType } {\n  if (!node || typeof node !== 'object' || !(propertyName in node)) {\n    return { result: null }\n  }\n\n  const propertyValue = (node as Record<string, unknown>)[propertyName]\n\n  // If this is the last segment, wrap and return the property\n  if (isLastSegment) {\n    // For arrays, preserve the array structure\n    if (Array.isArray(propertyValue)) {\n      return {\n        result: {\n          name: propertyName,\n          type: 'array',\n          of: propertyValue,\n        } as ManifestSchemaType,\n      }\n    }\n\n    // For objects, spread the properties\n    return {\n      result: {\n        name: propertyName,\n        type:\n          typeof propertyValue === 'object' && propertyValue !== null\n            ? 'object'\n            : typeof propertyValue,\n        ...(propertyValue as Record<string, unknown>),\n      } as ManifestSchemaType,\n    }\n  }\n\n  // Not last segment - try to navigate deeper\n  if (typeof propertyValue === 'object' && propertyValue !== null) {\n    // For arrays, wrap them so of[N] navigation works\n    if (Array.isArray(propertyValue)) {\n      return {\n        result: null,\n        continueWith: {\n          type: 'array',\n          of: propertyValue,\n        } as ManifestSchemaType,\n      }\n    }\n\n    // For objects, continue navigation\n    return {\n      result: null,\n      continueWith: propertyValue as ManifestSchemaType,\n    }\n  }\n\n  return { result: null }\n}\n\n/**\n * Resolve the 'of' array for an array field, looking up referenced types if needed\n */\nfunction resolveArrayFieldOf(\n  field: ManifestField,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType[] | null {\n  // First check if field has inline 'of'\n  if (field.of) return field.of as ManifestSchemaType[]\n\n  // Field references another type - look it up in schema\n  if (field.type) {\n    const referencedType = schema.find((t) => t.name === field.type)\n    if (referencedType?.of) {\n      return referencedType.of as ManifestSchemaType[]\n    }\n  }\n\n  return null\n}\n\n/**\n * Create an array type node from a field (for navigation purposes)\n */\nfunction createArrayTypeFromField(\n  field: ManifestField,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType {\n  // Try to find the referenced array type\n  if (field.type) {\n    const arrayType = schema.find((t) => t.name === field.type)\n    if (arrayType) return arrayType\n  }\n\n  // Create inline array type\n  return {\n    ...field,\n    name: field.name,\n    type: 'array',\n  } as ManifestSchemaType\n}\n\n/**\n * Filter a schema type to a specific field path.\n * Supports complex path navigation including:\n * - Dot notation: \"author.person\"\n * - Array notation: \"content[]\"\n * - Array item navigation: \"content[].image\"\n * - of[N] indexed navigation: \"of[0]\", \"content.of[1]\"\n * - Property navigation: \"of[0].marks\", \"of[0].marks.annotations\"\n *\n * @param type - The schema type to filter\n * @param path - The path to filter to\n * @param schema - Full schema array to resolve type references\n * @returns A modified type containing only the specified field path, or a not-found marker\n */\nexport function filterToPath(\n  type: ManifestSchemaType,\n  path: string,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType {\n  // Parse the path segments - split on dots that are NOT inside brackets\n  const segments = path.split(/\\.(?![^[]*\\])/)\n\n  // Handle direct of[N] access on array types (e.g., type=\"arrayType\", path=\"of[0]\")\n  if (segments.length === 1 && segments[0].startsWith('of[')) {\n    const index = parseOfIndexSyntax(segments[0])\n    if (index !== null) {\n      const item = navigateToOfIndex(type, index)\n      if (item) return item\n      // Index out of bounds\n      return { ...type, fields: [], of: undefined }\n    }\n  }\n\n  // Start with the type's fields or of array\n  let currentNode: ManifestSchemaType = type\n  let currentFields: ManifestField[] | undefined = type.fields\n\n  // Navigate to the target field\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    // Check for of[N] syntax for navigating array type definitions\n    const ofIndex = parseOfIndexSyntax(segment)\n    if (ofIndex !== null) {\n      const item = navigateToOfIndex(currentNode, ofIndex)\n\n      if (item) {\n        // If this is the last segment, return this item\n        if (i === segments.length - 1) {\n          return item\n        }\n\n        // Otherwise, navigate into this item\n        currentNode = item\n        currentFields = currentNode.fields\n        continue\n      }\n\n      // Index out of bounds or not an array type\n      return { ...type, fields: [], of: undefined }\n    }\n\n    // Handle regular field access or array notation: \"field[]\" or \"field[index]\"\n    const arrayNotation = parseArrayNotation(segment)\n    const fieldName = arrayNotation ? arrayNotation.fieldName : segment\n\n    // Try to find as a field first\n    const field: ManifestField | undefined = currentFields?.find((f) => f.name === fieldName)\n\n    if (!field) {\n      // Not a field - check if it's a property of the current schema node\n      // This allows navigation like of[0].marks or of[0].styles\n      const isLastSegment = i === segments.length - 1\n      const propertyNav = navigateToSchemaProperty(currentNode, fieldName, isLastSegment)\n\n      if (propertyNav.result) {\n        return propertyNav.result\n      }\n\n      if (propertyNav.continueWith) {\n        currentNode = propertyNav.continueWith\n        currentFields = currentNode.fields\n        continue\n      }\n\n      // Field not found and not a property - return not found marker\n      return createNotFoundMarker()\n    }\n\n    // If this is the last segment, we found our target\n    if (i === segments.length - 1) {\n      // Check if this is array notation (field[])\n      if (arrayNotation) {\n        const indexMatch = segment.match(/\\[(\\d+)\\]$/)\n        if (indexMatch) {\n          // This is field[N] syntax - not supported yet, treat as field[]\n        }\n\n        // For array notation (field[]), return the array type directly\n        // This prevents path recursion in navigator (e.g., content[].content[])\n        return createArrayTypeFromField(field, schema)\n      }\n      // Return a modified type with only this field\n      return { ...type, fields: [field] }\n    }\n\n    // Navigate deeper\n    if (arrayNotation) {\n      // For arrays, look in the 'of' items using helper\n      const fieldOf = resolveArrayFieldOf(field, schema)\n\n      if (!fieldOf) {\n        // No array items found\n        return { ...type, fields: [] }\n      }\n\n      // Update currentNode to be the array field's type for of[N] navigation\n      currentNode = createArrayTypeFromField(field, schema)\n\n      const nextSegment = segments[i + 1]\n      if (!nextSegment) {\n        // Path ends with [] - can't navigate further in this loop\n        continue\n      }\n\n      // CASE 0: Check if nextSegment is of[N] syntax - this allows content[].of[0] navigation\n      const nextOfIndex = parseOfIndexSyntax(nextSegment)\n      if (nextOfIndex !== null) {\n        // Navigate to the of[N] item in the array type\n        const item = navigateToOfIndex(currentNode, nextOfIndex)\n        if (item) {\n          // Check if this is the last segment\n          if (i + 1 === segments.length - 1) {\n            // Return the array item directly\n            return item\n          }\n          // More segments after of[N] - continue navigation from this item\n          currentNode = item\n          currentFields = item.fields\n          i++ // Consume the of[N] segment\n          continue\n        } else {\n          // Index out of bounds\n          return { ...type, fields: [], of: undefined }\n        }\n      }\n\n      // CASE 1: Check if nextSegment matches an array item TYPE NAME\n      const arrayItemByType = fieldOf.find(\n        (item) => item.name === nextSegment || item.type === nextSegment,\n      )\n\n      if (arrayItemByType) {\n        // Found a matching type!\n        // Check if this is the LAST segment in the path\n        if (i + 1 === segments.length - 1) {\n          // This IS the final destination - return the matched type\n          // Whether or not it has fields, we return it\n          return { ...type, fields: [{ ...field, of: [arrayItemByType] }] }\n        }\n\n        // More segments after this - need to navigate into the type's fields\n        if (arrayItemByType.fields) {\n          currentFields = arrayItemByType.fields\n          i++ // Consume the type name segment\n          continue\n        } else {\n          // Type has no fields (primitive) but path continues - error\n          return { ...type, fields: [] }\n        }\n      }\n\n      // CASE 2: nextSegment is not a type name - try to find it as a FIELD NAME across all array item types\n      const matchingFields: Array<{ typeName: string; field: ManifestField }> = []\n      for (const item of fieldOf) {\n        const itemAsType = item as ManifestSchemaType\n        if (itemAsType.fields && Array.isArray(itemAsType.fields)) {\n          const matchingField = itemAsType.fields.find((f: ManifestField) => f.name === nextSegment)\n          if (matchingField) {\n            matchingFields.push({\n              typeName: (itemAsType.name || itemAsType.type) as string,\n              field: matchingField,\n            })\n          }\n        }\n      }\n\n      if (matchingFields.length === 0) {\n        // Field not found in any array item type\n        return { ...type, fields: [] }\n      }\n\n      // Found field(s) - if this is the last segment, return the matches\n      if (i + 1 === segments.length - 1) {\n        // This is the last segment - return the matching field(s)\n        // If only one match, we can return it directly as nested under the array\n        // If multiple matches from different array types, show all of them\n        if (matchingFields.length === 1) {\n          // Single match - create array field with nested fields showing the matched field\n          const match = matchingFields[0]\n          const syntheticArrayField: ManifestField = {\n            ...field,\n            of: [\n              {\n                name: match.typeName,\n                type: 'object',\n                fields: [match.field], // The matched field\n              },\n            ],\n          }\n          return { ...type, fields: [syntheticArrayField] }\n        } else {\n          // Multiple matches - show all matching fields from different types\n          const syntheticArrayField: ManifestField = {\n            ...field,\n            of: matchingFields.map((m) => ({\n              name: m.typeName,\n              type: 'object',\n              fields: [m.field],\n            })),\n          }\n          return { ...type, fields: [syntheticArrayField] }\n        }\n      }\n\n      // More segments after this - continue navigation from the first match\n      // (In practice, multiple matches with further navigation is complex - we'll use first match)\n      currentFields = matchingFields[0].field.fields\n      i++ // Consume the field name segment\n    } else if (field.fields) {\n      // For objects, look in fields\n      currentFields = field.fields\n    } else {\n      // Can't navigate deeper\n      return { ...type, fields: [] }\n    }\n  }\n\n  return { ...type, fields: [] }\n}\n","/**\n * Convert a document path string to a schema path string.\n * Strips array indices, _key selectors, and internal markers.\n *\n * Examples:\n * - `\"content[_key==\\\"abc\\\"].children[0].text\"` → `\"content.children.text\"`\n * - `\"tags[0]\"` → `\"tags\"`\n * - `\"seo.image.asset\"` → `\"seo.image.asset\"`\n * - `\"items[append:3]\"` → `\"items\"`\n *\n * This is a self-contained implementation that avoids depending on\n * `@sanity/types` for path segment parsing.\n */\nexport function toSchemaPath(path: string): string {\n  if (!path) return ''\n\n  return (\n    path\n      // Strip internal markers: [append:N]\n      .replace(/\\[append:\\d+\\]/g, '')\n      // Strip _key selectors: [_key==\"value\"] or [_key=='value']\n      .replace(/\\[_key\\s*==\\s*[\"'][^\"']*[\"']\\]/g, '')\n      // Strip numeric indices: [0], [123]\n      .replace(/\\[\\d+\\]/g, '')\n      // Strip empty brackets: []\n      .replace(/\\[\\]/g, '')\n      // Collapse any resulting double dots\n      .replace(/\\.{2,}/g, '.')\n      // Trim leading/trailing dots\n      .replace(/^\\.+|\\.+$/g, '')\n  )\n}\n","const BASE_PRIMITIVES = ['string', 'number', 'boolean', 'date', 'datetime', 'text', 'url', 'email']\n\nconst BLOCK_TYPES = ['block', 'reference']\n\n/**\n * Check if a type name represents a primitive type.\n *\n * When `includeBlockTypes` is true, 'block' and 'reference' are also\n * considered primitive (useful for navigator/large-node detection where\n * you don't want to drill into these).\n */\nexport function isPrimitiveType(\n  typeName: string | undefined,\n  options: { includeBlockTypes?: boolean } = {},\n): boolean {\n  if (!typeName) return false\n  if (options.includeBlockTypes) {\n    return BASE_PRIMITIVES.includes(typeName) || BLOCK_TYPES.includes(typeName)\n  }\n  return BASE_PRIMITIVES.includes(typeName)\n}\n\n/**\n * Check if a type is a built-in Sanity type (superset of primitives).\n * Includes complex built-in types like array, object, image, file, slug, etc.\n */\nexport function isBuiltInType(type: string): boolean {\n  return BUILT_IN_TYPES.has(type)\n}\n\nconst BUILT_IN_TYPES = new Set([\n  'string',\n  'text',\n  'number',\n  'boolean',\n  'array',\n  'object',\n  'reference',\n  'image',\n  'file',\n  'date',\n  'datetime',\n  'url',\n  'slug',\n  'block',\n  'geopoint',\n])\n\n/**\n * Check if a node is a generic object-like node.\n * Generic objects are objects that don't have a `fields` array and\n * aren't array types with `of`. These include block types and other\n * object-shaped schemas with properties like marks, lists, styles, etc.\n */\nexport function isGenericObject(node: unknown): boolean {\n  if (typeof node !== 'object' || node === null || Array.isArray(node)) return false\n  const obj = node as Record<string, unknown>\n  return !obj.fields && !(obj.type === 'array' && Array.isArray(obj.of))\n}\n","import type { ManifestSchemaType } from '../types.js'\nimport { toSchemaPath } from './path.js'\nimport { isBuiltInType } from './types.js'\n\n/**\n * Resolves a document path to field schemas, returning ALL possible schemas for union types.\n * This is important for arrays with multiple `of` types where a field might exist\n * in some but not all union types.\n */\nexport function resolveFieldSchemaAllUnions(\n  path: string,\n  typeSchema: ManifestSchemaType,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType[] {\n  const pathParts = toSchemaPath(path).split('.').filter(Boolean)\n\n  let currentSchemas: ManifestSchemaType[] = [typeSchema]\n\n  for (let i = 0; i < pathParts.length; i++) {\n    const part = pathParts[i]\n    const isLastPart = i === pathParts.length - 1\n    const nextSchemas: ManifestSchemaType[] = []\n\n    for (const currentSchema of currentSchemas) {\n      if (!currentSchema?.fields || !Array.isArray(currentSchema.fields)) {\n        continue\n      }\n\n      const field = currentSchema.fields.find((f) => f.name === part)\n      if (!field) continue\n\n      if (field.type === 'array' && field.of && field.of.length > 0) {\n        for (const itemSchema of field.of) {\n          const itemType = typeof itemSchema.type === 'string' ? itemSchema.type : undefined\n          if (isLastPart && (itemType === 'image' || itemType === 'file')) {\n            nextSchemas.push(itemSchema as ManifestSchemaType)\n          } else if (itemType && !isBuiltInType(itemType)) {\n            const foundSchema = schema.find((s) => s.name === itemType)\n            if (foundSchema) nextSchemas.push(foundSchema)\n          } else if ((itemSchema as ManifestSchemaType).fields) {\n            nextSchemas.push(itemSchema as ManifestSchemaType)\n          }\n        }\n      } else if (field.type && !isBuiltInType(field.type)) {\n        const foundSchema = schema.find((s) => s.name === field.type)\n        if (foundSchema) {\n          if (foundSchema.type === 'array' && foundSchema.of && foundSchema.of.length > 0) {\n            for (const itemSchema of foundSchema.of) {\n              const itemType = typeof itemSchema.type === 'string' ? itemSchema.type : undefined\n              if (isLastPart && (itemType === 'image' || itemType === 'file')) {\n                nextSchemas.push(itemSchema as ManifestSchemaType)\n              } else if (itemType && !isBuiltInType(itemType)) {\n                const itemFoundSchema = schema.find((s) => s.name === itemType)\n                if (itemFoundSchema) nextSchemas.push(itemFoundSchema)\n              } else if ((itemSchema as ManifestSchemaType).fields) {\n                nextSchemas.push(itemSchema as ManifestSchemaType)\n              }\n            }\n          } else {\n            nextSchemas.push(foundSchema)\n          }\n        }\n      } else {\n        nextSchemas.push(field as ManifestSchemaType)\n      }\n    }\n\n    currentSchemas = nextSchemas\n  }\n\n  return currentSchemas\n}\n","import type { ManifestField, ManifestSchemaType } from '../types.js'\nimport {\n  ARRAY_ITEM_SYSTEM_FIELDS,\n  BUILT_IN_TYPE_FIELDS,\n  DEFAULT_LINK_ANNOTATION,\n} from './constants.js'\nimport { toSchemaPath } from './path.js'\nimport { isPrimitiveType } from './types.js'\n\ninterface SchemaResolutionResult {\n  schema: ManifestSchemaType | null\n  earlyReturn: ManifestSchemaType | null\n}\n\nfunction getBuiltInFieldSchema(\n  segment: string,\n  currentSchema: ManifestSchemaType,\n): ManifestSchemaType | null {\n  if (!currentSchema?.type || !BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {\n    return null\n  }\n\n  let builtInField: ManifestSchemaType = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment]\n\n  // For block.children, merge in block.of (inline objects) from the schema\n  if (currentSchema.type === 'block' && segment === 'children' && currentSchema.of) {\n    builtInField = {\n      ...builtInField,\n      of: [...(builtInField.of || []), ...(currentSchema.of as ManifestSchemaType[])],\n    }\n  }\n\n  // For block.markDefs, merge in block.marks.annotations from the schema\n  // If no annotations are declared, add default \"link\" annotation (Sanity built-in)\n  if (currentSchema.type === 'block' && segment === 'markDefs') {\n    const annotations = (\n      currentSchema as ManifestSchemaType & { marks?: { annotations?: ManifestSchemaType[] } }\n    ).marks?.annotations\n    if (annotations) {\n      builtInField = {\n        ...builtInField,\n        of: [...(builtInField.of || []), ...annotations],\n      }\n    } else {\n      builtInField = {\n        ...builtInField,\n        of: [...(builtInField.of || []), DEFAULT_LINK_ANNOTATION],\n      }\n    }\n  }\n\n  return builtInField\n}\n\nfunction findSchemaInUnionArray(\n  segment: string,\n  arraySchema: ManifestSchemaType,\n  allSchemas: ManifestSchemaType[],\n  isLastSegment: boolean,\n): SchemaResolutionResult {\n  if (!arraySchema.of || arraySchema.of.length === 0) {\n    return { schema: null, earlyReturn: null }\n  }\n\n  for (const itemSchema of arraySchema.of as ManifestSchemaType[]) {\n    if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[segment]) {\n      const builtInField = BUILT_IN_TYPE_FIELDS[itemSchema.type][segment]\n      if (isLastSegment) {\n        return { schema: null, earlyReturn: builtInField }\n      }\n      return { schema: builtInField, earlyReturn: null }\n    }\n\n    if (itemSchema.fields?.some((f) => f.name === segment)) {\n      return { schema: itemSchema, earlyReturn: null }\n    }\n\n    if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {\n      const referencedSchema = allSchemas.find((s) => s.name === itemSchema.type)\n      if (referencedSchema?.fields?.some((f) => f.name === segment)) {\n        return { schema: referencedSchema, earlyReturn: null }\n      }\n    }\n  }\n\n  const firstItem = arraySchema.of[0] as ManifestSchemaType\n  if (firstItem.fields) {\n    return { schema: firstItem, earlyReturn: null }\n  }\n\n  const referencedSchema = allSchemas.find((s) => s.name === firstItem.type)\n  if (referencedSchema?.fields) {\n    return { schema: referencedSchema, earlyReturn: null }\n  }\n\n  return { schema: null, earlyReturn: null }\n}\n\nfunction resolveCurrentSchema(\n  segment: string,\n  currentSchema: ManifestSchemaType,\n  allSchemas: ManifestSchemaType[],\n  isLastSegment: boolean,\n): SchemaResolutionResult {\n  if (!currentSchema?.type) {\n    return { schema: null, earlyReturn: null }\n  }\n\n  if (currentSchema.type === 'array' && currentSchema.of && currentSchema.of.length > 0) {\n    return findSchemaInUnionArray(segment, currentSchema, allSchemas, isLastSegment)\n  }\n\n  const referencedSchema = allSchemas.find((s) => s.name === currentSchema.type)\n  if (referencedSchema?.fields) {\n    return { schema: referencedSchema, earlyReturn: null }\n  }\n\n  if (BUILT_IN_TYPE_FIELDS[currentSchema.type]?.[segment]) {\n    const builtInField = BUILT_IN_TYPE_FIELDS[currentSchema.type][segment]\n    if (isLastSegment) {\n      return { schema: null, earlyReturn: builtInField }\n    }\n    return { schema: builtInField, earlyReturn: null }\n  }\n\n  return { schema: null, earlyReturn: null }\n}\n\nfunction getNextSchemaForField(\n  field: ManifestField,\n  nextSegment: string,\n  allSchemas: ManifestSchemaType[],\n): ManifestSchemaType {\n  let resolvedField: ManifestSchemaType = field as ManifestSchemaType\n  if (field.type && !isPrimitiveType(field.type) && field.type !== 'array') {\n    const referencedSchema = allSchemas.find((s) => s.name === field.type)\n    if (referencedSchema) {\n      resolvedField = referencedSchema\n    }\n  }\n\n  if (resolvedField.type === 'array' && resolvedField.of && resolvedField.of.length > 0) {\n    for (const itemSchema of resolvedField.of as ManifestSchemaType[]) {\n      if (BUILT_IN_TYPE_FIELDS[itemSchema.type]?.[nextSegment]) {\n        return itemSchema\n      }\n      if (itemSchema.fields?.some((f) => f.name === nextSegment)) {\n        return itemSchema\n      }\n      if (itemSchema.type && !isPrimitiveType(itemSchema.type)) {\n        const refSchema = allSchemas.find((s) => s.name === itemSchema.type)\n        if (refSchema?.fields?.some((f) => f.name === nextSegment)) {\n          return refSchema\n        }\n      }\n    }\n    return resolvedField.of[0] as ManifestSchemaType\n  }\n\n  return resolvedField\n}\n\n/**\n * Resolves a document path to the field schema at that location.\n * Handles nested paths like \"author.name\" and array paths like \"tags[0]\".\n *\n * Returns the field schema at the path, NOT navigating into arrays.\n * For \"tags\" (an array field), returns the array field schema (with 'of').\n * For \"tags[0].foo\", returns the \"foo\" field from the array item schema.\n */\nexport function resolveFieldSchema(\n  path: string,\n  typeSchema: ManifestSchemaType,\n  schema: ManifestSchemaType[],\n): ManifestSchemaType | null {\n  const segments = toSchemaPath(path).split('.').filter(Boolean)\n\n  let currentSchema: ManifestSchemaType | undefined = typeSchema\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n    const isLastSegment = i === segments.length - 1\n\n    if (ARRAY_ITEM_SYSTEM_FIELDS[segment]) {\n      return ARRAY_ITEM_SYSTEM_FIELDS[segment]\n    }\n\n    const builtInField = getBuiltInFieldSchema(segment, currentSchema!)\n    if (builtInField) {\n      if (isLastSegment) return builtInField\n      currentSchema = builtInField\n      continue\n    }\n\n    if (!currentSchema?.fields) {\n      const resolved = resolveCurrentSchema(segment, currentSchema!, schema, isLastSegment)\n      if (resolved.earlyReturn) return resolved.earlyReturn\n      if (!resolved.schema) return null\n      currentSchema = resolved.schema\n\n      const resolvedBuiltInField = getBuiltInFieldSchema(segment, currentSchema)\n      if (resolvedBuiltInField) {\n        if (isLastSegment) return resolvedBuiltInField\n        currentSchema = resolvedBuiltInField\n        continue\n      }\n    }\n\n    if (!currentSchema?.fields) return null\n\n    const field = currentSchema.fields.find((f) => f.name === segment)\n    if (!field) return null\n    if (isLastSegment) return field\n\n    currentSchema = getNextSchemaForField(field, segments[i + 1], schema)\n  }\n\n  return currentSchema || null\n}\n","import { SCHEMA_CONSTANTS } from './constants.js'\n\nexport function shouldSkipType(typeName: string): boolean {\n  return SCHEMA_CONSTANTS.SKIP_PATTERNS.test(typeName)\n}\n","import { filterToPath } from './navigate/filterToPath.js'\nimport { isGenericObject, isPrimitiveType } from './navigate/types.js'\nimport type { ManifestField, ManifestSchemaType } from './types.js'\nimport { shouldSkipType } from './utils.js'\n\nexport type FullSchemaOptions = {\n  /** The document type name to return (e.g. \"post\"). */\n  type: string\n  /** Optional field path to scope the result (e.g. \"content\" or \"content[].codeBlock\"). */\n  path?: string\n  /** Size threshold in bytes before returning a navigator instead of the full JSON (default 200KB). */\n  sizeThreshold?: number\n}\n\ntype LargeNodeNavigator = {\n  _rawLargeNode: true\n  name: string\n  type: string\n  children: Array<{ type: string; path: string }>\n  hint: string\n}\n\n/**\n * Returns the complete JSON structure for a specific document type, optionally\n * scoped to a field path. Internal/system types are filtered out.\n *\n * When the JSON output exceeds `sizeThreshold`, a navigator object is returned\n * instead — listing child paths the caller can drill into.\n *\n * This is the counterpart to `compressedSchema`:\n * - `compressedSchema` → lossy text summary for LLM context windows\n * - `fullSchema` → complete JSON for schema explorer tools and mutation agents\n */\nexport function fullSchema(\n  schema: ManifestSchemaType[],\n  options: FullSchemaOptions,\n): Record<string, unknown> | LargeNodeNavigator {\n  const { type: typeName, path, sizeThreshold = 200 * 1024 } = options\n\n  const type = schema.find((t) => t.name === typeName)\n  if (!type) {\n    const documentTypes = schema\n      .filter((t) => t.type === 'document' && !shouldSkipType(t.name))\n      .map((t) => t.name)\n      .sort()\n      .slice(0, 10)\n\n    return {\n      _error: true,\n      message: `Type \"${typeName}\" not found`,\n      availableTypes: documentTypes,\n    }\n  }\n\n  const targetNode = path ? filterToPath(type, path, schema) : type\n\n  if (path) {\n    if (targetNode.type === 'notfound') {\n      return {\n        _error: true,\n        message: `Path \"${path}\" not found in type \"${typeName}\"`,\n        type: typeName,\n        path,\n      }\n    }\n\n    const originalHadFields = type.fields && type.fields.length > 0\n    const resultHasFields = targetNode.fields && targetNode.fields.length > 0\n    const resultHasOf = targetNode.of && targetNode.of.length > 0\n    const resultIsDifferent = targetNode !== type\n\n    const hasJustTypeProperty = targetNode.type && Object.keys(targetNode).length <= 2\n    const hasPropertyContent = resultIsDifferent && Object.keys(targetNode).length > 2\n    const resultHasContent =\n      resultHasFields ||\n      resultHasOf ||\n      targetNode.validation ||\n      targetNode.options ||\n      targetNode.to ||\n      (resultIsDifferent && hasJustTypeProperty) ||\n      hasPropertyContent\n\n    const pathNotFound =\n      (resultIsDifferent && !resultHasContent) ||\n      (!resultIsDifferent && originalHadFields && !resultHasFields && !resultHasOf)\n\n    if (pathNotFound) {\n      return {\n        _error: true,\n        message: `Path \"${path}\" not found in type \"${typeName}\"`,\n        type: typeName,\n        path,\n      }\n    }\n  }\n\n  const rawSubtree = extractRawSubtree(targetNode)\n\n  const jsonString = JSON.stringify(rawSubtree, null, 2)\n  const sizeInBytes = new TextEncoder().encode(jsonString).length\n\n  if (sizeInBytes <= sizeThreshold) {\n    return rawSubtree\n  }\n\n  return generateLargeNodeNavigator(targetNode, path, typeName)\n}\n\nfunction extractRawSubtree(node: ManifestSchemaType): Record<string, unknown> {\n  const cleaned = JSON.parse(JSON.stringify(node))\n\n  if (cleaned.fields && Array.isArray(cleaned.fields)) {\n    cleaned.fields = cleaned.fields.filter((field: ManifestField) => !shouldSkipType(field.name))\n  }\n\n  return cleaned\n}\n\nfunction generateLargeNodeNavigator(\n  node: ManifestSchemaType,\n  currentPath: string | undefined,\n  rootTypeName: string,\n): LargeNodeNavigator {\n  const children: Array<{ type: string; path: string }> = []\n\n  if ((node.type === 'array' || node.of) && Array.isArray(node.of) && node.of.length > 0) {\n    node.of.forEach((item: Record<string, unknown>, index: number) => {\n      const itemType =\n        item.name ||\n        item.title ||\n        (item.type && item.type !== 'object' ? item.type : null) ||\n        item.type ||\n        'unknown'\n\n      children.push({\n        type: String(itemType),\n        path: currentPath ? `${currentPath}.of[${index}]` : `of[${index}]`,\n      })\n    })\n  } else if (node.fields && Array.isArray(node.fields)) {\n    node.fields.forEach((field: ManifestField) => {\n      if (shouldSkipType(field.name)) return\n\n      const childPath = currentPath ? `${currentPath}.${field.name}` : field.name\n\n      if (field.type === 'array' && field.of && Array.isArray(field.of)) {\n        const arrayPath = `${childPath}[]`\n\n        field.of.forEach((item: Record<string, unknown>) => {\n          if (item.name || item.type) {\n            const itemType = String(item.name || item.type)\n            if (!isPrimitiveType(itemType, { includeBlockTypes: true })) {\n              children.push({ type: itemType, path: `${arrayPath}.${itemType}` })\n            }\n          }\n        })\n\n        if (field.of.length > 0) {\n          children.push({ type: 'array', path: arrayPath })\n        }\n      } else if (field.type === 'object' || field.fields) {\n        children.push({ type: field.type || 'object', path: childPath })\n      } else if (field.type && !isPrimitiveType(field.type, { includeBlockTypes: true })) {\n        children.push({ type: field.type, path: childPath })\n      }\n    })\n  } else if (isGenericObject(node)) {\n    const nodeObj = node as Record<string, unknown>\n    const skipKeys = new Set(['type', 'name', '_type', '_key'])\n\n    for (const key of Object.keys(nodeObj)) {\n      if (skipKeys.has(key)) continue\n\n      const value = nodeObj[key]\n      const childPath = currentPath ? `${currentPath}.${key}` : key\n\n      let propertyType = 'unknown'\n      if (Array.isArray(value)) propertyType = 'array'\n      else if (typeof value === 'object' && value !== null) propertyType = 'object'\n      else propertyType = typeof value\n\n      children.push({ type: propertyType, path: childPath })\n    }\n  }\n\n  return {\n    _rawLargeNode: true,\n    name: currentPath || rootTypeName,\n    type: node.type || 'object',\n    children,\n    hint: 'This node is large. Fetch a specific child path to drill in.',\n  }\n}\n","import { z } from 'zod'\n\n// =============================================================================\n// Schema Descriptor Types (Lexicon API response)\n// =============================================================================\n\ntype ManifestSerializable =\n  | string\n  | number\n  | boolean\n  | { [k: string]: ManifestSerializable }\n  | ManifestSerializable[]\n\nexport type ManifestSchemaType = {\n  type: string\n  name: string\n  title?: string\n  description?: string\n  deprecated?: { reason: string }\n  readOnly?: boolean | 'conditional'\n  hidden?: boolean | 'conditional'\n  validation?: ManifestValidationGroup[]\n  fields?: ManifestField[]\n  to?: ManifestReferenceMember[]\n  of?: ManifestArrayMember[]\n  preview?: { select: Record<string, string> }\n  fieldsets?: ManifestFieldset[]\n  options?: Record<string, ManifestSerializable>\n  // Portable text\n  marks?: {\n    annotations?: ManifestArrayMember[]\n    decorators?: ManifestTitledValue[]\n  }\n  lists?: ManifestTitledValue[]\n  styles?: ManifestTitledValue[]\n  // Userland (assignable to ManifestSerializable | undefined)\n  [index: string]: unknown\n}\n\ntype ManifestFieldset = {\n  name: string\n  title?: string\n  [index: string]: ManifestSerializable | undefined\n}\n\ntype ManifestTitledValue = {\n  value: string\n  title?: string\n}\n\nexport type ManifestField = ManifestSchemaType & { fieldset?: string }\n\ntype ManifestArrayMember = Omit<ManifestSchemaType, 'name'> & { name?: string }\n\ntype ManifestReferenceMember = Omit<ManifestSchemaType, 'name'> & { name?: string }\n\ntype ManifestValidationGroup = {\n  rules: ManifestValidationRule[]\n  message?: string\n  level?: 'error' | 'warning' | 'info'\n}\n\ntype ManifestValidationRule = {\n  flag: 'presence' | string\n  constraint?: 'required' | ManifestSerializable\n  [index: string]: ManifestSerializable | undefined\n}\n\n// =============================================================================\n// Lexicon Descriptor Types (raw API response before conversion)\n// =============================================================================\n\nexport type HoistedEntry = {\n  name: string\n  typeDef: TypeDef\n  groups?: unknown\n  fieldset?: unknown\n}\n\nexport type HoistedMarker = {\n  __type: 'hoisted'\n  key: string\n}\n\nexport type InlineOrHoisted = { name: string; typeDef: TypeDef } | HoistedMarker\n\nexport type LexiconResponse = {\n  types: Record<string, TypeDef>\n  hoisted: Record<string, HoistedEntry>\n  registries?: string[]\n}\n\nexport type TypeDef = {\n  extends: string\n  fields?: InlineOrHoisted[]\n  to?: Array<{ name: string }>\n  of?: InlineOrHoisted[]\n  fieldsets?: string[]\n  validation?: unknown\n  [key: string]: unknown\n}\n\n// =============================================================================\n// Dataset Stats Types\n// =============================================================================\n\nconst InOutCountsSchema = z.object({\n  incoming: z.record(z.union([z.number(), z.literal('unknown')])),\n  outgoing: z.record(z.union([z.number(), z.literal('unknown')])),\n})\n\nexport const DatasetStatsSchema = z.object({\n  documentCount: z.record(z.number()).optional(),\n  referenceCount: z.record(InOutCountsSchema).optional(),\n})\n\nexport type DatasetStats = z.infer<typeof DatasetStatsSchema>\nexport type InOutCounts = z.infer<typeof InOutCountsSchema>\n\n// =============================================================================\n// Schema Processing Types\n// =============================================================================\n\nexport type SchemaField = ManifestField\n\nexport type ReferenceInfo = {\n  type: string\n  path: string\n}\n\nexport type ProcessedDocumentType = {\n  name: string\n  title?: string\n  description?: string\n  deprecated?: { reason: string }\n  liveEdit?: boolean\n  titleField: string\n  fields: ManifestField[]\n  outgoingReferences: string[]\n  incomingReferences: string[]\n  outgoingReferencePaths?: ReferenceInfo[]\n  incomingReferencePaths?: ReferenceInfo[]\n}\n\nexport type SchemaTypes = {\n  documentTypes: Map<string, ProcessedDocumentType>\n  objectTypes: Map<string, ManifestSchemaType>\n}\n\n// =============================================================================\n// Options\n// =============================================================================\n\n/**\n * Filter document types by GROQ expressions or an explicit list.\n * - `{ read?, write? }` — GROQ boolean expressions (requires groq-js peer dep).\n *   Types matching either expression are included (union).\n * - `string[]` — explicit list of document type names to include.\n * - `undefined` / empty — include all document types.\n */\nexport type SchemaFilter = { read?: string; write?: string } | string[]\n\nexport type SchemaFieldDisplayOptions = {\n  showAll?: boolean\n  maxCount?: number\n  includeDescription?: boolean\n  includeHidden?: boolean\n  includeDeprecated?: boolean\n  maxEnumValues?: number\n  maxDescriptionLength?: number\n}\n\nexport type CompressedSchemaOptions = {\n  datasetStats?: DatasetStats\n  filter?: SchemaFilter\n  fields?: SchemaFieldDisplayOptions\n}\n\nexport type SchemaProcessorOptions = {\n  filter?: SchemaFilter\n  fields?: SchemaFieldDisplayOptions\n}\n","import type { ExprNode } from 'groq-js'\n\nimport type { ManifestSchemaType, SchemaFilter } from './types.js'\n\ntype GroqFilter = { read?: string; write?: string }\n\n/**\n * Resolves a `SchemaFilter` into a string array of document type names.\n * - `string[]` is returned as-is\n * - `{ read?, write? }` GROQ expressions are evaluated against the schema\n * - `undefined` returns `undefined` (no filtering)\n *\n * An empty result means \"include everything\".\n */\nexport async function resolveFilter(\n  schema: ManifestSchemaType[],\n  filter: SchemaFilter | undefined,\n): Promise<string[] | undefined> {\n  if (!filter) return undefined\n  if (Array.isArray(filter)) return filter.length > 0 ? filter : undefined\n  const result = await getFilteredDocumentTypes(schema, filter)\n  return result.length > 0 ? result : undefined\n}\n\n/**\n * Extracts document type names to include based on read/write GROQ filter expressions.\n * Returns the union of types allowed by either filter.\n *\n * Returns an empty array when no filtering is needed (no filter, or filter matches all types).\n * Consumers should treat an empty result as \"include everything\".\n */\nexport async function getFilteredDocumentTypes(\n  schema: ManifestSchemaType[],\n  filter: GroqFilter | undefined,\n): Promise<string[]> {\n  if (!filter || (!filter.read && !filter.write)) return []\n\n  const allDocTypes = schema.filter((s) => s.type === 'document').map((s) => s.name)\n  if (allDocTypes.length === 0) return []\n\n  const combined = new Set<string>()\n\n  if (filter.read) {\n    for (const type of await filterTypesByExpression(filter.read, allDocTypes)) {\n      combined.add(type)\n    }\n  }\n\n  if (filter.write) {\n    for (const type of await filterTypesByExpression(filter.write, allDocTypes)) {\n      combined.add(type)\n    }\n  }\n\n  // If the union covers all types, no filtering is needed\n  if (combined.size === allDocTypes.length) return []\n\n  return Array.from(combined)\n}\n\n/**\n * Filters document type names by evaluating a GROQ boolean expression.\n * Best-effort: returns all types when inference is not possible.\n *\n * Supports `_type == \"x\"`, `_type != \"x\"`, `_type in [...]`,\n * and boolean combinations (&&, ||, !).\n */\nexport async function filterTypesByExpression(\n  filterExpr: string | undefined,\n  allTypes: string[],\n): Promise<Set<string>> {\n  if (!filterExpr?.trim() || allTypes.length === 0) {\n    return new Set(allTypes)\n  }\n\n  try {\n    const { parse } = await import('groq-js')\n    const ast = parse(filterExpr)\n    const matching = allTypes.filter((type) => evaluateForType(ast, type) !== false)\n    return matching.length > 0 ? new Set(matching) : new Set(allTypes)\n  } catch {\n    return new Set(allTypes)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// AST evaluation — uses `unknown` accessors to avoid coupling to groq-js internals\n// ---------------------------------------------------------------------------\n\ntype Node = ExprNode | Record<string, unknown>\n\nfunction prop(node: Node, key: string): unknown {\n  return (node as Record<string, unknown>)[key]\n}\n\nfunction child(node: Node, key: string): Node {\n  return prop(node, key) as Node\n}\n\nfunction evaluateForType(node: Node, type: string): boolean | null {\n  if (!node || typeof node !== 'object') return null\n  const kind = (node as { type?: string }).type\n\n  switch (kind) {\n    case 'OpCall':\n      return evaluateOpCall(node, type)\n\n    case 'And': {\n      const left = evaluateForType(child(node, 'left'), type)\n      const right = evaluateForType(child(node, 'right'), type)\n      if (left === false || right === false) return false\n      if (left === true && right === true) return true\n      return null\n    }\n\n    case 'Or': {\n      const left = evaluateForType(child(node, 'left'), type)\n      const right = evaluateForType(child(node, 'right'), type)\n      if (left === true || right === true) return true\n      if (left === false && right === false) return false\n      return null\n    }\n\n    case 'Not': {\n      const inner = evaluateForType(child(node, 'base'), type)\n      return inner === null ? null : !inner\n    }\n\n    case 'Group':\n      return evaluateForType(child(node, 'base'), type)\n\n    default:\n      return null\n  }\n}\n\nfunction evaluateOpCall(node: Node, type: string): boolean | null {\n  const op = prop(node, 'op') as string\n  const left = child(node, 'left')\n  const right = child(node, 'right')\n\n  if (!isTypeAttribute(left)) return null\n\n  const rightType = (right as { type?: string }).type\n\n  if (op === '==' && rightType === 'Value') {\n    const val = prop(right, 'value')\n    return typeof val === 'string' ? type === val : null\n  }\n\n  if (op === '!=' && rightType === 'Value') {\n    const val = prop(right, 'value')\n    return typeof val === 'string' ? type !== val : null\n  }\n\n  if (op === 'in' && rightType === 'Array') {\n    const values = extractStringValues(right)\n    return values ? values.includes(type) : null\n  }\n\n  return null\n}\n\nfunction isTypeAttribute(node: Node): boolean {\n  return (node as { type?: string })?.type === 'AccessAttribute' && prop(node, 'name') === '_type'\n}\n\nfunction extractStringValues(arrayNode: Node): string[] | null {\n  const elements = prop(arrayNode, 'elements') as\n    | Array<{ type: string; value?: Node; isSplat?: boolean }>\n    | undefined\n  if (!elements) return null\n  const values: string[] = []\n  for (const el of elements) {\n    if (el.type !== 'ArrayElement' || el.isSplat) return null\n    const val = el.value as Node | undefined\n    if ((val as { type?: string })?.type !== 'Value') return null\n    const v = prop(val!, 'value')\n    if (typeof v !== 'string') return null\n    values.push(v)\n  }\n  return values\n}\n","import { SCHEMA_CONSTANTS } from './constants.js'\nimport type { SchemaField, SchemaFieldDisplayOptions } from './types.js'\n\nconst SIMPLE_TYPE_MAP: Record<string, string> = {\n  document: 'object',\n  crossDatasetReference: 'reference',\n}\n\nconst KNOWN_TYPES = new Set([\n  'string',\n  'text',\n  'number',\n  'boolean',\n  'date',\n  'datetime',\n  'image',\n  'file',\n  'array',\n  'object',\n  'reference',\n  'block',\n  'slug',\n  'geopoint',\n  'span',\n  'url',\n  'email',\n  'color',\n])\n\nfunction getSimpleFieldType(field: SchemaField): string {\n  return SIMPLE_TYPE_MAP[field.type] ?? (KNOWN_TYPES.has(field.type) ? field.type : 'object')\n}\n\nfunction normalize(s: string): string {\n  return s.toLowerCase().replace(/[^a-z0-9]/g, '')\n}\n\nfunction getEnumValues(field: SchemaField): string[] | null {\n  const list = (field.options as Record<string, unknown> | undefined)?.list\n  if (!Array.isArray(list) || list.length === 0) return null\n  return list\n    .map((item: unknown) =>\n      typeof item === 'string' ? item : (item as Record<string, string>).value,\n    )\n    .filter(Boolean)\n}\n\nfunction formatTypeString(field: SchemaField, maxEnumValues: number): string {\n  const enumValues = getEnumValues(field)\n  if (!enumValues) return getSimpleFieldType(field)\n\n  const shown = enumValues.slice(0, maxEnumValues)\n  const overflow = enumValues.length - maxEnumValues\n  return shown.join('|') + (overflow > 0 ? `|...${overflow} more` : '')\n}\n\nfunction formatDescription(\n  field: SchemaField,\n  includeDescription: boolean,\n  maxLen: number,\n): string {\n  if (!includeDescription || !field.title) return ''\n  if (normalize(field.title) === normalize(field.name)) return ''\n  const desc = field.title.length > maxLen ? `${field.title.slice(0, maxLen)}...` : field.title\n  return `: ${desc}`\n}\n\nexport function formatFieldNamesWithTypes(\n  fields: SchemaField[],\n  options?: SchemaFieldDisplayOptions,\n): string {\n  const {\n    showAll,\n    maxCount,\n    includeDescription = false,\n    includeHidden = false,\n    includeDeprecated = false,\n    maxEnumValues = SCHEMA_CONSTANTS.DEFAULTS.maxEnumValues,\n    maxDescriptionLength = SCHEMA_CONSTANTS.DEFAULTS.maxDescriptionLength,\n  } = options ?? {}\n\n  const filtered = fields.filter((f) => {\n    if (!includeDeprecated && f.deprecated) return false\n    if (!includeHidden && f.hidden) return false\n    return true\n  })\n\n  const limit = showAll\n    ? filtered.length\n    : (maxCount ?? SCHEMA_CONSTANTS.DEFAULTS.maxFieldsInSummary)\n\n  return filtered\n    .slice(0, limit)\n    .map((f) => {\n      const typeStr = formatTypeString(f, maxEnumValues)\n      const desc = formatDescription(f, includeDescription, maxDescriptionLength)\n      return `${f.name}<${typeStr}>${desc}`\n    })\n    .join(', ')\n}\n","import { SCHEMA_CONSTANTS } from './constants.js'\nimport { formatFieldNamesWithTypes } from './formatFields.js'\nimport type {\n  DatasetStats,\n  ManifestSchemaType,\n  ProcessedDocumentType,\n  SchemaField,\n  SchemaFieldDisplayOptions,\n} from './types.js'\nimport { shouldSkipType } from './utils.js'\n\nfunction formatReferenceCount(count: number | 'unknown'): string {\n  return typeof count === 'number' && count > 0 ? `×${count}` : ''\n}\n\nfunction formatDocumentCount(count: number | undefined, hasDocumentCounts: boolean): string {\n  return hasDocumentCounts ? String(count ?? 0) : 'unknown'\n}\n\nfunction calculateMaxDepth(\n  fields: SchemaField[],\n  objectTypes: Map<string, ManifestSchemaType>,\n  currentDepth: number = 1,\n  visited: Set<string> = new Set(),\n): number {\n  let max = currentDepth\n\n  for (const field of fields) {\n    if (field.fields?.length) {\n      max = Math.max(max, calculateMaxDepth(field.fields, objectTypes, currentDepth + 1, visited))\n    }\n\n    const checkObjectType = (typeName: string | undefined) => {\n      if (!typeName || visited.has(typeName)) return\n      const obj = objectTypes.get(typeName)\n      if (!obj?.fields?.length) return\n      visited.add(typeName)\n      max = Math.max(max, calculateMaxDepth(obj.fields, objectTypes, currentDepth + 1, visited))\n    }\n\n    checkObjectType(field.type)\n\n    if (Array.isArray(field.of)) {\n      for (const item of field.of) {\n        checkObjectType((item as Record<string, unknown>)?.type as string | undefined)\n      }\n    }\n  }\n\n  return max\n}\n\ntype RefInfo = { outgoing: string; incoming: string }\n\nfunction formatRefsWithCounts(\n  doc: ProcessedDocumentType,\n  referenceCount: DatasetStats['referenceCount'],\n): RefInfo {\n  const counts = referenceCount ?? {}\n\n  const outgoing =\n    [...(doc.outgoingReferencePaths ?? [])]\n      .sort((a, b) => `${a.path}->${a.type}`.localeCompare(`${b.path}->${b.type}`))\n      .map((r) => {\n        const pathKey = `${r.path}->${r.type}`\n        const refCount = counts[doc.name]?.outgoing?.[pathKey]\n        if (typeof refCount !== 'number' || refCount <= 0) return null\n        return `${pathKey}${formatReferenceCount(refCount)}`\n      })\n      .filter(Boolean)\n      .join(', ') || ''\n\n  if (doc.incomingReferences.length === 0) return { outgoing, incoming: '' }\n\n  const incomingParts: string[] = []\n  for (const sourceType of [...doc.incomingReferences].sort()) {\n    const sourceCounts = counts[sourceType]\n    let total = 0\n    if (sourceCounts?.outgoing) {\n      const suffix = `->${doc.name}`\n      for (const [pathKey, pathCount] of Object.entries(sourceCounts.outgoing)) {\n        if (pathKey.endsWith(suffix) && typeof pathCount === 'number' && pathCount > 0) {\n          total += pathCount\n        }\n      }\n    }\n    if (total > 0) incomingParts.push(`${sourceType}${formatReferenceCount(total)}`)\n  }\n\n  return { outgoing, incoming: incomingParts.join(', ') }\n}\n\nfunction formatRefsSimple(doc: ProcessedDocumentType): RefInfo {\n  return {\n    outgoing:\n      doc.outgoingReferences.length > 0 ? [...doc.outgoingReferences].sort().join(', ') : '',\n    incoming:\n      doc.incomingReferences.length > 0 ? [...doc.incomingReferences].sort().join(', ') : '',\n  }\n}\n\nfunction formatDocEntry(\n  name: string,\n  doc: ProcessedDocumentType,\n  objectTypes: Map<string, ManifestSchemaType>,\n  fieldOptions: SchemaFieldDisplayOptions,\n  datasetStats?: DatasetStats,\n): string | null {\n  if (shouldSkipType(name)) return null\n\n  const { documentCount, referenceCount } = datasetStats ?? {}\n  const hasDocumentCounts = !!documentCount\n  const count = documentCount?.[name] ?? 0\n\n  // Skip types with zero documents when we have counts\n  if (documentCount && documentCount[name] === 0) return null\n\n  const useCount = formatDocumentCount(count, hasDocumentCounts)\n\n  // Deprecated types get a condensed single-line entry\n  if (doc.deprecated) {\n    return `- ${name} (DEPRECATED: \"${doc.deprecated.reason}\", count: ${useCount})`\n  }\n\n  const refs = referenceCount ? formatRefsWithCounts(doc, referenceCount) : formatRefsSimple(doc)\n\n  const depth = calculateMaxDepth(doc.fields, objectTypes)\n  const fieldNames = formatFieldNamesWithTypes(doc.fields, fieldOptions)\n  const indent = '  '\n\n  const liveEditFlag = doc.liveEdit ? 'liveEdit, ' : ''\n  const parts = [\n    `- ${name} (${liveEditFlag}title: ${doc.titleField}, depth: ${depth}, count: ${useCount})`,\n  ]\n\n  if (doc.description) {\n    const maxLen = SCHEMA_CONSTANTS.DEFAULTS.maxDocDescriptionLength\n    const desc =\n      doc.description.length > maxLen ? `${doc.description.slice(0, maxLen)}...` : doc.description\n    parts.push(`${indent}- description: ${desc}`)\n  }\n\n  parts.push(`${indent}- fields: ${fieldNames}`)\n\n  if (refs.outgoing) parts.push(`${indent}- references: ${refs.outgoing}`)\n  if (refs.incoming) parts.push(`${indent}- referenced by: ${refs.incoming}`)\n\n  return parts.join('\\n')\n}\n\n/**\n * Generates a compressed text representation of processed schema types.\n * Document types are sorted alphabetically, filtered by dataset stats,\n * and formatted with field summaries and reference information.\n */\nexport function formatCompressedSchema(\n  documentTypes: Map<string, ProcessedDocumentType>,\n  objectTypes: Map<string, ManifestSchemaType>,\n  fieldOptions: SchemaFieldDisplayOptions,\n  datasetStats?: DatasetStats,\n): string {\n  return [...documentTypes.entries()]\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([name, doc]) => formatDocEntry(name, doc, objectTypes, fieldOptions, datasetStats))\n    .filter(Boolean)\n    .join('\\n')\n}\n","// ---------------------------------------------------------------------------\n// Fetch\n// ---------------------------------------------------------------------------\n\nexport { fetchDatasetStats } from './fetchDatasetStats.js'\nexport {\n  type FetchSchemaOptions,\n  fetchSchemaByDescriptorId,\n  type SchemaCache,\n} from './fetchSchemaByDescriptorId.js'\n\n// ---------------------------------------------------------------------------\n// Process\n// ---------------------------------------------------------------------------\n\nexport { processSchema } from './processSchema.js'\n\n// ---------------------------------------------------------------------------\n// Navigate\n// ---------------------------------------------------------------------------\n\nexport {\n  ARRAY_ITEM_SYSTEM_FIELDS,\n  BUILT_IN_TYPE_FIELDS,\n  DEFAULT_LINK_ANNOTATION,\n} from './navigate/constants.js'\nexport { filterToPath } from './navigate/filterToPath.js'\nexport {\n  resolveFieldSchemaAllUnions,\n  resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions,\n} from './navigate/navigateAllUnions.js'\n// Deprecated aliases — remove in next minor\nexport {\n  resolveFieldSchema,\n  resolveFieldSchema as navigateToFieldSchema,\n} from './navigate/navigateToField.js'\nexport { toSchemaPath } from './navigate/path.js'\nexport { isBuiltInType, isGenericObject, isPrimitiveType } from './navigate/types.js'\n\n// ---------------------------------------------------------------------------\n// Format\n// ---------------------------------------------------------------------------\n\nexport { type FullSchemaOptions, fullSchema } from './fullSchema.js'\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type {\n  CompressedSchemaOptions,\n  DatasetStats,\n  ManifestField,\n  ManifestSchemaType,\n  ProcessedDocumentType,\n  SchemaFieldDisplayOptions,\n  SchemaFilter,\n  SchemaTypes,\n} from './types.js'\nexport { DatasetStatsSchema } from './types.js'\n\n// ---------------------------------------------------------------------------\n// Utilities\n// ---------------------------------------------------------------------------\n\nexport { SCHEMA_CONSTANTS } from './constants.js'\nexport { shouldSkipType } from './utils.js'\n\n// ---------------------------------------------------------------------------\n// Convenience\n// ---------------------------------------------------------------------------\n\nimport { resolveFilter } from './filterDocumentTypes.js'\nimport { formatCompressedSchema } from './formatSchema.js'\nimport { processSchema } from './processSchema.js'\nimport type { CompressedSchemaOptions, ManifestSchemaType } from './types.js'\n\n/**\n * Generates a compressed text representation of a schema for agent consumption.\n *\n * Takes parsed schema types and returns compact text summarizing document types,\n * fields, references, and optionally document/reference counts.\n *\n * The `filter` option accepts either a GROQ filter `{ read?, write? }` or\n * a pre-resolved `string[]` of document type names.\n */\nexport async function compressedSchema(\n  types: ManifestSchemaType[],\n  options: CompressedSchemaOptions = {},\n): Promise<string> {\n  const includeTypes = await resolveFilter(types, options.filter)\n\n  const { documentTypes, objectTypes } = processSchema(types, {\n    filter: includeTypes,\n    fields: options.fields,\n  })\n\n  return formatCompressedSchema(\n    documentTypes,\n    objectTypes,\n    options.fields ?? {},\n    options.datasetStats,\n  )\n}\n"],"names":["result","referencedSchema","processSchema"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/agent-schema",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Schema processing utilities for Sanity Agent",
   "keywords": [
     "sanity",
@@ -31,14 +31,6 @@
     "@sanity/client": ">=7.0.0",
     "groq-js": ">=1.0.0"
   },
-  "peerDependenciesMeta": {
-    "@sanity/client": {
-      "optional": true
-    },
-    "groq-js": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@sanity/client": "7.14.1",
     "@sanity/pkg-utils": "^10.4.1",