@nuasite/cms 0.28.0 → 0.30.0

package/src/editor/hooks/useClickOutsideEscape.ts

@@ -0,0 +1,43 @@
+import { useEffect, useRef } from 'preact/hooks'
+
+/**
+ * Dismiss handler for floating UI: closes on outside mousedown or Escape key.
+ * Pass all refs that should be considered "inside" (e.g. panel + trigger).
+ *
+ * Uses composedPath() so it works correctly inside Shadow DOM, and registers
+ * in the capture phase so stopPropagation() in bubble-phase handlers
+ * (e.g. modal overlays) doesn't block detection.
+ */
+export function useClickOutsideEscape(
+	refs: ReadonlyArray<{ readonly current: HTMLElement | null }>,
+	isOpen: boolean,
+	onClose: () => void,
+): void {
+	// Store refs and onClose in a ref so the effect never needs to re-register
+	// when the caller creates a new array (e.g. from spreading exemptRefs).
+	// The actual .current values of each ref are read at event time, not capture time.
+	const stableRefs = useRef(refs)
+	stableRefs.current = refs
+	const stableOnClose = useRef(onClose)
+	stableOnClose.current = onClose
+
+	useEffect(() => {
+		if (!isOpen) return
+		const onMouseDown = (e: MouseEvent) => {
+			const path = e.composedPath()
+			for (const ref of stableRefs.current) {
+				if (ref.current && path.includes(ref.current)) return
+			}
+			stableOnClose.current()
+		}
+		const onKeyDown = (e: KeyboardEvent) => {
+			if (e.key === 'Escape') stableOnClose.current()
+		}
+		document.addEventListener('mousedown', onMouseDown, true)
+		document.addEventListener('keydown', onKeyDown)
+		return () => {
+			document.removeEventListener('mousedown', onMouseDown, true)
+			document.removeEventListener('keydown', onKeyDown)
+		}
+	}, [isOpen])
+}

package/src/editor/hooks/useSearchFilter.ts

@@ -0,0 +1,21 @@
+import { useMemo, useRef } from 'preact/hooks'
+
+/**
+ * Filter a list of items by a search query.
+ * The `getSearchableText` callback returns the text to match against (e.g. `o => \`${o.label} ${o.value}\``).
+ * Uses a ref internally so callers don't need to memoize the callback.
+ */
+export function useSearchFilter<T>(
+	items: T[],
+	query: string,
+	getSearchableText: (item: T) => string,
+): T[] {
+	const fnRef = useRef(getSearchableText)
+	fnRef.current = getSearchableText
+
+	return useMemo(() => {
+		if (!query) return items
+		const q = query.toLowerCase()
+		return items.filter(item => fnRef.current(item).toLowerCase().includes(q))
+	}, [items, query])
+}

package/src/field-types.ts

