@nuasite/cms 0.42.1 → 0.43.0-beta.1

package/dist/editor.js

@@ -386,7 +386,7 @@ function fC(t, e) {
 function mC(t, e) {
   return typeof e == "function" ? e(t) : e;
 }
-const W3 = "0.42.1", K3 = W3, ct = {
+const W3 = "0.43.0-beta.1", K3 = W3, ct = {
   /** Highlight overlay for hovered elements */
   HIGHLIGHT: 2147483644,
   /** Hover outline for elements/components */

package/package.json

@@ -14,7 +14,7 @@
     "directory": "packages/astro-cms"
   },
   "license": "Apache-2.0",
-  "version": "0.42.1",
+  "version": "0.43.0-beta.1",
   "module": "src/index.ts",
   "types": "src/index.ts",
   "type": "module",
@@ -26,6 +26,8 @@
     }
   },
   "dependencies": {
+    "@nuasite/cms-core": "0.43.0-beta.1",
+    "@nuasite/cms-types": "0.43.0-beta.1",
     "@astrojs/compiler": "^3.0.1",
     "@babel/parser": "^7.29.2",
     "node-html-parser": "^7.1.0",

package/src/dev-middleware.ts

@@ -1,3 +1,4 @@
+import { createCmsCore, createNodeFs } from '@nuasite/cms-core'
 import fs from 'node:fs/promises'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import path from 'node:path'
@@ -118,7 +119,15 @@ export function createDevMiddleware(
 
 	// CMS API endpoints (local dev server backend)
 	if (options.enableCmsApi) {
-		const projectRoot = getProjectRoot()
+		// One cms-core instance per project root. Structural routes (entry/page/redirect
+		// CRUD, media) delegate to this brain over a node:fs adapter; the media adapter
+		// and component dirs mirror the selection @nuasite/cms makes for the dev server.
+		const cmsFs = createNodeFs(getProjectRoot())
+		const core = createCmsCore(cmsFs, {
+			contentDir: config.contentDir,
+			media: options.mediaAdapter,
+			componentDirs: config.componentDirs,
+		})
 
 		server.middlewares.use((req, res, next) => {
 			const url = req.url || ''
@@ -136,6 +145,8 @@ export function createDevMiddleware(
 				res,
 				route,
 				manifestWriter,
+				core,
+				fs: cmsFs,
 				contentDir: config.contentDir,
 				mediaAdapter: options.mediaAdapter,
 				maxUploadSize: options.maxUploadSize,

package/src/handlers/api-routes.ts

@@ -1,17 +1,16 @@
+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 { listProjectImages } from '../media/project-images'
 import type { MediaStorageAdapter } from '../media/types'
 import { handleAddArrayItem, handleRemoveArrayItem } from './array-ops'
 import { tryAstroImageUpload } from './astro-image-upload'
 import { handleInsertComponent, handleRemoveComponent } from './component-ops'
-import { handleCreateMarkdown, handleDeleteMarkdown, handleGetMarkdownContent, handleRenameMarkdown, handleUpdateMarkdown } from './markdown-ops'
-import { handleCheckSlugExists, handleCreatePage, handleDeletePage, handleDuplicatePage, handleGetLayouts } from './page-ops'
-import { handleAddRedirect, handleDeleteRedirect, handleGetRedirects, handleUpdateRedirect } from './redirect-ops'
+import { handleCheckSlugExists } from './page-ops'
 import { BodyTooLargeError, parseJsonBody, parseMultipartFile, readBody, sendError, sendJson } from './request-utils'
 import { handleUpdate } from './source-writer'
 
@@ -20,6 +19,10 @@ export interface RouteContext {
 	res: ServerResponse
 	route: string
 	manifestWriter: ManifestWriter
+	/** The framework-agnostic brain. Structural routes delegate here. */
+	core: CmsCore
+	/** Raw FileSystem port (for the few helpers that scan the project directly). */
+	fs: CmsFileSystem
 	contentDir: string
 	mediaAdapter?: MediaStorageAdapter
 	maxUploadSize: number
@@ -39,6 +42,37 @@ function getQuery(ctx: RouteContext): URLSearchParams {
 	return new URL(ctx.req.url!, `http://${ctx.req.headers.host}`).searchParams
 }
 
+/**
+ * Derive `{ collection, slug }` from a root-relative content-entry `filePath`.
+ *
+ * The dev API is addressed by `filePath` (e.g. `src/content/blog/hello.md`),
+ * while cms-core is addressed by `{ collection, slug }`. The collection is the
+ * first path segment under `contentDir`; the slug is the remainder with the
+ * extension stripped (and a trailing `/index` collapsed for index-layout
+ * entries). cms-core's path resolution is the exact inverse: a flat `<slug>.<ext>`
+ * resolves first, an index `<slug>/index.{md,mdx}` after — so the derived pair
+ * resolves back to the same file.
+ */
+function filePathToEntry(contentDir: string, filePath: string): { collection: string; slug: string } | null {
+	const normalized = filePath.replace(/^\/+/, '')
+	const prefix = `${contentDir.replace(/\/+$/, '')}/`
+	if (!normalized.startsWith(prefix)) return null
+
+	const rel = normalized.slice(prefix.length)
+	const firstSlash = rel.indexOf('/')
+	if (firstSlash < 0) return null
+
+	const collection = rel.slice(0, firstSlash)
+	const entryPath = rel.slice(firstSlash + 1)
+	if (!collection || !entryPath) return null
+
+	const withoutExt = entryPath.replace(/\.(md|mdx|json|yaml|yml)$/, '')
+	const slug = withoutExt.replace(/\/index$/, '')
+	if (!slug) return null
+
+	return { collection, slug }
+}
+
 // -- Route helper factories --
 
 /** POST route: parse JSON body → handler(body, manifestWriter) → sendJson */
@@ -49,19 +83,19 @@ function post<T>(route: string, handler: (body: T, mw: ManifestWriter) => Promis
 	}]
 }
 
-/** POST route: parse JSON body → handler(body) → sendJson with success-based status */
-function postWithStatus<T>(route: string, handler: (body: T) => Promise<{ success: boolean }>): [string, RouteHandler] {
-	return [`POST:${route}`, async ({ req, res }) => {
+/** POST route through cms-core: parse JSON body → handler(body, core) → sendJson with success-based status */
+function postCore<T>(route: string, handler: (body: T, core: CmsCore) => Promise<{ success: boolean }>): [string, RouteHandler] {
+	return [`POST:${route}`, async ({ req, res, core }) => {
 		const body = await parseJsonBody<T>(req)
-		const result = await handler(body)
+		const result = await handler(body, core)
 		sendJson(res, result, result.success ? 200 : 400)
 	}]
 }
 
-/** GET route: handler() → sendJson */
-function get(route: string, handler: () => Promise<unknown>): [string, RouteHandler] {
-	return [`GET:${route}`, async ({ res }) => {
-		sendJson(res, await handler())
+/** GET route through cms-core: handler(core) → sendJson */
+function getCore(route: string, handler: (core: CmsCore) => Promise<unknown>): [string, RouteHandler] {
+	return [`GET:${route}`, async ({ res, core }) => {
+		sendJson(res, await handler(core))
 	}]
 }
 
@@ -82,54 +116,150 @@ const ALLOWED_UPLOAD_TYPES = new Set([
 	'application/pdf',
 ])
 
+/** Frontmatter shape the create route enriches with title/date for markdown entries. */
+interface CreateMarkdownBody {
+	collection: string
+	title: string
+	slug: string
+	frontmatter?: Record<string, unknown>
+	content?: string
+	fileExtension?: string
+}
+
+interface UpdateMarkdownBody {
+	filePath: string
+	frontmatter?: Record<string, unknown>
+	content?: string
+}
+
+interface DeleteMarkdownBody {
+	filePath: string
+}
+
+interface RenameMarkdownBody {
+	filePath: string
+	newSlug: string
+}
+
+interface DuplicatePageBody {
+	sourcePagePath: string
+	slug: string
+	title?: string
+	layoutPath?: string
+	createRedirect?: boolean
+}
+
+interface DeletePageBody {
+	pagePath: string
+	createRedirect?: boolean
+	redirectTo?: string
+}
+
+const DATA_EXTENSIONS = new Set(['json', 'yaml', 'yml'])
+
 /** O(1) route lookup map: "METHOD:route" → handler */
 const routeMap = new Map<string, RouteHandler>([
-	// Source editing
+	// Source editing — manifest-coupled, stays in @nuasite/cms
 	post('update', (body: Parameters<typeof handleUpdate>[0], mw) => handleUpdate(body, mw)),
 	post('insert-component', (body: Parameters<typeof handleInsertComponent>[0], mw) => handleInsertComponent(body, mw)),
 	post('remove-component', (body: Parameters<typeof handleRemoveComponent>[0], mw) => handleRemoveComponent(body, mw)),
 	post('add-array-item', (body: Parameters<typeof handleAddArrayItem>[0], mw) => handleAddArrayItem(body, mw)),
 	post('remove-array-item', (body: Parameters<typeof handleRemoveArrayItem>[0], mw) => handleRemoveArrayItem(body, mw)),
 
-	// Markdown CRUD
-	custom('GET', 'markdown/content', async ({ req, res }) => {
+	// Markdown / entry CRUD — structural, delegated to cms-core
+	custom('GET', 'markdown/content', async ({ req, res, core, contentDir }) => {
 		const filePath = getQuery({ req } as RouteContext).get('filePath')
 		if (!filePath) {
 			sendError(res, 'filePath query parameter required')
 			return
 		}
-		const result = await handleGetMarkdownContent(filePath)
+		const entry = filePathToEntry(contentDir, filePath)
+		const result = entry ? await core.getEntry(entry.collection, entry.slug) : null
 		if (!result) {
 			sendError(res, 'File not found', 404)
 			return
 		}
-		sendJson(res, result)
+		sendJson(res, { content: result.content, frontmatter: result.frontmatter, filePath })
+	}),
+	custom('POST', 'markdown/update', async ({ req, res, core, contentDir }) => {
+		const body = await parseJsonBody<UpdateMarkdownBody>(req)
+		const entry = filePathToEntry(contentDir, body.filePath)
+		if (!entry) {
+			sendJson(res, { success: false, error: `Invalid content path: ${body.filePath}` })
+			return
+		}
+		// cms-core's updateEntry resolves component definitions internally for MDX imports.
+		const result = await core.updateEntry({
+			collection: entry.collection,
+			slug: entry.slug,
+			frontmatter: body.frontmatter,
+			body: body.content,
+		})
+		sendJson(res, { success: result.success, ...(result.error ? { error: result.error } : {}) })
 	}),
-	custom('POST', 'markdown/update', async ({ req, res, manifestWriter }) => {
-		const body = await parseJsonBody<Parameters<typeof handleUpdateMarkdown>[0]>(req)
-		const result = await handleUpdateMarkdown(body, manifestWriter.getComponentDefinitions())
-		sendJson(res, result)
+	custom('POST', 'markdown/rename', async ({ req, res, core, contentDir }) => {
+		const body = await parseJsonBody<RenameMarkdownBody>(req)
+		const entry = filePathToEntry(contentDir, body.filePath)
+		if (!entry) {
+			sendJson(res, { success: false, error: `Invalid content path: ${body.filePath}` })
+			return
+		}
+		const result = await core.renameEntry(entry.collection, entry.slug, body.newSlug)
+		if (!result.success) {
+			sendJson(res, { success: false, error: result.error })
+			return
+		}
+		const newSlug = result.sourcePath ? lastSlug(result.sourcePath) : undefined
+		sendJson(res, { success: true, newFilePath: result.sourcePath, newSlug })
 	}),
-	post('markdown/rename', (body: Parameters<typeof handleRenameMarkdown>[0]) => handleRenameMarkdown(body)),
-	custom('POST', 'markdown/create', async ({ req, res, manifestWriter, contentDir }) => {
-		const body = await parseJsonBody<Parameters<typeof handleCreateMarkdown>[0]>(req)
-		const result = await handleCreateMarkdown(body)
+	custom('POST', 'markdown/create', async ({ req, res, core, manifestWriter, contentDir }) => {
+		const body = await parseJsonBody<CreateMarkdownBody>(req)
+		const ext = body.fileExtension ?? 'md'
+		const isData = DATA_EXTENSIONS.has(ext)
+		// Markdown entries get title + an ISO date injected; data entries take frontmatter verbatim.
+		const frontmatter = isData
+			? { ...(body.frontmatter ?? {}) }
+			: { title: body.title, date: new Date().toISOString().split('T')[0]!, ...(body.frontmatter ?? {}) }
+
+		const result = await core.createEntry({
+			collection: body.collection,
+			slug: body.slug || body.title,
+			frontmatter,
+			body: body.content,
+			fileExtension: body.fileExtension,
+		})
+
 		if (result.success) {
 			manifestWriter.setCollectionDefinitions(await scanCollections(contentDir))
 		}
-		sendJson(res, result, result.success ? 200 : 400)
+		const slug = result.sourcePath ? lastSlug(result.sourcePath) : undefined
+		sendJson(
+			res,
+			{
+				success: result.success,
+				...(result.sourcePath ? { filePath: result.sourcePath } : {}),
+				...(slug ? { slug } : {}),
+				...(result.error ? { error: result.error } : {}),
+			},
+			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(/^\//, '') ?? '')
+	custom('POST', 'markdown/delete', async ({ req, res, core, manifestWriter, contentDir }) => {
+		const body = await parseJsonBody<DeleteMarkdownBody>(req)
+		const entry = filePathToEntry(contentDir, body.filePath)
+		if (!entry) {
+			sendJson(res, { success: false, error: `Invalid content path: ${body.filePath}` }, 400)
+			return
+		}
+		const fullPath = path.resolve(getProjectRoot(), body.filePath.replace(/^\//, ''))
 		expectedDeletions.add(fullPath)
-		const result = await handleDeleteMarkdown(body)
+		const result = await core.deleteEntry(entry.collection, entry.slug)
 		if (result.success) {
 			manifestWriter.setCollectionDefinitions(await scanCollections(contentDir))
 		} else {
 			expectedDeletions.delete(fullPath)
 		}
-		sendJson(res, result, result.success ? 200 : 400)
+		sendJson(res, { success: result.success, ...(result.error ? { error: result.error } : {}) }, result.success ? 200 : 400)
 	}),
 
 	// Media
@@ -143,7 +273,7 @@ const routeMap = new Map<string, RouteHandler>([
 	}),
 	custom('GET', 'media/project-images', async (ctx) => {
 		const excludeDir = ctx.mediaAdapter?.staticFiles?.dir
-		const items = await listProjectImages({ excludeDir })
+		const items = await listProjectImages(ctx.fs, { excludeDir })
 		sendJson(ctx.res, { items })
 	}),
 	custom('POST', 'media/upload', async (ctx) => {
@@ -225,24 +355,24 @@ const routeMap = new Map<string, RouteHandler>([
 		sendJson(ctx.res, result, result.success ? 200 : 400)
 	}),
 
-	// Page operations
-	postWithStatus('page/create', (body: Parameters<typeof handleCreatePage>[0]) => handleCreatePage(body)),
-	custom('POST', 'page/duplicate', async ({ req, res }) => {
-		const body = await parseJsonBody<Parameters<typeof handleDuplicatePage>[0]>(req)
-		const result = await handleDuplicatePage(body)
+	// Page operations — structural, delegated to cms-core
+	postCore('page/create', (body: Parameters<CmsCore['createPage']>[0], core) => core.createPage(body)),
+	custom('POST', 'page/duplicate', async ({ req, res, core }) => {
+		const body = await parseJsonBody<DuplicatePageBody>(req)
+		const result = await core.duplicatePage(body)
 		if (result.success && body.createRedirect) {
-			await handleAddRedirect({ source: body.sourcePagePath, destination: result.url!, statusCode: 307 })
+			await core.addRedirect({ source: body.sourcePagePath, destination: result.url!, statusCode: 307 })
 		}
 		sendJson(res, result, result.success ? 200 : 400)
 	}),
-	custom('POST', 'page/delete', async ({ req, res }) => {
-		const body = await parseJsonBody<Parameters<typeof handleDeletePage>[0]>(req)
-		const result = await handleDeletePage(body)
+	custom('POST', 'page/delete', async ({ req, res, core }) => {
+		const body = await parseJsonBody<DeletePageBody>(req)
+		const result = await core.deletePage(body)
 		if (result.success && result.filePath) {
 			expectedDeletions.add(path.resolve(getProjectRoot(), result.filePath))
 		}
 		if (result.success && body.createRedirect && body.redirectTo) {
-			await handleAddRedirect({ source: body.pagePath, destination: body.redirectTo, statusCode: 307 })
+			await core.addRedirect({ source: body.pagePath, destination: body.redirectTo, statusCode: 307 })
 		}
 		sendJson(res, result, result.success ? 200 : 400)
 	}),
@@ -254,18 +384,32 @@ const routeMap = new Map<string, RouteHandler>([
 		}
 		sendJson(ctx.res, await handleCheckSlugExists(slug))
 	}),
-	get('page/layouts', async () => ({ layouts: await handleGetLayouts() })),
+	getCore('page/layouts', async (core) => ({ layouts: await core.getLayouts() })),
 
-	// Redirects
-	get('redirects', () => handleGetRedirects()),
-	postWithStatus('redirects/add', (body: Parameters<typeof handleAddRedirect>[0]) => handleAddRedirect(body)),
-	postWithStatus('redirects/update', (body: Parameters<typeof handleUpdateRedirect>[0]) => handleUpdateRedirect(body)),
-	postWithStatus('redirects/delete', (body: Parameters<typeof handleDeleteRedirect>[0]) => handleDeleteRedirect(body)),
+	// Redirects — structural, delegated to cms-core
+	getCore('redirects', (core) => core.listRedirects()),
+	postCore('redirects/add', (body: Parameters<CmsCore['addRedirect']>[0], core) => core.addRedirect(body)),
+	postCore('redirects/update', (body: Parameters<CmsCore['updateRedirect']>[0], core) => core.updateRedirect(body)),
+	postCore('redirects/delete', (body: Parameters<CmsCore['deleteRedirect']>[0], core) => core.deleteRedirect(body)),
 
 	// Deployment
 	get('deployment/status', async () => ({ currentDeployment: null, pendingCount: 0, deploymentEnabled: false })),
 ])
 
+/** GET route returning a fixed/static payload (no cms-core needed). */
+function get(route: string, handler: () => Promise<unknown>): [string, RouteHandler] {
+	return [`GET:${route}`, async ({ res }) => {
+		sendJson(res, await handler())
+	}]
+}
+
+/** Last path segment of a root-relative source path, with the extension and a trailing `/index` stripped. */
+function lastSlug(sourcePath: string): string {
+	const withoutExt = sourcePath.replace(/\.(md|mdx|json|yaml|yml)$/, '').replace(/\/index$/, '')
+	const slash = withoutExt.lastIndexOf('/')
+	return slash >= 0 ? withoutExt.slice(slash + 1) : withoutExt
+}
+
 export async function handleCmsApiRoute(ctx: RouteContext): Promise<void> {
 	const { req, res, route } = ctx
 

package/src/handlers/page-ops.ts

@@ -1,103 +1,12 @@
 import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getProjectRoot } from '../config'
-import type { CreatePageRequest, DeletePageRequest, DuplicatePageRequest, LayoutInfo, PageOperationResponse } from '../types'
-import { escapeHtml, isNodeError, resolveAndValidatePath, slugify } from '../utils'
+import { resolveAndValidatePath, slugify } from '../utils'
 
 const PAGE_EXTENSIONS = ['.astro', '.md', '.mdx']
 
-export async function handleCreatePage(request: CreatePageRequest): Promise<PageOperationResponse> {
-	const { title, slug } = request
-	const normalizedSlug = slugify(slug || title)
-
-	if (!normalizedSlug) {
-		return { success: false, error: 'Could not generate a valid slug from the provided title/slug' }
-	}
-
-	const filePath = `src/pages/${normalizedSlug}.astro`
-	const fullPath = resolveAndValidatePath(filePath)
-
-	const layoutImport = await resolveLayoutImport(request.layoutPath)
-	const content = generatePageContent(title, layoutImport)
-
-	try {
-		await fs.mkdir(path.dirname(fullPath), { recursive: true })
-		// 'wx' flag atomically fails if file exists — no pre-check needed
-		await fs.writeFile(fullPath, content, { encoding: 'utf-8', flag: 'wx' })
-
-		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
-		return { success: true, filePath, slug: normalizedSlug, url }
-	} catch (error) {
-		if (isNodeError(error, 'EEXIST')) {
-			return { success: false, error: `Page already exists: ${filePath}` }
-		}
-		return { success: false, error: errorMessage(error) }
-	}
-}
-
-export async function handleDuplicatePage(request: DuplicatePageRequest): Promise<PageOperationResponse> {
-	const { sourcePagePath, slug, title } = request
-	const normalizedSlug = slugify(slug)
-
-	if (!normalizedSlug) {
-		return { success: false, error: 'Could not generate a valid slug' }
-	}
-
-	const sourceFile = await findPageFile(sourcePagePath)
-	if (!sourceFile) {
-		return { success: false, error: `Source page not found: ${sourcePagePath}` }
-	}
-
-	let content: string
-	try {
-		content = await fs.readFile(resolveAndValidatePath(sourceFile), 'utf-8')
-	} catch {
-		return { success: false, error: `Could not read source file: ${sourceFile}` }
-	}
-
-	if (title) {
-		content = replacePageTitle(content, title)
-	}
-
-	const newFilePath = `src/pages/${normalizedSlug}.astro`
-	const newFullPath = resolveAndValidatePath(newFilePath)
-
-	try {
-		await fs.mkdir(path.dirname(newFullPath), { recursive: true })
-		await fs.writeFile(newFullPath, content, { encoding: 'utf-8', flag: 'wx' })
-
-		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
-		return { success: true, filePath: newFilePath, slug: normalizedSlug, url }
-	} catch (error) {
-		if (isNodeError(error, 'EEXIST')) {
-			return { success: false, error: `Page already exists: ${newFilePath}` }
-		}
-		return { success: false, error: errorMessage(error) }
-	}
-}
-
-export async function handleDeletePage(request: DeletePageRequest): Promise<PageOperationResponse> {
-	const { pagePath } = request
-
-	const pageFile = await findPageFile(pagePath)
-	if (!pageFile) {
-		return { success: false, error: `Page not found: ${pagePath}` }
-	}
-
-	try {
-		// No pre-check — just unlink and handle ENOENT
-		await fs.unlink(resolveAndValidatePath(pageFile))
-		return { success: true, filePath: pageFile, url: pagePath }
-	} catch (error) {
-		if (isNodeError(error, 'ENOENT')) {
-			return { success: false, error: `File not found: ${pageFile}` }
-		}
-		return { success: false, error: errorMessage(error) }
-	}
-}
-
 /**
- * Reuses findPageFile to check whether a slug is already taken.
+ * Check whether a page slug is already taken. Page create/duplicate/delete and
+ * layout listing now live in `@nuasite/cms-core`; this slug check stays here
+ * because it is not part of the cms-core structural interface.
  */
 export async function handleCheckSlugExists(slug: string): Promise<{ exists: boolean; filePath?: string }> {
 	const normalizedSlug = slugify(slug)
@@ -107,35 +16,8 @@ export async function handleCheckSlugExists(slug: string): Promise<{ exists: boo
 	return found ? { exists: true, filePath: found } : { exists: false }
 }
 
-export async function handleGetLayouts(): Promise<LayoutInfo[]> {
-	const layoutsDir = path.join(getProjectRoot(), 'src', 'layouts')
-
-	let entries
-	try {
-		entries = await fs.readdir(layoutsDir, { withFileTypes: true })
-	} catch {
-		return []
-	}
-
-	const layouts: LayoutInfo[] = []
-	for (const entry of entries) {
-		if (entry.isFile() && entry.name.endsWith('.astro')) {
-			layouts.push({
-				name: path.basename(entry.name, '.astro'),
-				path: `src/layouts/${entry.name}`,
-			})
-		}
-	}
-
-	return layouts.sort((a, b) => a.name.localeCompare(b.name))
-}
-
 // --- Internal helpers ---
 
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error)
-}
-
 async function fileExists(fullPath: string): Promise<boolean> {
 	try {
 		await fs.access(fullPath)
@@ -160,70 +42,3 @@ async function findPageFile(pagePath: string): Promise<string | null> {
 
 	return null
 }
-
-async function resolveLayoutImport(layoutPath?: string): Promise<{ importPath: string; componentName: string } | null> {
-	if (layoutPath) {
-		const name = path.basename(layoutPath, '.astro')
-		const importPath = `../${layoutPath.replace(/^src\//, '')}`
-		return { importPath, componentName: pascalCase(name) }
-	}
-
-	const layouts = await handleGetLayouts()
-	if (layouts.length === 0) return null
-
-	const layout = layouts[0]!
-	const importPath = `../${layout.path.replace(/^src\//, '')}`
-	return { importPath, componentName: pascalCase(layout.name) }
-}
-
-function pascalCase(name: string): string {
-	return name.replace(/(^|[-_])(\w)/g, (_, _sep, char) => char.toUpperCase())
-}
-
-function generatePageContent(
-	title: string,
-	layoutImport: { importPath: string; componentName: string } | null,
-): string {
-	const escapedTitle = title.replace(/'/g, "\\'").replace(/`/g, '\\`')
-	const htmlTitle = escapeHtml(title)
-
-	if (layoutImport) {
-		const { importPath, componentName } = layoutImport
-		return `---
-import ${componentName} from '${importPath}'
----
-
-<${componentName} title="${escapedTitle}" description="">
-\t<main>
-\t\t<h1>${htmlTitle}</h1>
-\t</main>
-</${componentName}>
-`
-	}
-
-	return `---
-
----
-
-<html lang="en">
-\t<head>
-\t\t<meta charset="utf-8" />
-\t\t<meta name="viewport" content="width=device-width" />
-\t\t<title>${escapedTitle}</title>
-\t</head>
-\t<body>
-\t\t<main>
-\t\t\t<h1>${htmlTitle}</h1>
-\t\t</main>
-\t</body>
-</html>
-`
-}
-
-function replacePageTitle(content: string, newTitle: string): string {
-	let result = content
-	result = result.replace(/(title\s*=\s*")([^"]*)(")/, `$1${newTitle}$3`)
-	result = result.replace(/(<title>)([^<]*)(<\/title>)/, `$1${newTitle}$3`)
-	result = result.replace(/(<h1[^>]*>)([^<]*)(<\/h1>)/, `$1${escapeHtml(newTitle)}$3`)
-	return result
-}

package/src/index.ts

@@ -4,6 +4,7 @@ import fs from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
+import { createLocalStorageAdapter } from '@nuasite/cms-core'
 import { processBuildOutput } from './build-processor'
 import { scanCollections } from './collection-scanner'
 import { ComponentRegistry } from './component-registry'
@@ -11,7 +12,6 @@ import { resetProjectRoot } from './config'
 import { createDevMiddleware } from './dev-middleware'
 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'
@@ -391,11 +391,16 @@ async function mergeRedirects(dir: URL, logger: { info: (msg: string) => void })
 	logger.info(`Merged ${lineCount} CMS redirect(s) into _redirects`)
 }
 
+// Shared structural contract from @nuasite/cms-types — surfaced through the cms public API
+// so consumers of @nuasite/cms get the field-type list + guard from one place.
+export {
+	createContemberStorageAdapter as contemberMedia,
+	createLocalStorageAdapter as localMedia,
+	createS3StorageAdapter as s3Media,
+} from '@nuasite/cms-core'
+export { FIELD_TYPES, isFieldType } from '@nuasite/cms-types'
 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'
 export type { MediaFolderItem, MediaItem, MediaListOptions, MediaListResult, MediaStorageAdapter, MediaTypeFilter } from './media/types'
 export type { Color, Date, DateTime, Email, Image, Reference, Textarea, Time, Url } from './prop-types'