canopycms 0.0.67-int.90 → 0.0.67

package/dist/editor/schema-editor/EntryTypeEditor.js

@@ -3,34 +3,23 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * EntryTypeEditor - Modal for creating/editing entry types within a collection.
  *
- * Entry types define the structure of content items:
- * - name: Machine-readable identifier (e.g., "post", "page")
- * - label: Human-readable display name
- * - format: Content format (md, mdx, json, yaml)
- * - fields: Schema registry key for field definitions
- * - default: Whether this is the default type for new items
- * - maxItems: Optional limit on number of items (1 = singleton-like)
+ * An entry type has a name (machine-readable id), label, format (md/mdx/json/
+ * yaml), schema (registry key for field definitions), a default flag, and an
+ * optional maxItems limit (1 behaves like a singleton).
  */
 import { useState, useCallback, useEffect } from 'react';
 import { Modal, Stack, TextInput, Select, Switch, NumberInput, Group, Button, Text, Alert, Tooltip, } from '@mantine/core';
 import { IconAlertCircle, IconLock } from '@tabler/icons-react';
-// ============================================================================
-// Constants
-// ============================================================================
 const FORMAT_OPTIONS = [
     { value: 'json', label: 'JSON' },
     { value: 'yaml', label: 'YAML' },
     { value: 'md', label: 'Markdown' },
     { value: 'mdx', label: 'MDX' },
 ];
-// ============================================================================
-// Component
-// ============================================================================
 export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, existingEntryTypeNames = [], onSave, onClose, isSaving = false, error = null, }) {
     const isEditMode = editingEntryType !== null;
     const usageCount = editingEntryType?.usageCount ?? 0;
     const isLocked = isEditMode && usageCount > 0;
-    // Form state
     const [formData, setFormData] = useState({
         name: '',
         label: '',
@@ -39,9 +28,7 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
         default: false,
         maxItems: undefined,
     });
-    // Local validation error
     const [validationError, setValidationError] = useState(null);
-    // Reset form when modal opens or editing item changes
     /* eslint-disable react-hooks/set-state-in-effect -- intentional: sync form state from props on open */
     useEffect(() => {
         if (isOpen) {
@@ -69,12 +56,10 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
         }
     }, [isOpen, editingEntryType, availableSchemas]);
     /* eslint-enable react-hooks/set-state-in-effect */
-    // Update a form field
     const updateField = useCallback((field, value) => {
         setFormData((prev) => ({ ...prev, [field]: value }));
         setValidationError(null);
     }, []);
-    // Validate form
     const validate = useCallback(() => {
         if (!isEditMode && !formData.name.trim()) {
             setValidationError('Name is required');
@@ -88,7 +73,6 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
             setValidationError('Name must be 64 characters or less');
             return false;
         }
-        // Check for duplicate names (only in create mode)
         if (!isEditMode && existingEntryTypeNames.includes(formData.name.trim())) {
             setValidationError('Entry type with this name already exists in this collection');
             return false;
@@ -99,12 +83,10 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
         }
         return true;
     }, [formData, isEditMode, existingEntryTypeNames]);
-    // Handle save
     const handleSave = useCallback(() => {
         if (!validate())
             return;
         if (isEditMode) {
-            // Only include changed fields for update
             const updates = {};
             if (formData.label !== (editingEntryType?.label || '')) {
                 updates.label = formData.label || undefined;
@@ -124,7 +106,6 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
             onSave(updates, false);
         }
         else {
-            // Create new entry type
             const createData = {
                 name: formData.name.trim(),
                 format: formData.format,
@@ -142,7 +123,6 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
             onSave(createData, true);
         }
     }, [formData, isEditMode, editingEntryType, validate, onSave]);
-    // Schema options for select
     const schemaOptions = availableSchemas.map((key) => ({
         value: key,
         label: key,
@@ -158,4 +138,3 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
                             ? `Locked (${usageCount} ${usageCount === 1 ? 'entry' : 'entries'} exist)`
                             : 'Field definitions for this entry type', data: schemaOptions, value: formData.schema, onChange: (value) => value && updateField('schema', value), searchable: true, required: true, placeholder: "Select a schema", disabled: isLocked, rightSection: isLocked ? _jsx(IconLock, { size: 14 }) : undefined }) }), _jsx(Switch, { label: "Default entry type", description: "Use this type when adding new items to the collection", checked: formData.default, onChange: (e) => updateField('default', e.currentTarget.checked) }), _jsx(NumberInput, { label: "Max Items", description: "Limit number of items (leave empty for unlimited, use 1 for singleton-like behavior)", placeholder: "Unlimited", value: formData.maxItems ?? '', onChange: (value) => updateField('maxItems', typeof value === 'number' ? value : undefined), min: 1, allowNegative: false, allowDecimal: false }), formData.maxItems === 1 && (_jsx(Text, { size: "xs", c: "dimmed", children: "With maxItems=1, this entry type behaves like a singleton (e.g., homepage, settings)" })), _jsxs(Group, { justify: "flex-end", gap: "sm", mt: "md", children: [_jsx(Button, { variant: "subtle", onClick: onClose, disabled: isSaving, children: "Cancel" }), _jsx(Button, { onClick: handleSave, loading: isSaving, children: isEditMode ? 'Save Changes' : 'Add Entry Type' })] })] }) }));
 }