@@ -112,6 +112,8 @@ export const n = {
 	url: (hints?: TextHints) => stringField('url', hints),
 	/** Email input */
 	email: (hints?: TextHints) => stringField('email', hints),
+	/** Phone number input */
+	tel: (hints?: TextHints) => stringField('tel', hints),
 	/** Color picker */
 	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. */

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/html-processor.ts

@@ -17,6 +17,35 @@ import { generateStableId } from './utils'
 /** Type for parsed HTML element nodes from node-html-parser */
 type HTMLNode = ParsedHTMLElement
 
+/** Check whether any ancestor of `node` (inclusive) has `data-astro-source-file`. */
+function hasAncestorSourceFile(node: HTMLNode): boolean {
+	let current: HTMLNode | null = node
+	while (current) {
+		if (current.getAttribute?.('data-astro-source-file')) return true
+		current = current.parentNode as HTMLNode | null
+	}
+	return false
+}
+
+/** Walk ancestors of `node` (inclusive) to find the nearest source file and line. */
+function findAncestorSourceLocation(node: HTMLNode): { sourceFile?: string; sourceLine?: number } {
+	let current: HTMLNode | null = node
+	while (current) {
+		const file = current.getAttribute?.('data-astro-source-file')
+		if (file) {
+			const line = current.getAttribute?.('data-astro-source-loc') || current.getAttribute?.('data-astro-source-line')
+			let sourceLine: number | undefined
+			if (line) {
+				const parsed = parseInt(line.split(':')[0] ?? '1', 10)
+				if (!Number.isNaN(parsed)) sourceLine = parsed
+			}
+			return { sourceFile: file, sourceLine }
+		}
+		current = current.parentNode as HTMLNode | null
+	}
+	return {}
+}
+
 /**
  * Inline text styling elements that should NOT be marked with CMS IDs.
  * These elements are text formatting and should be part of their parent's content.
@@ -434,52 +463,61 @@ export async function processHtml(
 	// This needs to run BEFORE image marking so we can skip images inside markdown
 	let markdownWrapperNode: HTMLNode | null = null
 
-	// Two strategies:
-	// 1. Dev mode: look for elements with data-astro-source-file containing children without it
-	// 2. Build mode: find element whose first child content matches the start of markdown body
+	// Three strategies in priority order:
+	// 0. Rehype marker: the rehype-cms-marker plugin marks the first rendered element
+	//    with data-cms-markdown-content — its parent is the wrapper
+	// 1. Dev mode heuristic: elements with data-astro-source-file whose children lack it
+	// 2. Build mode: find element whose content matches the markdown body text
 	if (collectionInfo) {
 		const allElements = root.querySelectorAll('*')
 		let foundWrapper = false
 
+		// Strategy 0: Rehype marker — most reliable
+		const markerEl = root.querySelector('[data-cms-markdown-content]')
+		if (markerEl) {
+			markerEl.removeAttribute('data-cms-markdown-content')
+			const parent = markerEl.parentNode as HTMLNode | null
+			if (parent && parent.tagName) {
+				const id = getNextId()
+				parent.setAttribute(attributeName, id)
+				parent.setAttribute('data-cms-markdown', 'true')
+				collectionWrapperId = id
+				markdownWrapperNode = parent
+				foundWrapper = true
+			}
+		}
+
 		// Strategy 1: Dev mode - look for source file attributes
-		const SKIP_WRAPPER_TAGS = new Set(['html', 'head', 'body', 'script', 'style', 'meta', 'link'])
-		for (const node of allElements) {
-			const tag = node.tagName?.toLowerCase?.() ?? ''
-			if (SKIP_WRAPPER_TAGS.has(tag)) continue
-			const sourceFile = node.getAttribute('data-astro-source-file')
-			if (!sourceFile) continue
-
-			// Check if this element has any direct child elements without source file attribute
-			// These would be markdown-rendered elements
-			const childElements = node.childNodes.filter(
-				(child): child is HTMLNode => child.nodeType === 1 && 'tagName' in child,
-			)
-			const hasMarkdownChildren = childElements.some(
-				(child) => !child.getAttribute?.('data-astro-source-file'),
-			)
-
-			if (hasMarkdownChildren) {
-				// Check if any ancestor already has been marked as a collection wrapper
-				// We want the innermost wrapper
-				let parent = node.parentNode as HTMLNode | null
-				let hasAncestorWrapper = false
-				while (parent) {
-					if (parent.getAttribute?.(attributeName)?.startsWith('cms-collection-')) {
-						hasAncestorWrapper = true
-						break
+		if (!foundWrapper) {
+			const SKIP_WRAPPER_TAGS = new Set(['html', 'head', 'body', 'script', 'style', 'meta', 'link'])
+			for (const node of allElements) {
+				const tag = node.tagName?.toLowerCase?.() ?? ''
+				if (SKIP_WRAPPER_TAGS.has(tag)) continue
+				const sourceFile = node.getAttribute('data-astro-source-file')
+				if (!sourceFile) continue
+
+				// Check if this element has any direct child elements without source file attribute
+				// These would be markdown-rendered elements
+				const childElements = node.childNodes.filter(
+					(child): child is HTMLNode => child.nodeType === 1 && 'tagName' in child,
+				)
+				const hasMarkdownChildren = childElements.some(
+					(child) => !child.getAttribute?.('data-astro-source-file'),
+				)
+
+				if (hasMarkdownChildren) {
+					// Remove data-cms-markdown from previous (shallower) wrapper —
+					// we want only the deepest wrapper to have it
+					if (markdownWrapperNode) {
+						markdownWrapperNode.removeAttribute('data-cms-markdown')
 					}
-					parent = parent.parentNode as HTMLNode | null
-				}
 
-				if (!hasAncestorWrapper) {
-					// Mark this as the collection wrapper using the standard attribute
 					const id = getNextId()
 					node.setAttribute(attributeName, id)
 					node.setAttribute('data-cms-markdown', 'true')
 					collectionWrapperId = id
 					markdownWrapperNode = node
 					foundWrapper = true
-					// Don't break - we want the deepest wrapper, so we'll overwrite
 				}
 			}
 		}
@@ -636,42 +674,13 @@ export async function processHtml(
 
 		// When skipMarkdownContent is true (collection pages), only mark images
 		// that have source file attributes (from Astro templates, not markdown)
-		if (skipMarkdownContent) {
-			// Check if the image or any ancestor has source file attribute
-			let hasSourceAttr = false
-			let current: HTMLNode | null = node
-			while (current) {
-				if (current.getAttribute?.('data-astro-source-file')) {
-					hasSourceAttr = true
-					break
-				}
-				current = current.parentNode as HTMLNode | null
-			}
-			if (!hasSourceAttr) return
-		}
+		if (skipMarkdownContent && !hasAncestorSourceFile(node)) return
 
 		const id = getNextId()
 		node.setAttribute(attributeName, id)
 		node.setAttribute('data-cms-img', 'true')
 
-		// Try to get source location from the image itself or ancestors
-		let sourceFile: string | undefined
-		let sourceLine: number | undefined
-		let current: HTMLNode | null = node
-		while (current && !sourceFile) {
-			const file = current.getAttribute?.('data-astro-source-file')
-			const line = current.getAttribute?.('data-astro-source-loc') || current.getAttribute?.('data-astro-source-line')
-			if (file) {
-				sourceFile = file
-				if (line) {
-					const lineNum = parseInt(line.split(':')[0] ?? '1', 10)
-					if (!Number.isNaN(lineNum)) {
-						sourceLine = lineNum
-					}
-				}
-			}
-			current = current.parentNode as HTMLNode | null
-		}
+		const { sourceFile, sourceLine } = findAncestorSourceLocation(node)
 
 		// Build image metadata
 		const metadata: ImageMetadata = {
@@ -708,41 +717,13 @@ export async function processHtml(
 		if (!bgMeta) return
 
 		// When skipMarkdownContent is true, only mark elements with source file attributes
-		if (skipMarkdownContent) {
-			let hasSourceAttr = false
-			let current: HTMLNode | null = node
-			while (current) {
-				if (current.getAttribute?.('data-astro-source-file')) {
-					hasSourceAttr = true
-					break
-				}
-				current = current.parentNode as HTMLNode | null
-			}
-			if (!hasSourceAttr) return
-		}
+		if (skipMarkdownContent && !hasAncestorSourceFile(node)) return
 
 		const id = getNextId()
 		node.setAttribute(attributeName, id)
 		node.setAttribute('data-cms-bg-img', 'true')
 
-		// Try to get source location from the element itself or ancestors
-		let sourceFile: string | undefined
-		let sourceLine: number | undefined
-		let current: HTMLNode | null = node
-		while (current && !sourceFile) {
-			const file = current.getAttribute?.('data-astro-source-file')
-			const line = current.getAttribute?.('data-astro-source-loc') || current.getAttribute?.('data-astro-source-line')
-			if (file) {
-				sourceFile = file
-				if (line) {
-					const lineNum = parseInt(line.split(':')[0] ?? '1', 10)
-					if (!Number.isNaN(lineNum)) {
-						sourceLine = lineNum
-					}
-				}
-			}
-			current = current.parentNode as HTMLNode | null
-		}
+		const { sourceFile, sourceLine } = findAncestorSourceLocation(node)
 
 		bgImageEntries.set(id, {
 			metadata: bgMeta,

package/src/index.ts

@@ -13,6 +13,7 @@ import { getErrorCollector, resetErrorCollector } from './error-collector'
 import { ManifestWriter } from './manifest-writer'
 import { createLocalStorageAdapter } from './media/local'
 import type { MediaStorageAdapter } from './media/types'
+import { rehypeCmsMarker } from './rehype-cms-marker'
 import type { CmsFeatures, CmsMarkerOptions, ComponentDefinition } from './types'
 import { createVitePlugin } from './vite-plugin'
 
@@ -283,6 +284,9 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 				const needsAliases = !src && !hasPrebuiltBundle
 
 				updateConfig({
+					markdown: {
+						rehypePlugins: [rehypeCmsMarker],
+					},
 					vite: {
 						plugins: vitePlugins,
 						resolve: needsAliases
@@ -367,6 +371,7 @@ export type { Color, Date, DateTime, Email, Image, Reference, Textarea, Time, Ur
 
 export { scanCollections } from './collection-scanner'
 export { getProjectRoot, resetProjectRoot, setProjectRoot } from './config'
+export { rehypeCmsMarker } from './rehype-cms-marker'
 export type { CollectionInfo, MarkdownContent, SourceLocation, VariableReference } from './source-finder'
 export { findCollectionSource, parseMarkdownContent } from './source-finder'
 export type {

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/rehype-cms-marker.ts

@@ -0,0 +1,15 @@
+/**
+ * Rehype plugin that marks the first element of rendered markdown/MDX content
+ * with `data-cms-markdown-content`. The HTML processor uses this marker to
+ * reliably identify the wrapper element (the marker's parent) instead of
+ * relying on heuristics.
+ */
+export function rehypeCmsMarker() {
+	return (tree: any) => {
+		const firstElement = tree.children?.find((n: any) => n.type === 'element')
+		if (firstElement) {
+			firstElement.properties ??= {}
+			firstElement.properties['dataCmsMarkdownContent'] = ''
+		}
+	}
+}

package/src/types.ts

@@ -236,6 +236,7 @@ export type FieldType =
 	| 'image'
 	| 'url'
 	| 'email'
+	| 'tel'
 	| 'color'
 	| 'select'
 	| 'array'

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()]
 }

