@nuasite/cms 0.27.0 → 0.29.0

package/src/editor/components/mdx-block-view.tsx

@@ -4,21 +4,22 @@ import {
 	commonmark,
 	liftListItemCommand,
 	toggleEmphasisCommand,
-	toggleLinkCommand,
 	toggleStrongCommand,
 	wrapInBlockquoteCommand,
 	wrapInBulletListCommand,
 	wrapInOrderedListCommand,
 } from '@milkdown/preset-commonmark'
 import { gfm, toggleStrikethroughCommand } from '@milkdown/preset-gfm'
-import { callCommand, insert, replaceAll } from '@milkdown/utils'
+import { callCommand, replaceAll } from '@milkdown/utils'
 import type { ComponentChildren } from 'preact'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'preact/hooks'
+import { useLinkPopover } from '../hooks/useLinkPopover'
 import { getComponentDefinition } from '../manifest'
 import { MDX_EXPR_PREFIX } from '../milkdown-mdx-plugin'
 import { type ActiveFormats, defaultActiveFormats, isInListType, setupFormatTracking, toggleHeading } from '../milkdown-utils'
 import { manifest, openMediaLibraryWithCallback } from '../signals'
 import type { ComponentProp } from '../types'
+import { LinkEditPopover } from './link-edit-popover'
 
 const MDX_COMPONENT_ICON_PATH =
 	'M14 10l-2 1m0 0l-2-1m2 1v2.5M20 7l-2 1m2-1l-2-1m2 1v2.5M14 4l-2-1-2 1M4 7l2-1M4 7l2 1M4 7v2.5M12 21l-2-1m2 1l2-1m-2 1v-2.5M6 18l-2-1v-2.5M18 18l2-1v-2.5'