-export default EntryTypeEditor;

package/dist/editor/schema-editor/index.d.ts

@@ -1,9 +1,2 @@
-/**
- * Schema Editor Components
- *
- * UI components for managing collection structure:
- * - CollectionEditor: Create/edit collections and their entry types
- * - EntryTypeEditor: Create/edit individual entry types
- */
 export { CollectionEditor, type CollectionEditorProps, type ExistingCollection, type ExistingEntryType, } from './CollectionEditor.js';
 export { EntryTypeEditor, type EntryTypeEditorProps, type EntryTypeFormData, } from './EntryTypeEditor.js';

package/dist/editor/schema-editor/index.js

@@ -1,9 +1,2 @@
-/**
- * Schema Editor Components
- *
- * UI components for managing collection structure:
- * - CollectionEditor: Create/edit collections and their entry types
- * - EntryTypeEditor: Create/edit individual entry types
- */
 export { CollectionEditor, } from './CollectionEditor.js';
 export { EntryTypeEditor, } from './EntryTypeEditor.js';

package/dist/editor/utils/env.d.ts

@@ -1,22 +1,7 @@
 /**
- * Detect if we're running in a test environment.
- * Playwright and other E2E frameworks often set specific globals.
- */
-export declare function isTestEnvironment(): boolean;
-/**
- * Get notification duration based on environment.
- * Tests get longer durations to be more reliable.
- *
- * @param defaultMs - Default duration in milliseconds for production (default: 4000)
- * @returns Duration in milliseconds (15000ms for tests, defaultMs for production)
+ * Notification duration, longer in tests for reliability.
  *
- * @example
- * ```typescript
- * notifications.show({
- *   message: 'Saved',
- *   color: 'green',
- *   autoClose: getNotificationDuration(4000),  // 4s in production, 15s in tests
- * })
- * ```
+ * @param defaultMs - Default in milliseconds for production (default: 4000)
+ * @returns 15000ms in tests, defaultMs otherwise
  */
 export declare function getNotificationDuration(defaultMs?: number): number;

package/dist/editor/utils/env.js

