canopycms 0.0.63 → 0.0.64

package/dist/editor/permission-manager/PermissionTree.js

@@ -42,4 +42,3 @@ export const PermissionTree = ({ node, expandedNodes, selectedNode, canEdit, gro
                             minWidth: 0,
                         }, children: PERMISSION_LEVELS.map((level) => (_jsx(PermissionLevelBadge, { level: level, target: getTargetForLevel(level, 'direct'), inherited: getTargetForLevel(level, 'inherited') }, level))) })] }), _jsx(Collapse, { in: isSelected, children: _jsx(PermissionEditor, { node: node, activeLevel: activeLevel, onSetActiveLevel: onSetActiveLevel, canEdit: canEdit, groups: groups, userSearchResults: userSearchResults, isSearchingUsers: isSearchingUsers, showUserSearch: showUserSearch, userSearchQuery: userSearchQuery, userSearchError: userSearchError, onSearchUsers: onSearchUsers, onGetUserMetadata: onGetUserMetadata, onToggleUserSearch: onToggleUserSearch, onAddUser: onAddUser, onRemoveUser: onRemoveUser, showGroupSearch: showGroupSearch, groupSearchQuery: groupSearchQuery, filteredGroups: filteredGroups, onSearchGroups: onSearchGroups, onToggleGroupSearch: onToggleGroupSearch, onAddGroup: onAddGroup, onRemoveGroup: onRemoveGroup, isSelected: isSelected }) }), node.type === 'folder' && hasChildren && (_jsx(Collapse, { in: isExpanded, children: _jsx("div", { style: { paddingLeft: 16 }, children: node.children.map((child) => (_jsx(PermissionTree, { node: child, expandedNodes: expandedNodes, selectedNode: selectedNode, canEdit: canEdit, groups: groups, activeLevel: activeLevel, userSearchResults: userSearchResults, isSearchingUsers: isSearchingUsers, showUserSearch: showUserSearch, userSearchQuery: userSearchQuery, userSearchError: userSearchError, showGroupSearch: showGroupSearch, groupSearchQuery: groupSearchQuery, filteredGroups: filteredGroups, onToggle: onToggle, onSelect: onSelect, onSetActiveLevel: onSetActiveLevel, onUpdatePermission: onUpdatePermission, onSearchUsers: onSearchUsers, onGetUserMetadata: onGetUserMetadata, onToggleUserSearch: onToggleUserSearch, onAddUser: onAddUser, onRemoveUser: onRemoveUser, onSearchGroups: onSearchGroups, onToggleGroupSearch: onToggleGroupSearch, onAddGroup: onAddGroup, onRemoveGroup: onRemoveGroup }, child.path))) }) }))] }));
 };
-//# sourceMappingURL=PermissionTree.js.map

package/dist/editor/permission-manager/UserSelector.d.ts

@@ -2,7 +2,7 @@
  * User search and selection component
  */
 import React from 'react';
-import type { UserSearchResult } from './types';
+import type { UserSearchResult } from './types.js';
 export interface UserSelectorProps {
     searchQuery: string;
     onSearchChange: (query: string) => void;
@@ -13,4 +13,3 @@ export interface UserSelectorProps {
     onGetUserMetadata?: (userId: string) => Promise<UserSearchResult | null>;
 }
 export declare const UserSelector: React.FC<UserSelectorProps>;
-//# sourceMappingURL=UserSelector.d.ts.map

package/dist/editor/permission-manager/UserSelector.js

@@ -11,4 +11,3 @@ export const UserSelector = ({ searchQuery, onSearchChange, searchResults, isSea
                         fontSize: '14px',
                     } }), isSearching && _jsx(Loader, { size: "xs" }), searchError && (_jsx(Text, { size: "xs", c: "red", children: searchError })), searchResults.length > 0 && (_jsx(Stack, { gap: 4, children: searchResults.map((user) => (_jsx(Paper, { p: "xs", withBorder: true, style: { cursor: 'pointer' }, onClick: () => onSelectUser(user.id), children: onGetUserMetadata ? (_jsx(UserBadge, { userId: user.id, getUserMetadata: onGetUserMetadata, variant: "full", size: "sm", cachedUser: user, showEmailTooltip: false })) : (_jsxs(_Fragment, { children: [_jsx(Text, { size: "sm", fw: 500, children: user.name }), _jsx(Text, { size: "xs", c: "dimmed", children: user.email })] })) }, user.id))) })), searchQuery.trim() && !isSearching && searchResults.length === 0 && (_jsx(Text, { size: "xs", c: "dimmed", children: "No users found" }))] }) }));
 };