package/src/content-invalidator.ts

@@ -1,134 +0,0 @@
-/**
- * Vite SSR module cache invalidation + content-sync coordination.
- *
- * Astro's content layer chain (chokidar → glob loader → syncData → data store
- * → fs.watch → invalidateModule) is racy and unreliable under several conditions:
- *
- *   - Native fs.watch on Linux dies after the first atomic rename of the watched
- *     file (Astro writes data-store.json via writeFile-tmp + rename).
- *   - Vite's bundled chokidar 3.6.0 misses the same atomic-write events.
- *   - `invalidateModule(astro:data-layer-content)` alone does not propagate up
- *     the import graph, so route modules that already cached `getCollection`
- *     references keep returning stale data.
- *
- * This module exposes two things:
- *
- *   - `invalidateContentCache(server)` — walks the SSR module graph from
- *     `astro:data-layer-content` upward and invalidates every transitive
- *     importer, then broadcasts `full-reload` to the client.
- *   - `notifyContentStoreUpdated` / `awaitNextContentStoreUpdate` — a shared
- *     rendezvous between the fs.watch plugin (which observes data-store.json
- *     writes) and the CMS API middleware (which needs to hold the HTTP
- *     response until the store is fresh). Keeps invalidation on a single path.
- */
-
-interface SsrModuleNode {
-	id: string | null
-	importers: Set<SsrModuleNode>
-}
-
-interface SsrModuleGraph {
-	getModuleById(id: string): SsrModuleNode | undefined
-	invalidateModule(
-		mod: SsrModuleNode,
-		seen?: Set<SsrModuleNode>,
-		timestamp?: number,
-		isHmr?: boolean,
-	): void
-}
-
-interface SsrEnvironment {
-	moduleGraph: SsrModuleGraph
-	hot: { send: (event: string, data?: unknown) => void }
-}
-
-interface ClientEnvironment {
-	hot: { send: (payload: { type: string; path: string }) => void }
-}
-
-export interface ViteServerLike {
-	environments: { ssr: SsrEnvironment; client: ClientEnvironment }
-}
-
-// Astro exposes the content data store as a virtual module whose resolved id
-// is `\0astro:data-layer-content` (see astro/dist/content/consts.js). Earlier
-// versions of this file used `\0astro:data-store`, which does not exist and
-// silently reduced `invalidateContentCache` to a no-op full-reload broadcast.
-const DATA_STORE_VIRTUAL_ID = '\0astro:data-layer-content'
-
-/**
- * Invalidate the SSR `astro:data-layer-content` virtual module and every
- * module that (transitively) imports it. After this returns, the next request
- * that imports any of these modules will re-execute and read fresh content.
- *
- * Also broadcasts `full-reload` so any connected browser refreshes.
- */
-export function invalidateContentCache(server: ViteServerLike): void {
-	const ssr = server.environments.ssr
-	const dataStoreMod = ssr.moduleGraph.getModuleById(DATA_STORE_VIRTUAL_ID)
-	if (dataStoreMod) {
-		const seen = new Set<SsrModuleNode>()
-		const ts = Date.now()
-		const walk = (mod: SsrModuleNode) => {
-			if (seen.has(mod)) return
-			seen.add(mod)
-			ssr.moduleGraph.invalidateModule(mod, seen, ts, true)
-			for (const importer of mod.importers) {
-				walk(importer)
-			}
-		}
-		walk(dataStoreMod)
-	}
-	ssr.hot.send('astro:content-changed', {})
-	server.environments.client.hot.send({ type: 'full-reload', path: '*' })
-}
-
-// ---------------------------------------------------------------------------
-// Content-sync rendezvous
-// ---------------------------------------------------------------------------
-//
-// The CMS API middleware writes a content file and then needs to hold the HTTP
-// response until Astro has actually re-synced the data store — otherwise the
-// browser reloads into a stale render. The fs.watch plugin is the component
-// that observes the data-store.json write, so it is also the component that
-// resolves these waiters.
-
-type StoreUpdateResolver = () => void
-const pendingStoreUpdateWaiters = new Set<StoreUpdateResolver>()
-
-/**
- * Called by the data-store fs.watch plugin after it has invalidated the SSR
- * module cache in response to a data-store.json write. Wakes every middleware
- * caller currently parked in `awaitNextContentStoreUpdate`.
- */
-export function notifyContentStoreUpdated(): void {
-	if (pendingStoreUpdateWaiters.size === 0) return
-	const resolvers = Array.from(pendingStoreUpdateWaiters)
-	pendingStoreUpdateWaiters.clear()
-	for (const resolve of resolvers) resolve()
-}
-
-/**
- * Park until the next data-store.json write has been fully processed (store
- * reloaded on disk, SSR module graph invalidated). Resolves with `true` on
- * success or `false` if the timeout elapses first — callers should treat
- * timeout as "best-effort, proceed anyway".
- *
- * The timeout fallback exists because some edits legitimately do not change
- * the data store (e.g. whitespace-only edits are skipped by Astro's atomic
- * write comparator), in which case no fs.watch event will ever fire.
- */
-export function awaitNextContentStoreUpdate(timeoutMs: number): Promise<boolean> {
-	return new Promise((resolve) => {
-		const resolver = () => {
-			clearTimeout(timer)
-			pendingStoreUpdateWaiters.delete(resolver)
-			resolve(true)
-		}
-		const timer = setTimeout(() => {
-			pendingStoreUpdateWaiters.delete(resolver)
-			resolve(false)
-		}, timeoutMs)
-		pendingStoreUpdateWaiters.add(resolver)
-	})
-}