@@ -1,36 +1,17 @@
-/**
- * Detect if we're running in a test environment.
- * Playwright and other E2E frameworks often set specific globals.
- */
-export function isTestEnvironment() {
+/** True when running in a test environment (Playwright, Cypress, or an E2E flag sets these globals). */
+function isTestEnvironment() {
     if (typeof window === 'undefined')
         return false;
-    // Check for common E2E testing indicators
-    return (
-    // Playwright sets window.playwright
-    'playwright' in window ||
-        // Cypress sets window.Cypress
+    return ('playwright' in window ||
         'Cypress' in window ||
-        // Check if running in test mode via env variable (set by test runner)
         window.__E2E_TEST__ === true ||
-        // Some test frameworks set navigator.webdriver
         navigator.webdriver === true);
 }
 /**
- * Get notification duration based on environment.
- * Tests get longer durations to be more reliable.
- *
- * @param defaultMs - Default duration in milliseconds for production (default: 4000)
- * @returns Duration in milliseconds (15000ms for tests, defaultMs for production)
+ * Notification duration, longer in tests for reliability.
  *
- * @example
- * ```typescript
- * notifications.show({
- *   message: 'Saved',
- *   color: 'green',
- *   autoClose: getNotificationDuration(4000),  // 4s in production, 15s in tests
- * })
- * ```
+ * @param defaultMs - Default in milliseconds for production (default: 4000)
+ * @returns 15000ms in tests, defaultMs otherwise
  */
 export function getNotificationDuration(defaultMs = 4000) {
     return isTestEnvironment() ? 15000 : defaultMs;

package/dist/entry-link-resolver.d.ts

@@ -1,24 +1,15 @@
 /**
- * Entry link resolution for body content.
+ * Entry link resolution for body content: `entry:CONTENT_ID` tokens in markdown/MDX
+ * text resolve to URL paths, extending the reference-by-ID pattern from structured
+ * reference fields to inline body links.
  *
- * Resolves `entry:CONTENT_ID` patterns in markdown/MDX body text to actual URL paths.
- * This extends the reference-by-ID pattern (already used for structured reference fields)
- * to inline links in content bodies.
- *
- * Syntax:
  *   [Link text](entry:vh2WdhwAFiSL)
  *   [Link text](entry:vh2WdhwAFiSL#section-heading)
  *
- * Resolution skips fenced code blocks and inline code spans to avoid
- * corrupting code examples.
+ * Fenced code blocks and inline code spans are skipped, so code examples are never
+ * rewritten.
  */
 import type { ContentIdIndex, IdLocation } from './content-id-index.js';
-/**
- * Base58 alphabet pattern (matches content IDs).
- * Excludes ambiguous characters: 0, O, I, l
- */
-/** Base58 alphabet character class (excludes ambiguous: 0, O, I, l). */
-export declare const BASE58_CHAR = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
 /**
  * Pattern matching `entry:CONTENT_ID` with optional anchor fragment.
  * Uses the `g` flag — safe to share when used only with `.replace()`.
@@ -30,36 +21,23 @@ export type EntryLinkUrlResolver = (entry: {
     slug: string;
     id: string;
 }) => string;
-/**
- * Compute a URL path from an entry's location in the content tree.
- * Delegates to the shared `computeEntryUrl` utility.
- */
+/** URL path for an entry's location in the content tree; delegates to `computeEntryUrl`. */
 export declare function resolveEntryUrl(location: Pick<IdLocation, 'collection' | 'slug'>, contentRoot: string): string;
 /**
- * Replace `entry:CONTENT_ID` patterns in text with resolved URL paths.
- *
- * Skips code blocks (fenced ``` and inline `code`) to avoid corrupting
- * code examples that mention the entry: syntax.
- *
- * Missing IDs are replaced with "#" (dead link) and logged as warnings.
- * Anchor fragments are preserved: entry:ID#heading => /path#heading
+ * Replace `entry:CONTENT_ID` tokens with resolved URL paths, skipping code blocks and
+ * spans so examples mentioning the syntax survive. A missing ID becomes "#" (dead link)
+ * plus a warning; an anchor fragment is preserved (`entry:ID#heading` => `/path#heading`).
  */
 export declare function resolveEntryLinksInText(text: string, idIndex: ContentIdIndex, contentRoot: string, customResolver?: EntryLinkUrlResolver): string;
 /** Quick-check pattern for early bail-out (no `g` flag, safe for `.test()`). */
 export declare const ENTRY_LINK_QUICK_CHECK: RegExp;
 /**
- * Recursively resolve entry:ID patterns in all string values of a data object.
- *
- * This handles nested objects, arrays, and mixed structures — important for
- * JSON entries where markdown fields live inside nested objects (e.g., hero.body).
- *
- * Returns the same object reference if nothing changed (structural sharing).
+ * Recursively resolve `entry:ID` tokens in every string of a data structure — nested
+ * objects and arrays included, since JSON entries keep markdown fields inside nested
+ * objects (e.g. hero.body). Returns the same reference when nothing changed.
  */
 export declare function resolveEntryLinksInData(data: unknown, idIndex: ContentIdIndex, contentRoot: string, customResolver?: EntryLinkUrlResolver): unknown;
-/**
- * Extract all entry link IDs from text (for validation, not resolution).
- * Returns IDs found in entry:ID patterns, skipping code blocks.
- */
+/** Every entry link ID in text, skipping code blocks — for validation, not resolution. */
 export declare function extractEntryLinkIds(text: string): Array<{
     id: string;
     anchor?: string;

package/dist/entry-link-resolver.js

@@ -1,49 +1,34 @@
 /**
- * Entry link resolution for body content.
+ * Entry link resolution for body content: `entry:CONTENT_ID` tokens in markdown/MDX
+ * text resolve to URL paths, extending the reference-by-ID pattern from structured
+ * reference fields to inline body links.
  *
- * Resolves `entry:CONTENT_ID` patterns in markdown/MDX body text to actual URL paths.
- * This extends the reference-by-ID pattern (already used for structured reference fields)
- * to inline links in content bodies.
- *
- * Syntax:
  *   [Link text](entry:vh2WdhwAFiSL)
  *   [Link text](entry:vh2WdhwAFiSL#section-heading)
  *
- * Resolution skips fenced code blocks and inline code spans to avoid
- * corrupting code examples.
+ * Fenced code blocks and inline code spans are skipped, so code examples are never
+ * rewritten.
  */
 import { createDebugLogger } from './utils/debug.js';
 import { computeEntryUrl } from './utils/entry-url.js';
 const log = createDebugLogger({ prefix: 'EntryLinks' });
-/**
- * Base58 alphabet pattern (matches content IDs).
- * Excludes ambiguous characters: 0, O, I, l
- */
 /** Base58 alphabet character class (excludes ambiguous: 0, O, I, l). */
-export const BASE58_CHAR = '[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]';
+const BASE58_CHAR = '[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]';
 /**
  * Pattern matching `entry:CONTENT_ID` with optional anchor fragment.
  * Uses the `g` flag — safe to share when used only with `.replace()`.
  */
 export const ENTRY_LINK_PATTERN = new RegExp(`entry:(${BASE58_CHAR}{12})(#[^\\s)>"']*)?`, 'g');
-/**
- * Compute a URL path from an entry's location in the content tree.
- * Delegates to the shared `computeEntryUrl` utility.
- */
+/** URL path for an entry's location in the content tree; delegates to `computeEntryUrl`. */
 export function resolveEntryUrl(location, contentRoot) {
     return computeEntryUrl(location.collection ?? '', location.slug ?? '', contentRoot);
 }
 /**
- * Replace `entry:CONTENT_ID` patterns in text with resolved URL paths.
- *
- * Skips code blocks (fenced ``` and inline `code`) to avoid corrupting
- * code examples that mention the entry: syntax.
- *
- * Missing IDs are replaced with "#" (dead link) and logged as warnings.
- * Anchor fragments are preserved: entry:ID#heading => /path#heading
+ * Replace `entry:CONTENT_ID` tokens with resolved URL paths, skipping code blocks and
+ * spans so examples mentioning the syntax survive. A missing ID becomes "#" (dead link)
+ * plus a warning; an anchor fragment is preserved (`entry:ID#heading` => `/path#heading`).
  */
 export function resolveEntryLinksInText(text, idIndex, contentRoot, customResolver) {
-    // Split text into protected regions (code blocks/spans) and resolvable regions
     const parts = splitByCodeRegions(text);
     return parts
         .map((part) => {
@@ -74,12 +59,9 @@ export function resolveEntryLinksInText(text, idIndex, contentRoot, customResolv
 /** Quick-check pattern for early bail-out (no `g` flag, safe for `.test()`). */
 export const ENTRY_LINK_QUICK_CHECK = /entry:[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{12}/;
 /**
- * Recursively resolve entry:ID patterns in all string values of a data object.
- *
- * This handles nested objects, arrays, and mixed structures — important for
- * JSON entries where markdown fields live inside nested objects (e.g., hero.body).
- *
- * Returns the same object reference if nothing changed (structural sharing).
+ * Recursively resolve `entry:ID` tokens in every string of a data structure — nested
+ * objects and arrays included, since JSON entries keep markdown fields inside nested
+ * objects (e.g. hero.body). Returns the same reference when nothing changed.
  */
 export function resolveEntryLinksInData(data, idIndex, contentRoot, customResolver) {
     if (typeof data === 'string') {
@@ -110,20 +92,16 @@ export function resolveEntryLinksInData(data, idIndex, contentRoot, customResolv
     }
     return data;
 }
-/**
- * Extract all entry link IDs from text (for validation, not resolution).
- * Returns IDs found in entry:ID patterns, skipping code blocks.
- */
+/** Every entry link ID in text, skipping code blocks — for validation, not resolution. */
 export function extractEntryLinkIds(text) {
     const parts = splitByCodeRegions(text);
     const results = [];
     for (const part of parts) {
         if (part.isCode)
             continue;
-        // Source is ENTRY_LINK_PATTERN.source, a fixed compile-time pattern (see
-        // line 33), not attacker-controlled input. A fresh instance is created per
-        // part so the stateful `lastIndex` from the shared `g`-flagged
-        // ENTRY_LINK_PATTERN isn't mutated by this exec() loop.
+        // `ENTRY_LINK_PATTERN.source` is a fixed compile-time pattern, not attacker-controlled
+        // input. A fresh instance per part keeps this exec() loop from mutating the shared
+        // `g`-flagged pattern's `lastIndex`.
         // eslint-disable-next-line security/detect-non-literal-regexp
         const regex = new RegExp(ENTRY_LINK_PATTERN.source, 'g');
         let match;
@@ -137,30 +115,23 @@ export function extractEntryLinkIds(text) {
     return results;
 }
 /**
- * Split text into alternating code/non-code regions.
- *
- * Handles:
- * - Fenced code blocks (``` or ~~~), including with language tags
- * - Inline code spans (`code` and ``code``)
- *
- * This ensures entry:ID inside code is never resolved.
+ * Split text into alternating code/non-code regions — fenced blocks (``` or ~~~, language
+ * tags included) and inline spans (`code`, ``code``) — so `entry:ID` inside code is never
+ * resolved.
  */
 function splitByCodeRegions(text) {
     const parts = [];
     let current = '';
     let i = 0;
     while (i < text.length) {
-        // Check for fenced code block (``` or ~~~)
         if ((text[i] === '`' || text[i] === '~') &&
             i + 2 < text.length &&
             text[i + 1] === text[i] &&
             text[i + 2] === text[i]) {
             const fence = text[i];
-            // Count fence length (could be ``` or ```` etc.)
             let fenceLen = 0;
             while (i + fenceLen < text.length && text[i + fenceLen] === fence)
                 fenceLen++;
-            // Find end of opening fence line
             const lineEnd = text.indexOf('\n', i + fenceLen);
             if (lineEnd === -1) {
                 // No newline — rest of text is code block
@@ -169,7 +140,6 @@ function splitByCodeRegions(text) {
                 parts.push({ text: text.slice(i), isCode: true });
                 return parts;
             }
-            // Find closing fence
             const closingPattern = fence.repeat(fenceLen);
             let closeStart = lineEnd + 1;
             let found = false;
@@ -199,13 +169,10 @@ function splitByCodeRegions(text) {
             }
             continue;
         }
-        // Check for inline code span (` or ``)
         if (text[i] === '`') {
-            // Count opening backticks
             let ticks = 0;
             while (i + ticks < text.length && text[i + ticks] === '`')
                 ticks++;
-            // Find matching closing backticks
             const closer = '`'.repeat(ticks);
             const closeIdx = text.indexOf(closer, i + ticks);
             if (closeIdx !== -1) {

package/dist/entry-schema-registry.d.ts

@@ -3,78 +3,38 @@ import type { EntrySchemaRegistry } from './schema/types.js';
 /**
  * Create a type-safe entry schema registry with runtime validation.
  *
- * The KEYS in the registry are the strings that `.collection.json` files (and
- * the editor wire format) use to look up each schema via the `entry.schema`
- * property. You can pick any string — but the **recommended convention is to
- * key by the entry-type name** (the filename token, the same string that
- * appears in `meta.entryType` in `buildContentTree` callbacks). When you do
- * that, `EntryTypesFromRegistry<typeof yourRegistry>` derives the
- * discriminated-union map for `buildContentTree`'s `TEntryTypes` parameter
- * automatically — no parallel interface to maintain.
+ * The KEYS are the strings `.collection.json` files (and the editor wire format)
+ * use to look up each schema via the `entry.schema` property. Any string works,
+ * but **key by the entry-type name** — the filename token, the same string
+ * `meta.entryType` carries in `buildContentTree` callbacks — because then
+ * `EntryTypesFromRegistry<typeof yourRegistry>` derives the discriminated-union
+ * map for `buildContentTree`'s `TEntryTypes` parameter with no parallel
+ * interface to maintain. Keyed any other way, the derived map is keyed by that
+ * string instead and will not plug into `TEntryTypes`.
+ *
+ * Rejected at call time: an empty registry; a schema that is not a non-empty
+ * `EntrySchema` array; more than one `isTitle` per schema, or one on a non-string
+ * field or inside a list; more than one `isBody`, or one on a field that is not
+ * markdown/mdx or is named one of `RESOLVED_REFERENCE_KEYS`. This is also the one
+ * place the shared field-shape checks run: select fields must have options,
+ * reference fields must have `collections` or `entryTypes`, no inline groups
+ * inside object/block fields, no field-name collisions after group flattening.
  *
  * @example
- * Recommended — keys are entry-type names:
  * ```typescript
- * import { createEntrySchemaRegistry } from 'canopycms/server'
- * import { type EntryTypesFromRegistry, defineEntrySchema } from 'canopycms'
- *
- * export const partnerSchema = defineEntrySchema([
- *   { name: 'name', type: 'string', label: 'Name', isTitle: true },
- *   { name: 'isFictional', type: 'boolean', label: 'Fictional?' },
- * ])
- * export const docSchema = defineEntrySchema([
- *   { name: 'title', type: 'string', label: 'Title' },
- * ])
- *
  * export const entrySchemaRegistry = createEntrySchemaRegistry({
- *   partner: partnerSchema,
+ *   partner: partnerSchema, // .collection.json: { "name": "partner", "schema": "partner" }
  *   doc: docSchema,
  * })
- *
- * // Then in .collection.json:
- * //   { "name": "partner", "format": "yaml", "schema": "partner" }
- *
- * // Derive entry-type map for typed narrowing:
  * export type EntryTypes = EntryTypesFromRegistry<typeof entrySchemaRegistry>
- *
- * // Per-schema aliases stay one line each, anchored to the registry:
  * export type PartnerContent = EntryTypes['partner']
  * ```
- *
- * @example
- * Also valid — keys are schema-variable names (prior convention):
- * ```typescript
- * export const entrySchemaRegistry = createEntrySchemaRegistry({
- *   partnerSchema,  // JS shorthand — key is the string "partnerSchema"
- *   docSchema,
- * })
- *
- * // .collection.json must then say:
- * //   { "name": "partner", "schema": "partnerSchema" }
- * //
- * // EntryTypesFromRegistry produces a map keyed by "partnerSchema" rather than
- * // by "partner", so it can't plug straight into buildContentTree's TEntryTypes.
- * // Either rekey the registry to the recommended convention, or declare the
- * // entry-type map manually using TypeFromEntrySchema<typeof partnerSchema>.
- * ```
- *
- * Runtime validation: registry must be non-empty, each schema must be a
- * non-empty `EntrySchema` array, at most one `isTitle` per schema (string
- * fields only), at most one `isBody` per schema (markdown/mdx only). Field-
- * shape checks: select fields must have options, reference fields must have
- * `collections` or `entryTypes`, no inline groups inside object/block fields,
- * no field-name collisions after group flattening.
  */
 export declare function createEntrySchemaRegistry<T extends Record<string, EntrySchema>>(registry: T): T;
 /**
- * Validates that entry schema references in .collection.json files exist in the registry.
- *
- * Useful for build-time validation to catch schema reference errors early
- * rather than at runtime on first request.
- *
- * @param entrySchemaRegistry - The entry schema registry mapping names to field definitions
- * @param contentPath - Path to the content directory containing .collection.json files
- * @returns Promise that resolves if validation passes, rejects with descriptive error if not
+ * Validate that every entry-schema reference in the `.collection.json` files under
+ * `contentPath` exists in the registry. Run it at build time so a stale reference fails
+ * there rather than at runtime on first request.
  *
  * @example
  * ```typescript