-//# sourceMappingURL=UserSelector.js.map

package/dist/editor/permission-manager/constants.d.ts

@@ -2,11 +2,10 @@
  * Constants for PermissionManager
  */
 import React from 'react';
-import type { PermissionLevel } from './types';
+import type { PermissionLevel } from './types.js';
 export declare const PERMISSION_LEVELS: PermissionLevel[];
 export declare const LEVEL_CONFIG: Record<PermissionLevel, {
     label: string;
     icon: React.ReactNode;
     color: string;
 }>;
-//# sourceMappingURL=constants.d.ts.map

package/dist/editor/permission-manager/constants.js

@@ -6,4 +6,3 @@ export const LEVEL_CONFIG = {
     edit: { label: 'Edit', icon: _jsx(IconPencil, { size: 14 }), color: 'green' },
     review: { label: 'Review', icon: _jsx(IconCheckbox, { size: 14 }), color: 'grape' },
 };
-//# sourceMappingURL=constants.js.map

package/dist/editor/permission-manager/hooks/useGroupsAndUsers.d.ts

@@ -1,7 +1,7 @@
 /**
  * Hook for managing groups and user search state
  */
-import type { UserSearchResult, PermissionGroupOption, GroupSelectItem } from '../types';
+import type { UserSearchResult, PermissionGroupOption, GroupSelectItem } from '../types.js';
 export interface UseGroupsAndUsersOptions {
     onListGroups?: () => Promise<PermissionGroupOption[]>;
     onSearchUsers?: (query: string, limit?: number) => Promise<UserSearchResult[]>;
@@ -27,4 +27,3 @@ export interface UseGroupsAndUsersResult {
     toggleUserSearch: (show: boolean) => void;
 }
 export declare function useGroupsAndUsers({ onListGroups, onSearchUsers, canEdit, }: UseGroupsAndUsersOptions): UseGroupsAndUsersResult;
-//# sourceMappingURL=useGroupsAndUsers.d.ts.map

package/dist/editor/permission-manager/hooks/useGroupsAndUsers.js

@@ -100,4 +100,3 @@ export function useGroupsAndUsers({ onListGroups, onSearchUsers, canEdit, }) {
         toggleUserSearch,
     };
 }
-//# sourceMappingURL=useGroupsAndUsers.js.map

package/dist/editor/permission-manager/hooks/usePermissionTree.d.ts

@@ -1,8 +1,8 @@
 /**
  * Hook for managing permission tree state and operations
  */
