@nuasite/cms 0.46.4 → 0.47.0

package/src/dev-middleware.ts

@@ -1,4 +1,4 @@
-import { createCmsCore, createNodeFs } from '@nuasite/cms-core'
+import { createCmsCore, createNodeFs, resolvePathnameFromSpec } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import path from 'node:path'
@@ -193,23 +193,33 @@ export function createDevMiddleware(
 
 			for (const [name, def] of Object.entries(collectionDefs)) {
 				const routeInfo = collectionRoutes.get(def.name)
-
-				if (routeInfo === undefined) {
-					// No page renders this collection at all — leave entries alone rather
-					// than fabricating a pathname from an unrelated frontmatter field
-					// (e.g. a data collection's own `url` field pointing elsewhere).
-					responseCollectionDefs[name] = def
-				} else {
-					const routePrefix = typeof routeInfo === 'string' ? routeInfo : undefined
-					const resolvePathname = (entry: CollectionEntryInfo): string | undefined =>
-						declaredSitePathFromData(entry.data) ?? (routePrefix ? `${routePrefix}${entry.slug}` : undefined)
-					const needsPatching = def.entries?.some(e => !e.pathname && resolvePathname(e))
-
-					responseCollectionDefs[name] = !needsPatching ? def : {
-						...def,
-						entries: def.entries!.map(e => e.pathname ? e : { ...e, pathname: resolvePathname(e) ?? e.pathname }),
-					}
-				}
+				const routePrefix = typeof routeInfo === 'string' ? routeInfo : undefined
+				// Whether any page route renders this collection. The heuristic fallbacks
+				// below (a frontmatter-declared site path, or the discovered route prefix)
+				// only apply to routed collections — otherwise a declared `cms.pathname`
+				// spec whose fields are missing for an entry would fabricate a URL from an
+				// unrelated frontmatter field (e.g. a data collection's own `url`).
+				const routed = routeInfo !== undefined
+
+				// A declarative `cms.pathname` rule is the highest-priority source: it wins
+				// over the rendered-route pathname (addPage set entry.pathname to the page
+				// URL). resolvePathnameFromSpec is the same resolver manifest-writer uses at
+				// build, so dev-preview and the built manifest agree on the entry's URL.
+				const resolvePathname = (entry: CollectionEntryInfo): string | undefined =>
+					resolvePathnameFromSpec(def, entry.data)
+						?? entry.pathname
+						?? (routed ? declaredSitePathFromData(entry.data) : undefined)
+						?? (routePrefix ? `${routePrefix}${entry.slug}` : undefined)
+
+				// Build patched copies rather than mutating the originals so heuristic
+				// pathnames don't persist if the route file is later removed. Only patch
+				// entries whose resolved pathname differs from what they already have.
+				const patchedEntries = def.entries?.map(e => {
+					const pathname = resolvePathname(e)
+					return pathname && pathname !== e.pathname ? { ...e, pathname } : e
+				})
+				const changed = patchedEntries?.some((e, i) => e !== def.entries![i]) ?? false
+				responseCollectionDefs[name] = changed ? { ...def, entries: patchedEntries! } : def
 
 				const entries = responseCollectionDefs[name].entries
 				if (entries) {
@@ -440,7 +450,7 @@ async function markHtmlForDev(
 	const idGenerator = () => `cms-${pageCounter++}`
 
 	// Check if this is a collection page
-	const collectionInfo = await findCollectionSource(pagePath, config.contentDir)
+	const collectionInfo = await findCollectionSource(pagePath, config.contentDir, manifestWriter.getCollectionDefinitions())
 	const isCollectionPage = !!collectionInfo
 
 	let mdContent: Awaited<ReturnType<typeof parseMarkdownContent>> | undefined

package/src/handlers/api-routes.ts

@@ -2,11 +2,11 @@ import type { CmsCore, CmsFileSystem } from '@nuasite/cms-core'
 import { listProjectImages } from '@nuasite/cms-core'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import path from 'node:path'
-import { scanCollections } from '../collection-scanner'
 import { getProjectRoot } from '../config'
 import { expectedDeletions } from '../dev-middleware'
 import type { ManifestWriter } from '../manifest-writer'
 import type { MediaStorageAdapter } from '../media/types'
+import { scanCollections } from '../scan-cache'
 import { handleAddArrayItem, handleRemoveArrayItem } from './array-ops'
 import { tryAstroImageUpload } from './astro-image-upload'
 import { handleInsertComponent, handleRemoveComponent } from './component-ops'

package/src/index.ts

@@ -7,9 +7,8 @@ import { fileURLToPath } from 'node:url'
 import { createLocalStorageAdapter } from '@nuasite/cms-core'
 import remarkDirective from 'remark-directive'
 import { processBuildOutput } from './build-processor'
-import { scanCollections } from './collection-scanner'
 import { ComponentRegistry } from './component-registry'
-import { resetProjectRoot } from './config'
+import { getProjectRoot, resetProjectRoot } from './config'
 import { createDevMiddleware } from './dev-middleware'
 import { getErrorCollector, resetErrorCollector } from './error-collector'
 import { ADMIN_ROUTE, createLocalAdminMiddleware } from './local-admin'
@@ -18,6 +17,7 @@ import type { MediaStorageAdapter } from './media/types'
 import { type CmsMode, resolveCmsMode } from './mode'
 import { rehypeCmsMarker } from './rehype-cms-marker'
 import { remarkListDirective } from './remark-list-directive'
+import { scanCollections } from './scan-cache'
 import type { CmsFeatures, CmsMarkerOptions, ComponentDefinition } from './types'
 import { createPublicStaticFileChecker } from './utils'
 import { createVitePlugin } from './vite-plugin'
@@ -482,14 +482,14 @@ export {
 	createS3StorageAdapter as s3Media,
 } from '@nuasite/cms-core'
 export { FIELD_TYPES, isFieldType } from '@nuasite/cms-types'
-export type { CollectionLayout, CollectionLayoutSection } from '@nuasite/cms-types'
+export type { CollectionLayout, CollectionLayoutSection, PathnameSegment, PathnameSpec } from '@nuasite/cms-types'
 export { defineCmsCollection, n } from './field-types'
 export type { DateHints, FileHints, ImageHints, LayoutHints, NumberHints, TextareaHints, TextHints } from './field-types'
 export type { MediaFolderItem, MediaItem, MediaListOptions, MediaListResult, MediaStorageAdapter, MediaTypeFilter } from './media/types'
 export { type CmsMode, detectHostedFromEnv, resolveCmsMode } from './mode'
 export type { Color, Date, DateTime, Email, Image, Reference, Textarea, Time, Url } from './prop-types'
 
-export { scanCollections } from './collection-scanner'
+export { scanCollections } from '@nuasite/cms-core'
 export { getProjectRoot, resetProjectRoot, setProjectRoot } from './config'
 export { type FieldMigration, migrateAstroImages, type MigrationOptions, type MigrationResult } from './migrate-astro-image'
 export { rehypeCmsMarker } from './rehype-cms-marker'

package/src/manifest-writer.ts

@@ -1,3 +1,4 @@
+import { resolvePathnameFromSpec } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { getProjectRoot } from './config'
@@ -279,12 +280,19 @@ export class ManifestWriter {
 
 		// Populate pathname on collection definition entries
 		for (const def of Object.values(this.collectionDefinitions)) {
-			if (def.entries) {
-				for (const entry of def.entries) {
-					const pathname = collectionPathMap.get(`${def.name}/${entry.slug}`)
-					if (pathname) {
-						entry.pathname = pathname
-					}
+			if (!def.entries) continue
+			for (const entry of def.entries) {
+				// A declarative `cms.pathname` rule is the highest-priority source: it
+				// wins over the rendered-page pathname. resolvePathnameFromSpec is the
+				// same resolver the dev middleware uses, so dev and build agree.
+				const fromSpec = resolvePathnameFromSpec(def, entry.data)
+				if (fromSpec) {
+					entry.pathname = fromSpec
+					continue
+				}
+				const pathname = collectionPathMap.get(`${def.name}/${entry.slug}`)
+				if (pathname) {
+					entry.pathname = pathname
 				}
 			}
 		}

package/src/migrate-astro-image.ts

@@ -1,8 +1,8 @@
+import { createNodeFs, scanCollections } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { parseDocument } from 'yaml'
 import { pickAstroImageTarget } from './astro-image-paths'
-import { scanCollections } from './collection-scanner'
 import { getProjectRoot } from './config'
 
 export interface MigrationOptions {
@@ -33,7 +33,7 @@ export async function migrateAstroImages(options: MigrationOptions = {}): Promis
 	const projectRoot = options.projectRoot ?? getProjectRoot()
 	const dryRun = options.dryRun ?? false
 
-	const collections = await scanCollections()
+	const collections = await scanCollections(createNodeFs(projectRoot))
 	const migrations: FieldMigration[] = []
 	const skipped: MigrationResult['skipped'] = []
 

package/src/scan-cache.ts

@@ -0,0 +1,22 @@
+import { createNodeFs, type ParseCache, scanCollections as coreScanCollections } from '@nuasite/cms-core'
+import type { CollectionDefinition } from '@nuasite/cms-types'
+import { getProjectRoot } from './config'
+
+/**
+ * Process-persistent content-config parse cache shared across every standalone
+ * collection scan (server setup + each entry create/delete). cms-core's
+ * `parseContentConfig` is mtime-keyed, so threading one cache here lets repeated
+ * scans skip re-reading and re-Babel-parsing `content.config.ts` when it hasn't
+ * changed — the CmsCore instance keeps its own cache the same way, but these
+ * top-level call sites bypass it.
+ */
+const parseCache: ParseCache = new Map()
+
+/**
+ * Scan all content collections against the current project root, reusing the
+ * shared {@link parseCache}. Drop-in replacement for cms-core's `scanCollections`
+ * for the dev-server call sites that would otherwise each allocate a fresh cache.
+ */
+export function scanCollections(contentDir?: string): Promise<Record<string, CollectionDefinition>> {
+	return coreScanCollections(createNodeFs(getProjectRoot()), contentDir, parseCache)
+}

package/src/source-finder/collection-finder.ts

@@ -1,8 +1,10 @@
+import { resolvePathnameFromSpec } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { isMap, isPair, isScalar, isSeq, LineCounter, parseDocument } from 'yaml'
 
 import { getProjectRoot } from '../config'
+import { scanCollections } from '../scan-cache'
 import type { CollectionDefinition } from '../types'
 import { getCollectionTextIndex, getDeclaredUrlIndexCache, getMarkdownFileCache, setCollectionTextIndex } from './cache'
 import { normalizeText } from './snippet-utils'
@@ -249,6 +251,7 @@ const DECLARED_URL_FIELDS = ['urlpath', 'permalink', 'pathname', 'route', 'url']
 export async function findCollectionSource(
 	pagePath: string,
 	contentDir: string = 'src/content',
+	collections?: Record<string, CollectionDefinition>,
 ): Promise<CollectionInfo | undefined> {
 	// Remove leading/trailing slashes
 	const cleanPath = pagePath.replace(/^\/+|\/+$/g, '')
@@ -259,6 +262,18 @@ export async function findCollectionSource(
 	}
 
 	const requestedUrl = normalizeSitePath(`/${cleanPath}`)
+
+	// Highest priority: derive each entry's canonical URL from its collection's
+	// declarative `cms.pathname` rule (the same spec the forward resolver/manifest
+	// use) and match. This keeps reverse resolution (URL → source file) consistent
+	// with forward resolution without the entry needing a redundant `urlPath`
+	// frontmatter field, and correctly resolves entries whose filename differs
+	// from their URL slug (e.g. people stored as `<role>__<slug>.md` served at
+	// `/<family>/<slug>`). Collections without a `cms.pathname` rule contribute
+	// nothing here and fall through to the filename/declared-URL logic below.
+	const bySpec = await resolveBySpec(requestedUrl, contentDir, collections)
+	if (bySpec) return bySpec
+
 	const contentPath = path.join(getProjectRoot(), contentDir)
 
 	try {
@@ -357,6 +372,67 @@ export async function findCollectionSource(
 	return undefined
 }
 
+// Reverse index (computed spec URL → source) cached per scanned-collections
+// object. The scan cache hands back a fresh object identity whenever the
+// content config or any entry changes, so a WeakMap keyed on it rebuilds the
+// index exactly when the underlying data changes and never goes stale.
+const specPathnameIndexCache = new WeakMap<object, Map<string, CollectionInfo>>()
+
+/**
+ * Resolve `requestedUrl` to a source file by applying each collection's
+ * declarative `cms.pathname` rule to its entries' frontmatter data. Returns
+ * undefined when no collection declares a rule or none produces `requestedUrl`.
+ *
+ * `collections` should be the definitions already scanned once at plugin setup
+ * (`manifestWriter.getCollectionDefinitions()`) — passing them keeps this off the
+ * hot per-page path with no rescans and guarantees the reverse index matches the
+ * forward resolver's specs exactly. When omitted (tests, misc callers) it falls
+ * back to a self-contained scan.
+ */
+async function resolveBySpec(
+	requestedUrl: string,
+	contentDir: string,
+	collections: Record<string, CollectionDefinition> | undefined,
+): Promise<CollectionInfo | undefined> {
+	let defs = collections
+	if (!defs) {
+		try {
+			defs = await scanCollections(contentDir)
+		} catch {
+			return undefined
+		}
+	}
+
+	let index = specPathnameIndexCache.get(defs)
+	if (!index) {
+		index = buildSpecPathnameIndex(defs)
+		specPathnameIndexCache.set(defs, index)
+	}
+	return index.get(requestedUrl)
+}
+
+/**
+ * Build a `computed-URL → CollectionInfo` map from every collection that
+ * declares a `cms.pathname` rule. Collections and entries are visited in sorted
+ * order and the first writer of a URL wins, so a URL collision (a content bug)
+ * resolves deterministically rather than depending on scan/readdir order.
+ */
+function buildSpecPathnameIndex(collections: Record<string, CollectionDefinition>): Map<string, CollectionInfo> {
+	const index = new Map<string, CollectionInfo>()
+	for (const name of Object.keys(collections).sort()) {
+		const def = collections[name]
+		if (!def?.pathname || !def.entries) continue
+		const entries = [...def.entries].sort((a, b) => a.slug.localeCompare(b.slug))
+		for (const entry of entries) {
+			if (!entry.data) continue
+			const url = resolvePathnameFromSpec(def, entry.data)
+			if (!url || index.has(url)) continue
+			index.set(url, { name: def.name, slug: entry.slug, file: entry.sourcePath })
+		}
+	}
+	return index
+}
+
 /** Normalize a site-absolute path: ensure a leading slash, drop query/hash and any trailing slash. */
 function normalizeSitePath(p: string): string {
 	let s = p.split('?')[0]?.split('#')[0] ?? p

package/src/types.ts

@@ -1,4 +1,16 @@
-import type { CollectionDefinition, CollectionEntry, ComponentDefinition } from '@nuasite/cms-types'
+import type {
+	Attribute,
+	AvailableColors,
+	AvailableTextStyles,
+	BackgroundImageMetadata,
+	CollectionDefinition,
+	CollectionEntry,
+	ComponentDefinition,
+	ContentConstraints,
+	ImageMetadata,
+	ManifestMetadata,
+	PageEntry,
+} from '@nuasite/cms-types'
 
 // Structural contract types live in @nuasite/cms-types (the shared wire model).
 // Re-exported here so existing `@nuasite/cms` imports keep working unchanged.
@@ -12,6 +24,8 @@ export type {
 	FieldHints,
 	FieldType,
 	MutationResult,
+	PathnameSegment,
+	PathnameSpec,
 } from '@nuasite/cms-types'
 export type {
 	AddRedirectRequest,
@@ -26,6 +40,23 @@ export type {
 	RedirectRule,
 	UpdateRedirectRequest,
 } from '@nuasite/cms-types'
+// Render/manifest model types now live in @nuasite/cms-types (the shared, DOM-free
+// wire model). Re-exported here so existing `@nuasite/cms` imports keep working.
+export type {
+	Attribute,
+	AvailableColors,
+	AvailableTextStyles,
+	BackgroundImageMetadata,
+	CmsManifest,
+	ComponentInstance,
+	ContentConstraints,
+	ImageMetadata,
+	ManifestEntry,
+	ManifestMetadata,
+	PageEntry,
+	TailwindColor,
+	TextStyleValue,
+} from '@nuasite/cms-types'
 
 /** SEO tracking options */
 export interface SeoOptions {
@@ -52,40 +83,6 @@ export interface CmsMarkerOptions {
 	seo?: SeoOptions
 }
 
-/** Background image metadata for elements using bg-[url()] */
-export interface BackgroundImageMetadata {
-	/** Full Tailwind class, e.g. bg-[url('/path.png')] */
-	bgImageClass: string
-	/** Extracted image URL, e.g. /path.png */
-	imageUrl: string
-	/** Background size class: bg-auto | bg-cover | bg-contain */
-	bgSize?: string
-	/** Background position class: bg-center | bg-top | bg-bottom-left | ... */
-	bgPosition?: string
-	/** Background repeat class: bg-repeat | bg-no-repeat | bg-repeat-x | bg-repeat-y */
-	bgRepeat?: string
-}
-
-/** Image metadata for better tracking and integrity */
-export interface ImageMetadata {
-	/** Image source URL */
-	src: string
-	/** Alt text */
-	alt: string
-	/** SHA256 hash of image content (for integrity checking) */
-	hash?: string
-	/** Image dimensions */
-	dimensions?: { width: number; height: number }
-	/** Responsive image srcset */
-	srcSet?: string
-	/** Image sizes attribute */
-	sizes?: string
-	/** 0-based DOM-order index of this `<img>` among same-(src, sourceFile)
-	 *  occurrences on the page. Disambiguates source location when the same
-	 *  image URL appears multiple times in the same source file. */
-	srcOccurrence?: number
-}
-
 /** Identifies the (collection, entry, field) destination for an editor upload. */
 export interface MediaUploadContext {
 	collection: string
@@ -93,186 +90,6 @@ export interface MediaUploadContext {
 	field: string
 }
 
-/** Content constraints for validation */
-export interface ContentConstraints {
-	/** Maximum content length */
-	maxLength?: number
-	/** Minimum content length */
-	minLength?: number
-	/** Regex pattern for validation */
-	pattern?: string
-	/** Allowed HTML tags for rich text content */
-	allowedTags?: string[]
-}
-
-/** Represents a single Tailwind color with its shades and values */
-export interface TailwindColor {
-	/** Color name (e.g., 'red', 'blue', 'primary') */
-	name: string
-	/** Map of shade to CSS color value (e.g., { '500': '#ef4444', '600': '#dc2626' }) */
-	values: Record<string, string>
-	/** Whether this is a custom/theme color vs default Tailwind */
-	isCustom?: boolean
-}
-
-/** Attribute with source information for git diff tracking */
-export interface Attribute {
-	/** The resolved attribute value (from rendered HTML) */
-	value: string
-	/** The expression text if dynamic (e.g., "component.githubUrl") */
-	sourceExpression?: string
-	/** Path to the source file where the value is defined */
-	sourcePath?: string
-	/** Line number where the value is defined in source (1-indexed) */
-	sourceLine?: number
-	/** The exact source snippet that can be replaced for git diff */
-	sourceSnippet?: string
-}
-
-/** Available colors palette from Tailwind config */
-export interface AvailableColors {
-	/** All available colors with their shades */
-	colors: TailwindColor[]
-	/** Default Tailwind color names */
-	defaultColors: string[]
-	/** Custom/theme color names */
-	customColors: string[]
-}
-
-/** Text style value with class name and CSS properties */
-export interface TextStyleValue {
-	/** Tailwind class name (e.g., 'font-bold', 'text-xl') */
-	class: string
-	/** Display label for UI */
-	label: string
-	/** CSS properties to apply (e.g., { fontWeight: '700' }) */
-	css: Record<string, string>
-}
-
-/** Available text styles from Tailwind config */
-export interface AvailableTextStyles {
-	/** Font weight options (font-normal, font-bold, etc.) */
-	fontWeight: TextStyleValue[]
-	/** Font size options (text-xs, text-sm, text-base, etc.) */
-	fontSize: TextStyleValue[]
-	/** Text decoration options (underline, line-through, etc.) */
-	textDecoration: TextStyleValue[]
-	/** Font style options (italic, not-italic) */
-	fontStyle: TextStyleValue[]
-}
-
-export interface ManifestEntry {
-	id: string
-	tag: string
-	/** Plain text content (for display/search) */
-	text: string
-	/** HTML content when element contains inline styling (strong, em, etc.) */
-	html?: string
-	sourcePath?: string
-	sourceLine?: number
-	/** Full element snippet from opening to closing tag (for text content updates) */
-	sourceSnippet?: string
-	variableName?: string
-	childCmsIds?: string[]
-	parentComponentId?: string
-	/** Collection name for collection entries (e.g., 'services', 'blog') */
-	collectionName?: string
-	/** Entry slug for collection entries (e.g., '3d-tisk') */
-	collectionSlug?: string
-	/** Schema field name when this entry was resolved to a specific collection field (e.g., 'image', 'cover'). */
-	collectionFieldName?: string
-	/** Path to the markdown content file (e.g., 'src/content/blog/my-post.md') */
-	contentPath?: string
-
-	// === Robustness fields ===
-
-	/** Stable ID derived from content + context hash, survives rebuilds */
-	stableId?: string
-	/** SHA256 hash of sourceSnippet at generation time for conflict detection */
-	sourceHash?: string
-	/** Image metadata for img elements (replaces imageSrc/imageAlt) */
-	imageMetadata?: ImageMetadata
-	/** Background image metadata for elements using bg-[url()] */
-	backgroundImage?: BackgroundImageMetadata
-	/** Content validation constraints */
-	constraints?: ContentConstraints
-	/** Color classes applied to this element (for buttons, etc.) */
-	colorClasses?: Record<string, Attribute>
-	/** All HTML attributes with source information */
-	attributes?: Record<string, Attribute>
-	/** Whether inline text styling (bold, italic, etc.) can be applied.
-	 *  False when text comes from a string variable/prop that cannot contain HTML markup. */
-	allowStyling?: boolean
-
-	// === Reference field metadata ===
-
-	/** Collection the text was found in when it came through a reference (e.g., 'authors') */
-	referenceCollection?: string
-	/** Collections that have reference fields pointing to referenceCollection */
-	referencedBy?: Array<{ collection: string; fieldName: string; isArray?: boolean }>
-}
-
-export interface ComponentInstance {
-	id: string
-	componentName: string
-	file: string
-	sourcePath: string
-	sourceLine: number
-	props: Record<string, any>
-	slots?: Record<string, string>
-	parentId?: string
-	/** File where this component is invoked (parent page/layout) */
-	invocationSourcePath?: string
-	/** 0-based index among same-name component invocations in the parent file */
-	invocationIndex?: number
-	/** Whether this component represents an inline HTML element inside a .map() array */
-	isInlineArray?: boolean
-}
-
-/** Manifest metadata for versioning and conflict detection */
-export interface ManifestMetadata {
-	/** Manifest schema version */
-	version: string
-	/** ISO timestamp when manifest was generated */
-	generatedAt: string
-	/** Build system that generated the manifest (e.g., 'astro', 'vite') */
-	generatedBy?: string
-	/** Build ID for correlation */
-	buildId?: string
-	/** SHA256 hash of all entry content for quick drift detection */
-	contentHash?: string
-	/** Per-source-file hashes for granular conflict detection */
-	sourceFileHashes?: Record<string, string>
-}
-
-/** Page entry for the global manifest */
-export interface PageEntry {
-	/** Page URL pathname (e.g., '/', '/about') */
-	pathname: string
-	/** Page title from SEO data */
-	title?: string
-}
-
-export interface CmsManifest {
-	/** Manifest metadata for versioning and conflict detection */
-	metadata?: ManifestMetadata
-	entries: Record<string, ManifestEntry>
-	components: Record<string, ComponentInstance>
-	componentDefinitions: Record<string, ComponentDefinition>
-	/** Content collection entries indexed by "collectionName/slug" */
-	collections?: Record<string, CollectionEntry>
-	/** Collection definitions with inferred schemas */
-	collectionDefinitions?: Record<string, CollectionDefinition>
-	/** Available Tailwind colors from the project's config */
-	availableColors?: AvailableColors
-	/** Available text styles from the project's Tailwind config */
-	availableTextStyles?: AvailableTextStyles
-	/** All pages in the site with pathname and title */
-	pages?: PageEntry[]
-	/** Component names allowed in the MDX component picker (undefined = all) */
-	mdxComponents?: string[]
-}
-
 // === SEO Types ===
 
 /** Source tracking information for SEO elements */