@@ -78,6 +79,7 @@ function MiniMilkdownEditor({ value, onChange }: { value: string; onChange: (v:
 	const latestMarkdown = useRef(value)
 	const isFocused = useRef(false)
 	const [formats, setFormats] = useState<ActiveFormats>(defaultActiveFormats)
+	const link = useLinkPopover(editorRef, formats)
 
 	useEffect(() => {
 		const el = containerRef.current
@@ -144,18 +146,6 @@ function MiniMilkdownEditor({ value, onChange }: { value: string; onChange: (v:
 		return false
 	}, [])
 
-	const handleLink = useCallback(() => {
-		if (!editorRef.current) return
-		const url = prompt('Enter URL:', 'https://')
-		if (!url) return
-		try {
-			editorRef.current.action(callCommand(toggleLinkCommand.key, { href: url }))
-		} catch {
-			const linkText = window.getSelection()?.toString() || 'Link'
-			editorRef.current.action(insert(`[${linkText}](${url})`))
-		}
-	}, [])
-
 	const handleHeadingToggle = useCallback((level: number) => {
 		if (!editorRef.current) return
 		try {
@@ -242,7 +232,7 @@ function MiniMilkdownEditor({ value, onChange }: { value: string; onChange: (v:
 				<div class="w-px h-4 bg-white/15 mx-0.5" />
 
 				{/* Link */}
-				<MiniToolbarButton onClick={handleLink} title="Link" active={formats.link}>
+				<MiniToolbarButton onClick={link.toggleLinkPopover} title="Link" active={formats.link || link.linkPopoverOpen}>
 					<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
 						<path
 							stroke-linecap="round"
@@ -253,6 +243,19 @@ function MiniMilkdownEditor({ value, onChange }: { value: string; onChange: (v:
 				</MiniToolbarButton>
 			</div>
 
+			{link.linkPopoverState && (
+				<div class="mb-1.5">
+					<LinkEditPopover
+						inline
+						initialUrl={link.linkPopoverState.href}
+						suggestions={link.pageSuggestions}
+						onApply={link.applyLink}
+						onRemove={link.linkPopoverState.isEdit ? link.removeLink : undefined}
+						onClose={link.closeLinkPopover}
+					/>
+				</div>
+			)}
+
 			{/* Editor */}
 			<div
 				ref={(el) => {
@@ -311,6 +314,7 @@ const INLINE_INPUT_TYPES: Record<string, string> = {
 	datetime: 'datetime-local',
 	time: 'time',
 	email: 'email',
+	tel: 'tel',
 }
 const inputClass =
 	'w-full bg-white/5 border border-white/10 rounded-cms-sm px-2.5 py-1.5 text-[13px] text-white/80 placeholder:text-white/30 outline-none focus:border-white/25 transition-colors'
@@ -426,11 +430,11 @@ export function MdxBlockCard({ componentName, props, hasExpressions, slotContent
 
 	return (
 		<div
-			class="my-3 mx-0 bg-white/5 border border-white/15 rounded-cms-md overflow-hidden select-none"
+			class="my-3 mx-0 bg-white/5 border border-white/15 rounded-cms-md select-none"
 			data-cms-ui
 		>
 			{/* Header */}
-			<div class="flex items-center justify-between px-4 py-2.5 bg-white/5 border-b border-white/10">
+			<div class="flex items-center justify-between px-4 py-2.5 bg-white/5 border-b border-white/10 rounded-t-cms-md">
 				<div class="flex items-center gap-2">
 					<MdxComponentIcon />
 					<span class="text-[13px] font-semibold text-white">{componentName}</span>

package/src/editor/components/prop-editor.tsx

@@ -233,7 +233,13 @@ function ReferenceSelect({ collection, value, required, onChange }: {
 	if (isCreating) {
 		const slug = slugify(newName.trim())
 		return (
-			<div class="p-3 bg-white/5 border border-white/15 rounded-cms-md space-y-3">
+			<form
+				class="p-3 bg-white/5 border border-white/15 rounded-cms-md space-y-3"
+				onSubmit={(e) => {
+					e.preventDefault()
+					handleCreate()
+				}}
+			>
 				<div class="flex items-center justify-between">
 					<span class="text-[12px] font-medium text-white/70">Create new entry</span>
 					{options.length > 0 && (
@@ -251,6 +257,7 @@ function ReferenceSelect({ collection, value, required, onChange }: {
 					value={newName}
 					onInput={(e) => setNewName((e.target as HTMLInputElement).value)}
 					placeholder="Enter name..."
+					required
 					class="w-full px-4 py-2.5 bg-white/10 border border-white/20 text-[13px] text-white placeholder:text-white/40 outline-none focus:border-white/40 focus:ring-1 focus:ring-white/10 transition-all rounded-cms-md"
 					autoFocus
 				/>
@@ -279,15 +286,13 @@ function ReferenceSelect({ collection, value, required, onChange }: {
 						Cancel
 					</button>
 					<button
-						type="button"
-						onClick={handleCreate}
-						disabled={!newName.trim()}
+						type="submit"
 						class="px-3 py-1.5 text-[12px] bg-cms-primary text-cms-primary-text hover:bg-cms-primary-hover rounded-cms-md transition-colors font-medium disabled:opacity-50 disabled:cursor-not-allowed"
 					>
 						Create
 					</button>
 				</div>
-			</div>
+			</form>
 		)
 	}
 

package/src/editor/hooks/useLinkPopover.ts

@@ -0,0 +1,64 @@
+import type { Editor } from '@milkdown/core'
+import { editorViewCtx } from '@milkdown/core'
+import { toggleLinkCommand, updateLinkCommand } from '@milkdown/preset-commonmark'
+import { callCommand } from '@milkdown/utils'
+import type { RefObject } from 'preact'
+import { useCallback, useMemo, useState } from 'preact/hooks'
+import type { LinkSuggestion } from '../components/link-edit-popover'
+import type { ActiveFormats } from '../milkdown-utils'
+import { removeLinkMark } from '../milkdown-utils'
+import { manifest } from '../signals'
+
+export interface LinkPopoverState {
+	href: string
+	isEdit: boolean
+}
+
+export function useLinkPopover(editorRef: RefObject<Editor | null>, activeFormats: ActiveFormats) {
+	const [linkPopoverState, setLinkPopoverState] = useState<LinkPopoverState | null>(null)
+	const linkPopoverOpen = linkPopoverState !== null
+	const closeLinkPopover = useCallback(() => setLinkPopoverState(null), [])
+
+	const pageSuggestions = useMemo<LinkSuggestion[]>(() =>
+		(manifest.value.pages || []).map(p => ({
+			value: p.pathname,
+			label: p.title || p.pathname,
+			description: p.title ? p.pathname : undefined,
+		})), [manifest.value.pages])
+
+	const toggleLinkPopover = useCallback(() => {
+		if (!editorRef.current) return
+		setLinkPopoverState((prev) => prev !== null ? null : { href: activeFormats.linkHref || 'https://', isEdit: activeFormats.link })
+	}, [activeFormats.link, activeFormats.linkHref, editorRef])
+
+	const applyLink = useCallback((url: string) => {
+		if (!editorRef.current) return
+		const isEdit = linkPopoverState?.isEdit ?? false
+		closeLinkPopover()
+		try {
+			const view = editorRef.current.ctx.get(editorViewCtx)
+			view.focus()
+			if (isEdit) {
+				editorRef.current.action(callCommand(updateLinkCommand.key, { href: url }))
+			} else {
+				editorRef.current.action(callCommand(toggleLinkCommand.key, { href: url }))
+			}
+		} catch (error) {
+			console.error('Failed to apply link:', error)
+		}
+	}, [linkPopoverState, closeLinkPopover, editorRef])
+
+	const removeLink = useCallback(() => {
+		if (!editorRef.current) return
+		closeLinkPopover()
+		try {
+			const view = editorRef.current.ctx.get(editorViewCtx)
+			view.focus()
+			removeLinkMark(view)
+		} catch (error) {
+			console.error('Failed to remove link:', error)
+		}
+	}, [closeLinkPopover, editorRef])
+
+	return { linkPopoverState, linkPopoverOpen, closeLinkPopover, toggleLinkPopover, applyLink, removeLink, pageSuggestions }
+}

package/src/editor/milkdown-utils.ts

@@ -121,6 +121,27 @@ export function toggleHeading(view: EditorView, level: number): void {
 	view.focus()
 }
 
+/**
+ * Remove the link mark around the current cursor position.
+ * Finds the text node with a link mark at/near the selection and dispatches a removeMark transaction.
+ */
+export function removeLinkMark(view: EditorView): void {
+	const { state } = view
+	const { from, to } = state.selection
+	const linkType = state.schema.marks.link
+	if (!linkType) return
+	let linkFrom = from
+	let linkTo = to
+	state.doc.nodesBetween(from, from === to ? to + 1 : to, (node, pos) => {
+		if (linkType.isInSet(node.marks)) {
+			linkFrom = pos
+			linkTo = pos + node.nodeSize
+			return false
+		}
+	})
+	view.dispatch(state.tr.removeMark(linkFrom, linkTo, linkType))
+}
+
 function formatsEqual(a: ActiveFormats, b: ActiveFormats): boolean {
 	return a.bold === b.bold
 		&& a.italic === b.italic

package/src/field-types.ts

@@ -1,47 +1,131 @@
 import { z } from 'astro/zod'
 
 /**
- * Semantic field type schemas for content collections.
+ * Schema helpers for content collections.
  *
- * Each method returns a `z.string()` schema that Astro resolves
- * statically (concrete return type, no generics). The CMS collection
- * scanner detects them by name in the source and renders the
- * appropriate editor input.
+ * Combines Zod passthrough methods with CMS-aware semantic types,
+ * so a content config can import only `n` instead of both `n` and `z`.
  *
- * Chain Zod methods as usual (`.optional()`, `.default()`, etc.).
+ * Pass an options object to configure editor hints and Zod validation
+ * in one place. Chain `.orderBy('asc' | 'desc')` to mark the ordering field.
  *
  * @example
  * ```ts
  * import { n } from '@nuasite/cms'
- * import { z } from 'astro/zod'
  *
- * const schema = z.object({
+ * const schema = n.object({
+ *   title: n.text({ placeholder: "Enter title", maxLength: 120 }),
  *   photo: n.image(),
- *   website: n.url().optional(),
- *   contact: n.email(),
- *   accent: n.color(),
- *   publishedAt: n.date(),
- *   startsAt: n.datetime(),
- *   opensAt: n.time(),
- *   bio: n.textarea(),
+ *   bio: n.textarea({ rows: 4, maxLength: 500 }),
+ *   order: n.number({ min: 1, max: 100, step: 1 }).orderBy('asc'),
+ *   date: n.date().orderBy('desc'),
+ *   tags: n.array(n.string()),
+ *   featured: n.boolean().default(false),
  * })
  * ```
  */
+
+// --- Per-type hint interfaces ---
+
+export interface NumberHints {
+	min?: number
+	max?: number
+	step?: number
+	placeholder?: string
+}
+
+export interface TextHints {
+	placeholder?: string
+	maxLength?: number
+	minLength?: number
+}
+
+export interface TextareaHints {
+	placeholder?: string
+	maxLength?: number
+	rows?: number
+}
+
+export interface DateHints {
+	min?: string
+	max?: string
+}
+
+export interface ImageHints {
+	accept?: string
+}
+
+// --- Internals ---
+
+type OrderByDirection = 'asc' | 'desc'
+type WithOrderBy<T> = T & { orderBy(direction?: OrderByDirection): T }
+
+/** Normalize YAML Date objects to ISO date strings (YYYY-MM-DD) */
+const toISODate = (v: unknown) => (v instanceof Date ? v.toISOString().slice(0, 10) : v)
+/** Normalize YAML Date objects to ISO datetime strings */
+const toISODatetime = (v: unknown) => (v instanceof Date ? v.toISOString() : v)
+
+/** Add a chainable `.orderBy()` method to a Zod schema. The scanner detects it from source code. */
+function withOrderBy<T extends z.ZodTypeAny>(schema: T): WithOrderBy<T> {
+	const s = schema as WithOrderBy<T>
+	s.orderBy = (_direction?: OrderByDirection) => schema
+	return s
+}
+
+/** Build a CMS string field with optional length validation. Shared by text, url, email, textarea. */
+function stringField(cmsType: string, hints?: { minLength?: number; maxLength?: number }) {
+	let schema = z.string()
+	if (hints?.minLength != null) schema = schema.min(hints.minLength)
+	if (hints?.maxLength != null) schema = schema.max(hints.maxLength)
+	return withOrderBy(schema.describe(`cms:${cmsType}`))
+}
+
 export const n = {
-	/** Image picker (opens media library) */
-	image: () => z.string().describe('cms:image'),
+	// --- Zod passthroughs ---
+	/** Object schema */
+	object: <T extends z.ZodRawShape>(shape: T) => z.object(shape),
+	/** Array schema */
+	array: <T extends z.ZodTypeAny>(schema: T) => z.array(schema),
+	/** Enum schema */
+	enum: <U extends string, T extends [U, ...U[]]>(values: T) => z.enum(values),
+	/** Coerce namespace — parses input into the target type */
+	coerce: {
+		date: () => withOrderBy(z.coerce.date()),
+		number: () => withOrderBy(z.coerce.number()),
+		string: () => withOrderBy(z.coerce.string()),
+		boolean: () => withOrderBy(z.coerce.boolean()),
+	},
+
+	// --- CMS semantic types ---
+	/** Boolean / checkbox */
+	boolean: () => withOrderBy(z.boolean().describe('cms:checkbox')),
+	/** Number input with optional min/max/step */
+	number: (hints?: NumberHints) => {
+		let schema = z.number()
+		if (hints?.min != null) schema = schema.min(hints.min)
+		if (hints?.max != null) schema = schema.max(hints.max)
+		return withOrderBy(schema.describe('cms:number'))
+	},
+	/** Image picker (opens media library). Accepts hints for the scanner; no Zod validation applied. */
+	image: (_hints?: ImageHints) => withOrderBy(z.string().describe('cms:image')),
 	/** URL input */
-	url: () => z.string().describe('cms:url'),
+	url: (hints?: TextHints) => stringField('url', hints),
 	/** Email input */
-	email: () => z.string().describe('cms:email'),
+	email: (hints?: TextHints) => stringField('email', hints),
+	/** Phone number input */
+	tel: (hints?: TextHints) => stringField('tel', hints),
 	/** Color picker */
-	color: () => z.string().describe('cms:color'),
-	/** Date picker */
-	date: () => z.string().describe('cms:date'),
-	/** Date + time picker */
-	datetime: () => z.string().describe('cms:datetime'),
-	/** Time picker */
-	time: () => z.string().describe('cms:time'),
+	color: () => withOrderBy(z.string().describe('cms:color')),
+	/** Date picker (handles YAML Date coercion → ISO date string). Accepts hints for the scanner; no Zod validation applied. */
+	date: (_hints?: DateHints) => withOrderBy(z.preprocess(toISODate, z.string()).describe('cms:date')),
+	/** Date + time picker (handles YAML Date coercion → ISO datetime string). Accepts hints for the scanner; no Zod validation applied. */
+	datetime: (_hints?: DateHints) => withOrderBy(z.preprocess(toISODatetime, z.string()).describe('cms:datetime')),
+	/** Time picker. Accepts hints for the scanner; no Zod validation applied. */
+	time: (_hints?: DateHints) => withOrderBy(z.string().describe('cms:time')),
 	/** Multiline textarea */
-	textarea: () => z.string().describe('cms:textarea'),
+	textarea: (hints?: TextareaHints) => stringField('textarea', hints),
+	/** Text input */
+	text: (hints?: TextHints) => stringField('text', hints),
+	/** Plain string (no CMS type hint — type inferred from values) */
+	string: () => withOrderBy(z.string()),
 }

package/src/handlers/api-routes.ts

@@ -21,15 +21,6 @@ export interface RouteContext {
 	manifestWriter: ManifestWriter
 	contentDir: string
 	mediaAdapter?: MediaStorageAdapter
-	/**
-	 * Triggered after a content file (markdown / data collection) is written so
-	 * the dev middleware can synchronously refresh Astro's content layer and
-	 * invalidate Vite's SSR module cache before responding to the client.
-	 *
-	 * Awaiting this is important: returning success before the cache is fresh
-	 * causes the editor to reload the page into a stale render.
-	 */
-	notifyContentChanged?: (filePath: string) => Promise<void>
 }
 
 type RouteHandler = (ctx: RouteContext) => Promise<void>
@@ -113,16 +104,20 @@ const routeMap = new Map<string, RouteHandler>([
 		}
 		sendJson(res, result)
 	}),
-	custom('POST', 'markdown/update', async ({ req, res, manifestWriter, notifyContentChanged }) => {
+	custom('POST', 'markdown/update', async ({ req, res, manifestWriter }) => {
 		const body = await parseJsonBody<Parameters<typeof handleUpdateMarkdown>[0]>(req)
 		const result = await handleUpdateMarkdown(body, manifestWriter.getComponentDefinitions())
-		if (result.success && notifyContentChanged) {
-			await notifyContentChanged(body.filePath)
-		}
 		sendJson(res, result)
 	}),
 	post('markdown/rename', (body: Parameters<typeof handleRenameMarkdown>[0]) => handleRenameMarkdown(body)),
-	postWithStatus('markdown/create', (body: Parameters<typeof handleCreateMarkdown>[0]) => handleCreateMarkdown(body)),
+	custom('POST', 'markdown/create', async ({ req, res, manifestWriter, contentDir }) => {
+		const body = await parseJsonBody<Parameters<typeof handleCreateMarkdown>[0]>(req)
+		const result = await handleCreateMarkdown(body)
+		if (result.success) {
+			manifestWriter.setCollectionDefinitions(await scanCollections(contentDir))
+		}
+		sendJson(res, result, result.success ? 200 : 400)
+	}),
 	custom('POST', 'markdown/delete', async ({ req, res, manifestWriter, contentDir }) => {
 		const body = await parseJsonBody<Parameters<typeof handleDeleteMarkdown>[0]>(req)
 		const fullPath = path.resolve(getProjectRoot(), body.filePath?.replace(/^\//, '') ?? '')
@@ -238,9 +233,8 @@ export async function handleCmsApiRoute(
 	manifestWriter: ManifestWriter,
 	contentDir: string,
 	mediaAdapter?: MediaStorageAdapter,
-	notifyContentChanged?: (filePath: string) => Promise<void>,
 ): Promise<void> {
-	const ctx: RouteContext = { req, res, route, manifestWriter, contentDir, mediaAdapter, notifyContentChanged }
+	const ctx: RouteContext = { req, res, route, manifestWriter, contentDir, mediaAdapter }
 
 	// Exact match lookup
 	const handler = routeMap.get(`${req.method}:${route}`)

package/src/index.ts

@@ -358,6 +358,7 @@ async function mergeRedirects(dir: URL, logger: { info: (msg: string) => void })
 }
 
 export { n } from './field-types'
+export type { DateHints, ImageHints, NumberHints, TextareaHints, TextHints } from './field-types'
 export { createContemberStorageAdapter as contemberMedia } from './media/contember'
 export { createLocalStorageAdapter as localMedia } from './media/local'
 export { createS3StorageAdapter as s3Media } from './media/s3'
@@ -393,6 +394,7 @@ export type {
 	ComponentProp,
 	ContentConstraints,
 	FieldDefinition,
+	FieldHints,
 	FieldType,
 	ImageMetadata,
 	JsonLdEntry,

package/src/manifest-writer.ts

@@ -125,6 +125,21 @@ export class ManifestWriter {
 		return this.collectionDefinitions
 	}
 
+	/**
+	 * Clear all entry pathnames on collection definitions.
+	 * Called when route files change so stale pathnames from addPage() don't
+	 * point to routes that no longer exist.
+	 */
+	clearCollectionPathnames(): void {
+		for (const def of Object.values(this.collectionDefinitions)) {
+			if (def.entries) {
+				for (const entry of def.entries) {
+					entry.pathname = undefined
+				}
+			}
+		}
+	}
+
 	/**
 	 * Get the manifest path for a given page
 	 * Places manifest next to the page: /about -> /about.json, / -> /index.json

package/src/types.ts

@@ -236,12 +236,25 @@ export type FieldType =
 	| 'image'
 	| 'url'
 	| 'email'
+	| 'tel'
 	| 'color'
 	| 'select'
 	| 'array'
 	| 'object'
 	| 'reference'
 
+/** Editor hints for enhanced field rendering (extracted from `n.*()` options in content config) */
+export interface FieldHints {
+	min?: number | string
+	max?: number | string
+	step?: number
+	placeholder?: string
+	maxLength?: number
+	minLength?: number
+	rows?: number
+	accept?: string
+}
+
 /** Definition of a single field in a collection's schema */
 export interface FieldDefinition {
 	/** Field name as it appears in frontmatter */
@@ -270,6 +283,8 @@ export interface FieldDefinition {
 	hidden?: boolean
 	/** Source field name this field is derived from (e.g. categoryHref derived from category) */
 	derivedFrom?: string
+	/** Editor hints for enhanced field rendering */
+	hints?: FieldHints
 }
 
 /** Per-entry metadata for collection browsing */
@@ -304,6 +319,10 @@ export interface CollectionDefinition {
 	fileExtension: 'md' | 'mdx' | 'json' | 'yaml' | 'yml'
 	/** Per-entry metadata for browsing */
 	entries?: CollectionEntryInfo[]
+	/** Frontmatter field name to sort entries by (detected from `.orderBy()` in content config) */
+	orderBy?: string
+	/** Sort direction for orderBy field */
+	orderDirection?: 'asc' | 'desc'
 }
 
 /** Manifest metadata for versioning and conflict detection */

package/src/vite-plugin.ts

@@ -1,8 +1,5 @@
-import { watch } from 'node:fs'
-import { join } from 'node:path'
 import type { Plugin } from 'vite'
-import { invalidateContentCache, notifyContentStoreUpdated, type ViteServerLike } from './content-invalidator'
-import { expectedDeletions } from './dev-middleware'
+import { expectedDeletions, invalidateCollectionRoutesCache } from './dev-middleware'
 import type { ManifestWriter } from './manifest-writer'
 import { markFileDirty } from './source-finder'
 import type { CmsMarkerOptions, ComponentDefinition } from './types'
@@ -56,6 +53,11 @@ export function createVitePlugin(context: VitePluginContext): Plugin[] {
 		if (INDEXED_EXTENSIONS.test(filePath)) {
 			markFileDirty(filePath)
 		}
+		// Invalidate cached collection routes when a dynamic route file changes
+		if (filePath.includes('/src/pages/') && filePath.includes('[')) {
+			invalidateCollectionRoutesCache()
+			manifestWriter.clearCollectionPathnames()
+		}
 	}
 
 	// Intercept Vite's file watcher to:
@@ -80,83 +82,27 @@ export function createVitePlugin(context: VitePluginContext): Plugin[] {
 			// processes them. We use prependListener so our handler runs first.
 			const origEmit = watcher.emit.bind(watcher)
 			watcher.emit = ((event: string, filePath: string, ...args: any[]) => {
-				if ((event === 'unlink' || event === 'unlinkDir') && expectedDeletions.has(filePath)) {
-					expectedDeletions.delete(filePath)
-					// Swallow the event — don't let Vite/Astro see it
-					return true
+				if (event === 'unlink' || event === 'unlinkDir') {
+					if (expectedDeletions.has(filePath)) {
+						expectedDeletions.delete(filePath)
+						// Swallow the event — don't let Vite/Astro see it
+						return true
+					}
+					// Invalidate cached collection routes when a dynamic route file is deleted
+					if (filePath.includes('/src/pages/') && filePath.includes('[')) {
+						invalidateCollectionRoutesCache()
+						manifestWriter.clearCollectionPathnames()
+					}
 				}
 				return origEmit(event, filePath, ...args)
 			}) as typeof watcher.emit
 		},
 	}
 
-	// Vite's bundled chokidar 3.6.0 fails to detect changes to .astro/data-store.json
-	// (added via watcher.add() in Astro's vite-plugin-content-virtual-mod).
-	// Without this, content collection edits update the data store on disk but the
-	// browser never receives a full-reload because Vite's watcher never fires "change"
-	// for that file. We use native fs.watch as a reliable fallback.
-	//
-	// Caveat: native fs.watch on Linux tracks the inode, not the path. Astro writes
-	// data-store.json via atomic rename (writeFile-tmp + rename), which replaces the
-	// inode and silently kills the existing watcher. We re-attach on every event to
-	// keep tracking the live file across atomic writes.
-	const dataStoreWatchPlugin: Plugin = {
-		name: 'cms-data-store-watch',
-		configureServer(server) {
-			if (command !== 'dev') return
-			const root = server.config.root
-			const dataStorePath = join(root, '.astro', 'data-store.json')
-			let fsWatcher: ReturnType<typeof watch> | undefined
-			let debounce: ReturnType<typeof setTimeout> | undefined
-			let closed = false
-
-			const invalidate = () => {
-				invalidateContentCache(server as unknown as ViteServerLike)
-				// Wake any CMS API middleware call that is currently blocked
-				// waiting for the data store to reflect a just-written file.
-				// This keeps the invalidation on a single path (here) and lets
-				// the middleware respond only after the SSR module graph is fresh.
-				notifyContentStoreUpdated()
-			}
-
-			const onEvent = () => {
-				clearTimeout(debounce)
-				debounce = setTimeout(invalidate, 80)
-				// Re-attach: native fs.watch dies after the inode is replaced by an
-				// atomic rename. Close current and restart so subsequent writes are
-				// observed.
-				fsWatcher?.close()
-				fsWatcher = undefined
-				if (!closed) startWatching()
-			}
-
-			const startWatching = () => {
-				if (closed) return
-				try {
-					fsWatcher = watch(dataStorePath, onEvent)
-				} catch {
-					// File doesn't exist yet — retry when it appears
-					setTimeout(startWatching, 2000)
-				}
-			}
-
-			// Data store is created during content sync, which runs after server start
-			setTimeout(startWatching, 3000)
-
-			const origClose = server.close.bind(server)
-			server.close = async () => {
-				closed = true
-				fsWatcher?.close()
-				clearTimeout(debounce)
-				return origClose()
-			}
-		},
-	}
-
 	// Note: We cannot use transformIndexHtml for static Astro builds because
 	// Astro generates HTML files directly without going through Vite's HTML pipeline.
 	// HTML processing is done in build-processor.ts after pages are generated.
 	// Source location attributes are provided natively by Astro's compiler
 	// (data-astro-source-file, data-astro-source-loc) in dev mode.
-	return [virtualManifestPlugin, watcherPlugin, dataStoreWatchPlugin, createArrayTransformPlugin()]
+	return [virtualManifestPlugin, watcherPlugin, createArrayTransformPlugin()]
 }