-import type { TreeNode, ContentNode, PathPermission, PermissionLevel, PermissionTarget } from '../types';
-import type { EditorCollection } from '../../Editor';
+import type { TreeNode, ContentNode, PathPermission, PermissionLevel, PermissionTarget } from '../types.js';
+import type { EditorCollection } from '../../Editor.js';
 export interface UsePermissionTreeOptions {
     collections?: EditorCollection[];
     contentRoot?: string;
@@ -38,4 +38,3 @@ export interface UsePermissionTreeResult {
     setLocalPermissions: React.Dispatch<React.SetStateAction<PathPermission[]>>;
 }
 export declare function usePermissionTree({ collections, contentRoot, permissions, contentTree, }: UsePermissionTreeOptions): UsePermissionTreeResult;
-//# sourceMappingURL=usePermissionTree.d.ts.map

package/dist/editor/permission-manager/hooks/usePermissionTree.js

@@ -122,4 +122,3 @@ export function usePermissionTree({ collections, contentRoot = 'content', permis
         setLocalPermissions,
     };
 }
-//# sourceMappingURL=usePermissionTree.js.map

package/dist/editor/permission-manager/index.d.ts

@@ -6,9 +6,8 @@
  * tree building.
  */
 import React from 'react';
-import type { PermissionManagerProps } from './types';
+import type { PermissionManagerProps } from './types.js';
 export declare const PermissionManager: React.FC<PermissionManagerProps>;
-export type { PermissionManagerProps, ContentNode, TreeNode } from './types';
-export { usePermissionTree } from './hooks/usePermissionTree';
-export { useGroupsAndUsers } from './hooks/useGroupsAndUsers';
-//# sourceMappingURL=index.d.ts.map
+export type { PermissionManagerProps, ContentNode, TreeNode } from './types.js';
+export { usePermissionTree } from './hooks/usePermissionTree.js';
+export { useGroupsAndUsers } from './hooks/useGroupsAndUsers.js';

package/dist/editor/permission-manager/index.js

@@ -122,4 +122,3 @@ export const PermissionManager = ({ collections, contentRoot = 'content', permis
 };
 export { usePermissionTree } from './hooks/usePermissionTree.js';
 export { useGroupsAndUsers } from './hooks/useGroupsAndUsers.js';
-//# sourceMappingURL=index.js.map

package/dist/editor/permission-manager/types.d.ts

@@ -1,9 +1,9 @@
 /**
  * Types for PermissionManager component
  */
-import type { PathPermission, PermissionLevel, PermissionTarget } from '../../config';
-import type { UserSearchResult, GroupMetadata, GroupSource, PermissionGroupOption } from '../../auth/types';
-import type { EditorCollection } from '../Editor';
+import type { PathPermission, PermissionLevel, PermissionTarget } from '../../config/index.js';
+import type { UserSearchResult, GroupMetadata, GroupSource, PermissionGroupOption } from '../../auth/types.js';
+import type { EditorCollection } from '../Editor.js';
 export interface PermissionManagerProps {
     /** Collections from API */
     collections?: EditorCollection[];
@@ -52,4 +52,3 @@ export interface GroupSelectItem {
 }
 /** Re-export for convenience */
 export type { PathPermission, PermissionLevel, PermissionTarget, UserSearchResult, GroupMetadata, GroupSource, PermissionGroupOption, };
-//# sourceMappingURL=types.d.ts.map

package/dist/editor/permission-manager/types.js

@@ -2,4 +2,3 @@
  * Types for PermissionManager component
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/editor/permission-manager/utils.d.ts

@@ -1,8 +1,8 @@
 /**
  * Utility functions for PermissionManager
  */
-import type { TreeNode, ContentNode, PathPermission } from './types';
-import type { EditorCollection } from '../Editor';
+import type { TreeNode, ContentNode, PathPermission } from './types.js';
+import type { EditorCollection } from '../Editor.js';
 /**
  * Search utility: Find a tree node by exact path match (recursive search).
  * Used to locate nodes when updating permissions.
@@ -57,4 +57,3 @@ export declare function buildTree(contentTree: ContentNode | undefined, contentR
  * @returns Annotated TreeNode with permission data
  */
 export declare function annotateTreeWithPermissions(node: TreeNode, permissions: PathPermission[]): TreeNode;
-//# sourceMappingURL=utils.d.ts.map

package/dist/editor/permission-manager/utils.js

@@ -149,4 +149,3 @@ export function annotateTreeWithPermissions(node, permissions) {
         children: node.children.map((child) => annotateTreeWithPermissions(child, permissions)),
     };
 }
-//# sourceMappingURL=utils.js.map

package/dist/editor/preview-bridge.d.ts

@@ -1,5 +1,5 @@
 import type { CSSProperties } from 'react';
-import { type CanopyPathSegment } from './canopy-path';
+import { type CanopyPathSegment } from './canopy-path.js';
 export declare const __CANOPY_PREVIEW_CLIENT__ = true;
 export declare const CANOPY_PREVIEW_MESSAGE = "canopycms:draft:update";
 export declare const CANOPY_PREVIEW_FOCUS = "canopycms:preview:focus";
@@ -102,4 +102,3 @@ export declare const PreviewFrame: ({ src, path, data, isLoading, className, sty
         fieldPath?: string;
     } | null) => void;
 }) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=preview-bridge.d.ts.map

package/dist/editor/preview-bridge.js

@@ -330,4 +330,3 @@ export const PreviewFrame = ({ src, path, data, isLoading, className, style, hig
                     postHighlight();
                 } })] }));
 };
-//# sourceMappingURL=preview-bridge.js.map

package/dist/editor/relative-time.d.ts

@@ -5,4 +5,3 @@
  * unchanged so callers never render "Invalid Date" to the user.
  */
 export declare function formatRelativeTime(iso: string): string;
-//# sourceMappingURL=relative-time.d.ts.map

package/dist/editor/relative-time.js

@@ -23,4 +23,3 @@ export function formatRelativeTime(iso) {
         return `${days}d ago`;
     return date.toLocaleDateString();
 }
-//# sourceMappingURL=relative-time.js.map

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

@@ -1,7 +1,7 @@
-import type { ContentFormat } from '../../config';
-import type { CreateCollectionInput, UpdateCollectionInput, CreateEntryTypeInput } from '../../schema/schema-store-types';
-import type { LogicalPath } from '../../paths/types';
-import type { SchemaOpResult } from '../hooks/useSchemaManager';
+import type { ContentFormat } from '../../config/index.js';
+import type { CreateCollectionInput, UpdateCollectionInput, CreateEntryTypeInput } from '../../schema/schema-store-types.js';
+import type { LogicalPath } from '../../paths/types.js';
+import type { SchemaOpResult } from '../hooks/useSchemaManager.js';
 export interface CollectionFormData {
     name: string;
     label: string;
@@ -51,4 +51,3 @@ export interface CollectionEditorProps {
 }
 export declare function CollectionEditor({ isOpen, editingCollection, parentPath, availableSchemas, onSave, onAddEntryType, onUpdateEntryType, onRemoveEntryType, onClose, isSaving, error, }: CollectionEditorProps): import("react/jsx-runtime").JSX.Element;
 export default CollectionEditor;
-//# sourceMappingURL=CollectionEditor.d.ts.map

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

@@ -242,4 +242,3 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
                 } })] }));
 }
 export default CollectionEditor;
-//# sourceMappingURL=CollectionEditor.js.map

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

@@ -1,5 +1,5 @@
-import type { ContentFormat } from '../../config';
-import type { CreateEntryTypeInput, UpdateEntryTypeInput } from '../../schema/schema-store-types';
+import type { ContentFormat } from '../../config/index.js';
+import type { CreateEntryTypeInput, UpdateEntryTypeInput } from '../../schema/schema-store-types.js';
 export interface EntryTypeFormData {
     name: string;
     label: string;
@@ -36,4 +36,3 @@ export interface EntryTypeEditorProps {
 }
 export declare function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, existingEntryTypeNames, onSave, onClose, isSaving, error, }: EntryTypeEditorProps): import("react/jsx-runtime").JSX.Element;
 export default EntryTypeEditor;
-//# sourceMappingURL=EntryTypeEditor.d.ts.map

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

@@ -159,4 +159,3 @@ export function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, ex
                             : '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;
-//# sourceMappingURL=EntryTypeEditor.js.map

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

@@ -5,6 +5,5 @@
  * - CollectionEditor: Create/edit collections and their entry types
  * - EntryTypeEditor: Create/edit individual entry types
  */
-export { CollectionEditor, type CollectionEditorProps, type ExistingCollection, type ExistingEntryType, } from './CollectionEditor';
-export { EntryTypeEditor, type EntryTypeEditorProps, type EntryTypeFormData, } from './EntryTypeEditor';
-//# sourceMappingURL=index.d.ts.map
+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

@@ -7,4 +7,3 @@
  */
 export { CollectionEditor, } from './CollectionEditor.js';
 export { EntryTypeEditor, } from './EntryTypeEditor.js';
-//# sourceMappingURL=index.js.map

package/dist/editor/theme.d.ts

@@ -163,4 +163,3 @@ export interface CanopyCMSProviderProps extends CanopyThemeOptions {
     children: React.ReactNode;
 }
 export declare const CanopyCMSProvider: React.FC<CanopyCMSProviderProps>;
-//# sourceMappingURL=theme.d.ts.map

package/dist/editor/theme.js

@@ -64,4 +64,3 @@ export const CanopyCMSProvider = ({ children, colors, colorScheme = 'light', the
     const theme = useMemo(() => createCanopyTheme({ colors, themeOverride }), [colors, themeOverride]);
     return (_jsx(MantineProvider, { theme: theme, defaultColorScheme: colorScheme, children: _jsxs(ModalsProvider, { children: [withNotifications ? _jsx(Notifications, { position: "bottom-left" }) : null, children] }) }));
 };
-//# sourceMappingURL=theme.js.map

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

@@ -20,4 +20,3 @@ export declare function isTestEnvironment(): boolean;
  * ```
  */
 export declare function getNotificationDuration(defaultMs?: number): number;
-//# sourceMappingURL=env.d.ts.map

package/dist/editor/utils/env.js

@@ -35,4 +35,3 @@ export function isTestEnvironment() {
 export function getNotificationDuration(defaultMs = 4000) {
     return isTestEnvironment() ? 15000 : defaultMs;
 }
-//# sourceMappingURL=env.js.map

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

@@ -12,7 +12,7 @@
  * Resolution skips fenced code blocks and inline code spans to avoid
  * corrupting code examples.
  */
-import type { ContentIdIndex, IdLocation } from './content-id-index';
+import type { ContentIdIndex, IdLocation } from './content-id-index.js';
 /**
  * Base58 alphabet pattern (matches content IDs).
  * Excludes ambiguous characters: 0, O, I, l
@@ -64,4 +64,3 @@ export declare function extractEntryLinkIds(text: string): Array<{
     id: string;
     anchor?: string;
 }>;
-//# sourceMappingURL=entry-link-resolver.d.ts.map

package/dist/entry-link-resolver.js

@@ -228,4 +228,3 @@ function splitByCodeRegions(text) {
         parts.push({ text: current, isCode: false });
     return parts;
 }
-//# sourceMappingURL=entry-link-resolver.js.map

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

@@ -1,5 +1,5 @@
-import type { EntrySchema } from './config';
-import type { EntrySchemaRegistry } from './schema/types';
+import type { EntrySchema } from './config/index.js';
+import type { EntrySchemaRegistry } from './schema/types.js';
 /**
  * Create a type-safe entry schema registry with runtime validation.
  *
@@ -79,10 +79,9 @@ export declare function createEntrySchemaRegistry<T extends Record<string, Entry
  * @example
  * ```typescript
  * import { validateEntrySchemaRegistry } from 'canopycms/server'
- * import { entrySchemaRegistry } from './schemas'
+ * import { entrySchemaRegistry } from './schemas.js'
  *
  * await validateEntrySchemaRegistry(entrySchemaRegistry, './content')
  * ```
  */
 export declare function validateEntrySchemaRegistry(entrySchemaRegistry: EntrySchemaRegistry, contentPath: string): Promise<void>;
-//# sourceMappingURL=entry-schema-registry.d.ts.map

package/dist/entry-schema-registry.js

@@ -1,5 +1,6 @@
 import { countTitleFields, findInvalidTitleFields, findTitleFieldsInLists, } from './utils/title-field.js';
-import { countBodyFields, findInvalidBodyFields } from './utils/body-field.js';
+import { countBodyFields, findInvalidBodyFields, findReservedBodyFieldName, } from './utils/body-field.js';
+import { RESOLVED_REFERENCE_KEYS } from './entry-schema.js';
 import { flattenGroupFields } from './utils/flatten-group-fields.js';
 import { ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, } from './config/validation.js';
 /** Look up a field's type by dotted path (e.g., "meta.order").
@@ -124,6 +125,10 @@ export function createEntrySchemaRegistry(registry) {
         if (invalidBodyFields.length > 0) {
             throw new Error(`Entry schema registry entry "${key}": field "${invalidBodyFields[0]}" has isBody: true but is type "${findFieldType(schema, invalidBodyFields[0])}" — isBody is only valid on markdown or mdx fields`);
         }
+        const reservedBodyField = findReservedBodyFieldName(schema, RESOLVED_REFERENCE_KEYS);
+        if (reservedBodyField) {
+            throw new Error(`Entry schema registry entry "${key}": field "${reservedBodyField}" has isBody: true but "${reservedBodyField}" is reserved — reference resolution sets ${RESOLVED_REFERENCE_KEYS.map((k) => `"${k}"`).join(', ')} on a resolved reference, and a body field with one of those names would overwrite it. Rename the field (the body's field name is yours to choose; only these four are reserved).`);
+        }
         // Field-shape checks moved here from validateCanopyConfig — these used to walk
         // the (now-removed) inline-config schema; the registry is now the canonical
         // entry point for entry schemas, so they run here.
@@ -193,4 +198,3 @@ export async function validateEntrySchemaRegistry(entrySchemaRegistry, contentPa
         throw new Error(`Entry schema registry validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
     }
 }
-//# sourceMappingURL=entry-schema-registry.js.map

package/dist/entry-schema.d.ts

@@ -12,13 +12,88 @@ type InferableField = {
         name: string;
         fields: readonly InferableField[];
     }>;
+    /**
+     * For select fields: the option list. Inferring the literal union of these values is
+     * what makes a select field's type its own options rather than a bare `string`.
+     *
+     * MUST stay `readonly` even though `SelectFieldConfig.options` (config/types.ts) is a
+     * mutable `SelectOption[]` — but NOT for the reason you might assume. A mutable
+     * constraint does not defeat `const` inference here: verified against this repo's tsc,
+     * `<const T>` still infers `['a', 'b']` with the literals intact under a mutable
+     * constraint, so the union would survive. The real failure is louder. An adopter who
+     * declares the option list separately and shares it across schemas writes
+     * `as const`, producing a `readonly` tuple — and a `readonly` array is not assignable
+     * to a mutable one (TS4104), so every such schema would stop compiling at the
+     * definition site. `readonly` here accepts both the inline literal and the shared
+     * `as const` array.
+     */
+    options?: readonly (string | {
+        label: string;
+        value: string;
+    })[];
     /** For reference fields: the target collection's schema (from defineEntrySchema) to infer resolved types. */
     resolvedSchema?: readonly InferableField[];
     /** For reference fields: filter by entry type name (e.g., ['partner']). */
     entryTypes?: readonly string[];
     /** For reference fields: collection paths to scope the search. */
     collections?: readonly string[];
+    /** For reference fields: resolve the target's body too. See ReferenceFieldConfig.includeBody. */
+    includeBody?: boolean;
 };
+/**
+ * The fields reference resolution adds to a target's own data, on top of whatever
+ * `resolvedSchema` declares.
+ *
+ * These have always been returned at runtime (`resolveSingleReferenceOnce` in
+ * content-store.ts) but were missing from the inferred type, so a resolved reference typed
+ * narrower than it actually is — which is why reading `ref.id` needed a cast, and one source
+ * of the library-internal type error `adopter-migration.md` records under
+ * `exactOptionalPropertyTypes` + `skipLibCheck: false`.
+ *
+ * `urlPath` is what makes a resolved reference linkable without a second lookup; it follows
+ * the same collection+slug rule `listEntries` publishes as `item.urlPath`, so an index entry
+ * collapses to its parent path.
+ */
+export declare const RESOLVED_REFERENCE_KEYS: readonly ["id", "slug", "collection", "urlPath"];
+/**
+ * Runtime counterpart of {@link ResolvedReferenceMeta}'s keys — the names reference resolution
+ * reserves on a resolved value. Kept beside the type so the two cannot drift, and consumed by
+ * both the resolver (which applies these last, so a target cannot shadow them) and the entry
+ * schema registry (which rejects a body field named one of them, since the body is assigned by
+ * key and would otherwise be the one way around that ordering).
+ */
+export interface ResolvedReferenceMeta {
+    /** The referenced entry's 12-char content ID. */
+    id: string;
+    /** The referenced entry's slug. */
+    slug: string;
+    /** The referenced entry's collection logical path (e.g. `content/snippets`). */
+    collection: string;
+    /** URL path for the referenced entry, e.g. `/guides/getting-started`. */
+    urlPath: string;
+}
+/**
+ * Assemble a resolved reference: the target's own data, then its body if the field asked to
+ * embed it, then the reserved metadata.
+ *
+ * Exists so the two places that construct one — the server resolver in content-store.ts and
+ * the editor's live-preview endpoint in api/resolve-references.ts — cannot drift. They already
+ * had: the preview endpoint kept the old `{ id, ...data }` order and carried none of the other
+ * three keys, so a component rendering `<a href={ref.urlPath}>` showed `undefined` while
+ * previewing and a real URL once published.
+ *
+ * The ordering is the contract, not a detail. Metadata last means a target that models `id` as
+ * a content field cannot shadow the real content ID — which matters because the write boundary
+ * recovers a reference's id from `value.id` (`referenceValueId`), so shadowing it made a
+ * re-save persist the wrong value and silently repoint the reference. Body before metadata
+ * closes the same hole for a body field named `id`; that schema is also rejected outright by
+ * the entry schema registry, so this ordering is the guarantee and that check is the loud
+ * error rather than a silent drop.
+ */
+export declare function buildResolvedReference(data: Record<string, unknown>, meta: ResolvedReferenceMeta, body?: {
+    fieldName: string;
+    value: string | undefined;
+}): Record<string, unknown>;
 /**
  * Recursively flatten inline groups (type: 'group') out of a field tuple so that
  * InferContentShape sees only data-carrying fields. Inline groups contribute no
@@ -46,6 +121,43 @@ type Simplify<T> = {
  * the `?` modifier that InferContentShape applies, never duplicated as `| undefined`.
  */
 type ScalarValue<F extends InferableField, V> = F['list'] extends true ? V[] : V;
+/**
+ * The value one `select` option contributes to the field's value union. A bare string
+ * option contributes itself; a `{ label, value }` option contributes its `value`, not
+ * the whole object. Mixed arrays of both forms work because this distributes.
+ *
+ * Falls back to `string` for an option whose literal type is gone — an options array
+ * annotated as `SelectOption[]` rather than inferred by `defineEntrySchema` widens to
+ * `string | { label: string; value: string }`, and both arms then land on `string`.
+ */
+type SelectOptionValue<O> = O extends {
+    value: infer V extends string;
+} ? V : O extends string ? O : string;
+/**
+ * The value type of a `select` field: the literal union of its OWN `options`.
+ *
+ * A select value is always a string — `SelectOption` (config/types.ts) carries
+ * `value: string` in both arms, `normalizeOptions` (editor/FormRenderer.tsx) emits
+ * strings, and `validateEntryData` (validation/entry-validator.ts) rejects anything
+ * that is not one. This type says WHICH strings.
+ *
+ * Like the rest of InferContentShape, this models the SCHEMA'S declared shape, not
+ * every byte the validator will tolerate on disk — the same stance that types a field
+ * omitting `required` as a required property. Notably the validator also accepts `''`
+ * as "not filled in" for any field that is not explicitly `required: true`, and `''` is
+ * deliberately NOT in this union.
+ *
+ * Degrades to `string` when there is nothing to infer: no `options` key at all, or an
+ * empty one. Both are schema mistakes that `ensureSelectFieldsHaveOptions`
+ * (config/validation.ts) rejects — but note it runs from `createEntrySchemaRegistry`,
+ * NOT from `validateCanopyConfig`, so a schema that is only ever fed to
+ * `TypeFromEntrySchema` and never registered gets no runtime rejection at all.
+ * Returning `never` here would type such a field as unsatisfiable, which is a worse
+ * error than the bare `string` this falls back to.
+ */
+type SelectValue<F extends InferableField> = F extends {
+    options: infer O extends readonly unknown[];
+} ? [O[number]] extends [never] ? string : SelectOptionValue<O[number]> : string;
 type ObjectValue<F extends InferableField & {
     fields: readonly InferableField[];
 }> = F['list'] extends true ? Array<InferContentShape<F['fields']>> : InferContentShape<F['fields']>;
@@ -102,10 +214,10 @@ type FieldValue<F extends InferableField> = F extends {
     }>>>;
 }> : F extends {
     type: 'select';
-} ? ScalarValue<F, string | number> : F extends {
+} ? ScalarValue<F, SelectValue<F>> : F extends {
     type: 'reference';
     resolvedSchema: infer S;
-} ? ScalarValue<F, InferContentShape<Extract<S, readonly InferableField[]>> | null> : F extends {
+} ? ScalarValue<F, (InferContentShape<Extract<S, readonly InferableField[]>> & ResolvedReferenceMeta) | null> : F extends {
     type: 'reference';
 } ? ScalarValue<F, string | null> : F extends {
     type: 'image';
@@ -471,4 +583,3 @@ export type BlockComponentRegistry<Blocks extends {
  */
 export declare const defineFieldFragment: <const T extends readonly InferableField[]>(fields: T) => T;
 export {};
-//# sourceMappingURL=entry-schema.d.ts.map

package/dist/entry-schema.js

@@ -1,6 +1,52 @@
 // The recommended SEO field names, shared with the read side (extractSeoFields) so the schema
 // this module emits and the fields that module looks for cannot drift apart.
 import { DEFAULT_SEO_FIELD_NAMES } from './static/seo.js';
+/**
+ * The fields reference resolution adds to a target's own data, on top of whatever
+ * `resolvedSchema` declares.
+ *
+ * These have always been returned at runtime (`resolveSingleReferenceOnce` in
+ * content-store.ts) but were missing from the inferred type, so a resolved reference typed
+ * narrower than it actually is — which is why reading `ref.id` needed a cast, and one source
+ * of the library-internal type error `adopter-migration.md` records under
+ * `exactOptionalPropertyTypes` + `skipLibCheck: false`.
+ *
+ * `urlPath` is what makes a resolved reference linkable without a second lookup; it follows
+ * the same collection+slug rule `listEntries` publishes as `item.urlPath`, so an index entry
+ * collapses to its parent path.
+ */
+export const RESOLVED_REFERENCE_KEYS = ['id', 'slug', 'collection', 'urlPath'];
+/**
+ * Assemble a resolved reference: the target's own data, then its body if the field asked to
+ * embed it, then the reserved metadata.
+ *
+ * Exists so the two places that construct one — the server resolver in content-store.ts and
+ * the editor's live-preview endpoint in api/resolve-references.ts — cannot drift. They already
+ * had: the preview endpoint kept the old `{ id, ...data }` order and carried none of the other
+ * three keys, so a component rendering `<a href={ref.urlPath}>` showed `undefined` while
+ * previewing and a real URL once published.
+ *
+ * The ordering is the contract, not a detail. Metadata last means a target that models `id` as
+ * a content field cannot shadow the real content ID — which matters because the write boundary
+ * recovers a reference's id from `value.id` (`referenceValueId`), so shadowing it made a
+ * re-save persist the wrong value and silently repoint the reference. Body before metadata
+ * closes the same hole for a body field named `id`; that schema is also rejected outright by
+ * the entry schema registry, so this ordering is the guarantee and that check is the loud
+ * error rather than a silent drop.
+ */
+export function buildResolvedReference(data, meta, body) {
+    const resolved = { ...data };
+    // Truthiness, matching `readEntryData`'s own merge: a listed md entry with an empty body
+    // carries no body key, so resolving one to `''` would reintroduce a listed-vs-resolved
+    // shape disagreement.
+    if (body && body.value)
+        resolved[body.fieldName] = body.value;
+    resolved.id = meta.id;
+    resolved.slug = meta.slug;
+    resolved.collection = meta.collection;
+    resolved.urlPath = meta.urlPath;
+    return resolved;
+}
 /**
  * Helper to define entry schema field arrays with literal inference without sprinkling `as const`.
  */
@@ -202,4 +248,3 @@ export const defineBlockTemplate = (template) => template;
  * ])
  */
 export const defineFieldFragment = (fields) => fields;
-//# sourceMappingURL=entry-schema.js.map

package/dist/git-manager.d.ts

@@ -1,5 +1,5 @@
 import { type SimpleGitOptions, type StatusResult } from 'simple-git';
-import type { OperatingMode } from './operating-mode';
+import type { OperatingMode } from './operating-mode/index.js';
 /**
  * Exported for GitManager's own use (see `this.git.env(...)` above),
  * worker/cms-worker.ts's push-rejection-classified GitHub calls
@@ -423,4 +423,3 @@ export declare class GitManager {
     createOrphanSettingsBranch(branchName: string, initialFiles: Record<string, string>): Promise<void>;
     private createOrphanSettingsBranchInner;
 }
-//# sourceMappingURL=git-manager.d.ts.map

package/dist/git-manager.js

@@ -1282,4 +1282,3 @@ export class GitManager {
         log.debug('git', 'Orphan settings branch created', { branchName });
     }
 }
-//# sourceMappingURL=git-manager.js.map

package/dist/github-service.d.ts

@@ -1,5 +1,5 @@
 import { Octokit } from '@octokit/rest';
-import type { CanopyConfig } from './config';
+import type { CanopyConfig } from './config/index.js';
 /**
  * Retry primary rate limits at most twice and only for short waits; beyond
  * that, task-level retry/backoff (worker) or the caller's error path takes
@@ -156,4 +156,3 @@ export declare class GitHubService {
  * Returns null if not applicable (missing token, not GitHub, etc.)
  */
 export declare const createGitHubService: (config: CanopyConfig, remoteUrl?: string) => GitHubService | null;
-//# sourceMappingURL=github-service.d.ts.map

package/dist/github-service.js

@@ -359,4 +359,3 @@ export const createGitHubService = (config, remoteUrl) => {
         return null;
     }
 };
-//# sourceMappingURL=github-service.js.map

package/dist/http/handler.d.ts

@@ -1,9 +1,9 @@
-import type { CanopyBinaryResponse, CanopyRequest, CanopyResponse } from './types';
-import type { ApiContext, ApiResponse } from '../api/types';
-import { type AuthPlugin } from '../auth/plugin';
-import { type CanopyServices } from '../services';
-import type { CanopyConfig } from '../config';
-import type { BranchContext } from '../types';
+import type { CanopyBinaryResponse, CanopyRequest, CanopyResponse } from './types.js';
+import type { ApiContext, ApiResponse } from '../api/types.js';
+import { type AuthPlugin } from '../auth/plugin.js';
+import { type CanopyServices } from '../services.js';
+import type { CanopyConfig } from '../config/index.js';
+import type { BranchContext } from '../types.js';
 /**
  * Options for creating a Canopy request handler.
  * This is framework-agnostic - adapters convert their framework's
@@ -57,4 +57,3 @@ export declare function createCanopyRequestHandler(options: CanopyHandlerOptions
 export declare function createCanopyRequestHandlerFromConfig(options: {
     config: CanopyConfig;
 } & Omit<CanopyHandlerOptions, 'services' | 'config'>): Promise<CanopyRequestHandler>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/http/handler.js

@@ -321,4 +321,3 @@ export async function createCanopyRequestHandlerFromConfig(options) {
         services: await createCanopyServices(options.config),
     });
 }
-//# sourceMappingURL=handler.js.map