@velastack/cms 0.1.0

package/dist/srv/mock-adapter.d.ts

@@ -0,0 +1,96 @@
+import { type Tree } from '../components/cms/path.ts';
+import type { CmsAdapter, CmsAdapterTombstone } from './types.ts';
+/**
+ * One page-kind entry: a specific (`routeId`, `params`) pair and its
+ * currently-published content. `routeId` is the SvelteKit route id (e.g.
+ * `/(marketing)/rooms/[slug]`); `params` is the bound values for that route's
+ * owned params (e.g. `{ slug: 'suite-1' }`). For static page routes (no owned
+ * params) `params` is `{}` and there's exactly one entry per route id.
+ *
+ * Pending edits live in releases (see `_store.ts`), not on the entry — saving
+ * a draft adds an item to the editor's open release rather than mutating the
+ * published content here.
+ *
+ * `tombstone`, when set, marks this entry as a published tombstone — the page
+ * was deleted with a non-404 outcome in a prior release. `published` is still
+ * required (for `findPageEntry` symmetry) but is ignored when `tombstone` is
+ * set; `fetchDocs` returns the tombstone instead of the doc.
+ */
+export type PageEntry = {
+    params: Record<string, string>;
+    published: Record<string, unknown>;
+    tombstone?: CmsAdapterTombstone;
+};
+/**
+ * One pending change in an open release, snapshot for adapter overlay. Items
+ * with `kind: 'page'` carry `params`; layout items don't (layouts have no
+ * owned params). `kind: 'page-delete'` signals a staged page removal — in
+ * preview, the adapter emits the staged `outcome` (gone / redirect) when set,
+ * and otherwise suppresses the page so it appears removed (404 after publish).
+ * The `tree` is a partial tree that deep-merges over the published content.
+ *
+ * Each item carries its `locale`. A release in flight typically holds items
+ * across all locales the editor has touched; the adapter filters by the
+ * request's `locale` so only matching items overlay.
+ */
+export type ReleaseItemSnapshot = {
+    kind: 'page';
+    routeId: string;
+    params: Record<string, string>;
+    locale: string;
+    tree: Tree;
+} | {
+    kind: 'layout';
+    routeId: string;
+    locale: string;
+    tree: Tree;
+} | {
+    kind: 'page-delete';
+    routeId: string;
+    params: Record<string, string>;
+    locale: string;
+    outcome?: CmsAdapterTombstone;
+};
+export type ReleaseSnapshot = {
+    id: string;
+    items: ReleaseItemSnapshot[];
+};
+export type MockAdapterOptions = {
+    /**
+     * Layout docs keyed by `[locale][routeId]` (e.g. `en['/']`,
+     * `en['/(marketing)']`). Layouts have no owned params, so the inner
+     * `routeId` alone identifies a layout doc per locale.
+     */
+    layoutDocs?: Record<string, Record<string, Record<string, unknown>>>;
+    /**
+     * Page docs keyed by `[locale][routeId]`, with one `PageEntry` per
+     * (`params`) combination per locale. Stores only currently-published
+     * content; missing-locale fallback to the default locale happens in
+     * `resolveCmsPayload`, not here.
+     */
+    pageDocs?: Record<string, Record<string, PageEntry[]>>;
+    /**
+     * Look up an open release by its preview key. Called when a request
+     * carries `?preview=…` so adapter results overlay the matching release's
+     * pending edits onto published content.
+     */
+    resolvePreview?: (previewKey: string) => ReleaseSnapshot | null | undefined;
+};
+/** Match a `PageEntry` whose `params` map equals the requested params. */
+export declare const findPageEntry: (entries: PageEntry[] | undefined, params: Record<string, string>) => PageEntry | undefined;
+/**
+ * In-memory {@link CmsAdapter} useful for tests, demos, and local development
+ * before a real backend is wired up.
+ *
+ * Layout queries are looked up by `[locale][routeId]`; page queries by
+ * `[locale][routeId]` + exact `params` map. When `context.previewKey` is set
+ * and matches an open release (via `resolvePreview`), pending edits in that
+ * release whose `locale` matches the query's `locale` overlay the published
+ * content for any matching scope. Without a preview key, queries always
+ * return the published content for the requested locale.
+ *
+ * Default-locale fallback (when a value is missing in the requested locale)
+ * is handled by `resolveCmsPayload`, not here — the adapter only returns
+ * what's stored for the requested locale.
+ */
+export declare const mockAdapter: (options?: MockAdapterOptions) => CmsAdapter;

package/dist/srv/mock-adapter.js

@@ -0,0 +1,171 @@
+import { mergeTree } from "../components/cms/path.js";
+/** Match a `PageEntry` whose `params` map equals the requested params. */
+export const findPageEntry = (entries, params) => {
+    if (!entries)
+        return undefined;
+    const keys = Object.keys(params);
+    for (const entry of entries) {
+        const entryKeys = Object.keys(entry.params);
+        if (entryKeys.length !== keys.length)
+            continue;
+        let match = true;
+        for (const k of keys) {
+            if (entry.params[k] !== params[k]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return entry;
+    }
+    return undefined;
+};
+const paramsEqual = (a, b) => {
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length)
+        return false;
+    for (const k of aKeys)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+};
+const findReleaseItem = (snapshot, q) => {
+    for (const item of snapshot.items) {
+        if (item.locale !== q.locale)
+            continue;
+        if (q.kind === 'layout') {
+            if (item.kind === 'layout' && item.routeId === q.routeId)
+                return item;
+        }
+        else {
+            if (item.kind === 'layout')
+                continue;
+            if (item.routeId === q.routeId && paramsEqual(item.params, q.params)) {
+                return item;
+            }
+        }
+    }
+    return undefined;
+};
+const findPageDelete = (snapshot, routeId, params, locale) => {
+    for (const item of snapshot.items) {
+        if (item.kind !== 'page-delete')
+            continue;
+        if (item.locale !== locale)
+            continue;
+        if (item.routeId === routeId && paramsEqual(item.params, params))
+            return item;
+    }
+    return undefined;
+};
+const applyOverlay = (base, item) => mergeTree(base ?? {}, item.tree);
+/**
+ * In-memory {@link CmsAdapter} useful for tests, demos, and local development
+ * before a real backend is wired up.
+ *
+ * Layout queries are looked up by `[locale][routeId]`; page queries by
+ * `[locale][routeId]` + exact `params` map. When `context.previewKey` is set
+ * and matches an open release (via `resolvePreview`), pending edits in that
+ * release whose `locale` matches the query's `locale` overlay the published
+ * content for any matching scope. Without a preview key, queries always
+ * return the published content for the requested locale.
+ *
+ * Default-locale fallback (when a value is missing in the requested locale)
+ * is handled by `resolveCmsPayload`, not here — the adapter only returns
+ * what's stored for the requested locale.
+ */
+export const mockAdapter = (options = {}) => {
+    const layoutDocs = options.layoutDocs ?? {};
+    const pageDocs = options.pageDocs ?? {};
+    const resolvePreview = options.resolvePreview;
+    return {
+        fetchDocs(queries, context) {
+            const previewKey = context.previewKey;
+            const release = previewKey && resolvePreview ? resolvePreview(previewKey) : null;
+            const out = {};
+            for (const q of queries) {
+                let base;
+                let baseTombstone;
+                if (q.kind === 'page') {
+                    const entry = findPageEntry(pageDocs[q.locale]?.[q.routeId], q.params);
+                    base = entry?.published;
+                    baseTombstone = entry?.tombstone;
+                }
+                else {
+                    base = layoutDocs[q.locale]?.[q.routeId];
+                }
+                const pageDelete = release && q.kind === 'page'
+                    ? findPageDelete(release, q.routeId, q.params, q.locale)
+                    : undefined;
+                if (pageDelete) {
+                    if (pageDelete.outcome)
+                        out[q.scopeId] = pageDelete.outcome;
+                    // No outcome → suppress (404 in production after publish).
+                    continue;
+                }
+                const overlayItem = release ? findReleaseItem(release, q) : undefined;
+                if (overlayItem && overlayItem.kind !== 'page-delete') {
+                    out[q.scopeId] = { contents: applyOverlay(base, overlayItem) };
+                }
+                else if (baseTombstone) {
+                    out[q.scopeId] = baseTombstone;
+                }
+                else if (base) {
+                    out[q.scopeId] = { contents: base };
+                }
+            }
+            return out;
+        },
+        fetchEntries(routeId, context) {
+            const locale = context.locale;
+            const entries = pageDocs[locale]?.[routeId];
+            const previewKey = context.previewKey;
+            const release = previewKey && resolvePreview ? resolvePreview(previewKey) : null;
+            const out = [];
+            const metaOf = (tree) => {
+                const m = tree?.metadata;
+                return m && typeof m === 'object' && !Array.isArray(m)
+                    ? m
+                    : {};
+            };
+            const tombstoneFlags = (t) => t.kind === 'redirect' ? { redirectTo: t.to } : { gone: true };
+            for (const e of entries ?? []) {
+                if (release) {
+                    const pageDelete = findPageDelete(release, routeId, e.params, locale);
+                    if (pageDelete) {
+                        if (pageDelete.outcome) {
+                            out.push({
+                                params: { ...e.params },
+                                metadata: metaOf(e.published),
+                                ...tombstoneFlags(pageDelete.outcome)
+                            });
+                        }
+                        // No outcome → drop from preview list (hard-delete in flight).
+                        continue;
+                    }
+                }
+                if (e.tombstone) {
+                    out.push({
+                        params: { ...e.params },
+                        metadata: metaOf(e.published),
+                        ...tombstoneFlags(e.tombstone)
+                    });
+                    continue;
+                }
+                out.push({ params: { ...e.params }, metadata: metaOf(e.published) });
+            }
+            if (release) {
+                for (const item of release.items) {
+                    if (item.kind !== 'page' || item.routeId !== routeId)
+                        continue;
+                    if (item.locale !== locale)
+                        continue;
+                    if (findPageEntry(entries, item.params))
+                        continue;
+                    out.push({ params: { ...item.params }, metadata: metaOf(item.tree) });
+                }
+            }
+            return out;
+        }
+    };
+};

package/dist/srv/types.d.ts

@@ -0,0 +1,114 @@
+import type { CmsEntry, CmsScopeEntry, SiteSchema } from '../components/cms/scope.ts';
+export type { CmsEntry, SiteSchema };
+/**
+ * One scope's request, expanded from the build-time manifest with the locale
+ * and any owned param values from the current SvelteKit request. Adapters
+ * receive arrays of these and translate them into backend reads.
+ */
+export type CmsScopeQuery = CmsScopeEntry & {
+    locale: string;
+};
+/**
+ * One resolved document from an adapter. `contents` is the doc's tree —
+ * lodash-style paths walk into nested branches. Page-kind docs own a
+ * `metadata` branch that `loadCms` aliases as `cms.metadata`.
+ */
+export type CmsAdapterDoc = {
+    contents: Record<string, unknown>;
+};
+/**
+ * Tombstone for a page-kind scope: the page was deleted but the URL still
+ * resolves with non-404 semantics. `kind: 'gone'` means the page is
+ * deliberately permanently removed (HTTP 410); `kind: 'redirect'` means the
+ * page was replaced with a permanent redirect to `to` (HTTP 308). Layout
+ * scopes never resolve to a tombstone — only page-kind scopes do.
+ */
+export type CmsAdapterTombstone = {
+    kind: 'gone';
+} | {
+    kind: 'redirect';
+    to: string;
+};
+/**
+ * One resolution from an adapter for a single scope query: either the doc's
+ * tree (`CmsAdapterDoc`) or a tombstone signaling the page was deleted with
+ * a non-404 outcome. Discriminator: presence of `kind` on the value.
+ */
+export type CmsAdapterResolution = CmsAdapterDoc | CmsAdapterTombstone;
+/**
+ * Per-request context handed to adapter methods alongside their queries.
+ * `fetch` is the SvelteKit request-scoped fetch, suitable for HTTP-backed
+ * adapters that need cookie forwarding during SSR. `previewKey`, when set,
+ * is the value of `?preview=…` from the request URL — adapters that support
+ * release previews use it to overlay an open release's pending edits onto
+ * published content. `versionKey`, when set, is the value of `?version=…` —
+ * adapters resolve it to a past published release and return that release's
+ * snapshot. Mutually exclusive with `previewKey`; when both are present
+ * `versionKey` wins.
+ *
+ * `locale` is the BCP-47 string bound at `loadCms(event, { locale })` time;
+ * `locales` is the full supported set from `createCms({ locales })`. The
+ * first entry of `locales` is the default locale used for read-time
+ * fallback. Adapters use `locale` to scope reads (`fetchEntries` doesn't
+ * take queries, so it relies on this); `fetchDocs` also gets per-query
+ * `locale` on each `CmsScopeQuery`.
+ */
+export type CmsAdapterContext = {
+    fetch: typeof fetch;
+    previewKey?: string | null;
+    versionKey?: string | null;
+    locale: string;
+    locales: string[];
+};
+/**
+ * Backend-agnostic adapter. Implementations connect Vela CMS to a backing
+ * store (PocketBase, a flat-file mock, an in-memory table, …) and decide how
+ * scope queries map to documents.
+ *
+ * `fetchDocs` is called once per request with every applicable scope. May be
+ * sync or async. Page-kind docs own a `metadata` branch on their tree;
+ * `loadCms` aliases it as `cms.metadata` for the request without removing it
+ * from the doc — components can address `metadata.title` like any other path.
+ */
+export interface CmsAdapter {
+    /**
+     * URL prefix the frontend uses for client-side admin-bar fetches and that
+     * gets surfaced in `CmsPayload.endpoint`. HTTP-backed adapters set this to
+     * their base URL (e.g. `https://cms.example/v1/projects/p1/cms`); adapters
+     * with no remote (`mockAdapter`) leave it unset and the loader falls back
+     * to `'/api/cms'`.
+     */
+    readonly endpoint?: string;
+    /**
+     * Resolve documents for every scope in `queries`. The result map is keyed
+     * by `query.scopeId`; missing entries are treated as "no document yet"
+     * and components fall back to their authored `fallback`. Adapters
+     * disambiguate page-kind documents using `routeId` + `params` from the
+     * query, never a pre-composed scope-key string. When `context.previewKey`
+     * is set, adapters that support release previews overlay the matching
+     * open release's pending field edits on top of published content before
+     * returning.
+     *
+     * Page-kind scopes may resolve to a {@link CmsAdapterTombstone} instead of
+     * a {@link CmsAdapterDoc} when the page has been deleted with a non-404
+     * outcome (gone / redirect). The resolver short-circuits the page render
+     * for tombstoned scopes; layout-kind scopes never tombstone.
+     */
+    fetchDocs(queries: CmsScopeQuery[], context: CmsAdapterContext): Promise<Record<string, CmsAdapterResolution>> | Record<string, CmsAdapterResolution>;
+    /**
+     * Enumerate the publishable entries the adapter has at a given
+     * `routeId`. Each entry carries its bound owned `params` (for SvelteKit's
+     * prerender `entries()`) plus the doc's `metadata` branch (for index pages
+     * that render a list with titles).
+     */
+    fetchEntries(routeId: string, context: CmsAdapterContext): Promise<CmsEntry[]> | CmsEntry[];
+    /**
+     * Resolve the project-wide site tree (branding, contact, social, …).
+     * Always one tree per project — no locale, no params. Preview-overlay
+     * support is identical to `fetchDocs`: when `context.previewKey` is set,
+     * adapters merge the open release's site item on top of the published
+     * tree. Optional — adapters that don't carry site state may omit this and
+     * the loader treats the project as having an empty site tree.
+     */
+    fetchSite?(context: CmsAdapterContext): Promise<Record<string, unknown>> | Record<string, unknown>;
+}

package/dist/srv/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,116 @@
+{
+	"name": "@velastack/cms",
+	"version": "0.1.0",
+	"description": "A scope-aware CMS for SvelteKit, for static or dynamic sites.",
+	"keywords": [
+		"svelte",
+		"sveltekit",
+		"cms",
+		"content",
+		"editing",
+		"vite-plugin",
+		"velastack"
+	],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/velastack/cms.git"
+	},
+	"homepage": "https://github.com/velastack/cms#readme",
+	"bugs": {
+		"url": "https://github.com/velastack/cms/issues"
+	},
+	"type": "module",
+	"engines": {
+		"node": "^20.19.0 || >=22.12.0"
+	},
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run prepack",
+		"preview": "vite preview",
+		"prepare": "svelte-kit sync || echo ''",
+		"prepack": "svelte-kit sync && svelte-package && node scripts/build-plugin.js && node scripts/build-admin-bar-css.js && publint",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"lint": "prettier --check .",
+		"format": "prettier --write .",
+		"test:unit": "vitest",
+		"test": "npm run test:unit -- --run"
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*",
+		"plugin/dist",
+		"!plugin/dist/**/*.test.*",
+		"README.md",
+		"LICENSE"
+	],
+	"sideEffects": [
+		"**/*.css"
+	],
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./srv": {
+			"types": "./dist/srv/index.d.ts",
+			"default": "./dist/srv/index.js"
+		},
+		"./vite": {
+			"types": "./plugin/dist/index.d.ts",
+			"default": "./plugin/dist/index.js"
+		},
+		"./adapter": {
+			"types": "./plugin/dist/adapter.d.ts",
+			"default": "./plugin/dist/adapter.js"
+		}
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": "^2.0.0",
+		"marked": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0",
+		"svelte": "^5.0.0",
+		"vite": "^8.0.0"
+	},
+	"peerDependenciesMeta": {
+		"marked": {
+			"optional": true
+		}
+	},
+	"devDependencies": {
+		"@internationalized/date": "^3.12.3",
+		"@sveltejs/adapter-auto": "^7.0.1",
+		"@sveltejs/kit": "^2.70.3",
+		"@sveltejs/package": "^2.5.8",
+		"@sveltejs/vite-plugin-svelte": "^7.3.0",
+		"@tailwindcss/cli": "^4.3.3",
+		"@tailwindcss/vite": "^4.3.3",
+		"@types/node": "^26.4.0",
+		"marked": "^18.0.11",
+		"prettier": "^3.9.6",
+		"prettier-plugin-svelte": "^4.1.1",
+		"publint": "^0.3.24",
+		"svelte": "^5.57.0",
+		"svelte-check": "^4.7.6",
+		"svelte-meta-tags": "^5.0.2",
+		"tailwindcss": "^4.3.3",
+		"tw-animate-css": "^1.4.0",
+		"typescript": "^6.0.3",
+		"vite": "^8.2.2",
+		"vitest": "^4.1.11"
+	},
+	"dependencies": {
+		"@sveltejs/adapter-static": "^3.0.10",
+		"@tiptap/core": "^3.30.6",
+		"@tiptap/extension-link": "^3.30.6",
+		"@tiptap/pm": "^3.30.6",
+		"@tiptap/starter-kit": "^3.30.6",
+		"bits-ui": "^2.19.0",
+		"devalue": "^5.9.2",
+		"tailwind-merge": "^3.6.0"
+	}
+}

package/plugin/README.md

@@ -0,0 +1,137 @@
+# `@velastack/cms/vite` — Vite plugin
+
+Build-time companion to [`@velastack/cms`](../README.md). Walks SvelteKit's `src/routes`
+tree, scans every route file's static Svelte import graph, and exposes the
+result as virtual modules that the runtime CMS components and AdminBar consume.
+Also auto-injects two small bits of glue so authors don't repeat themselves at
+every route.
+
+## Install
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { sveltekit } from '@sveltejs/kit/vite';
+import { cms } from '@velastack/cms/vite';
+
+export default defineConfig({
+	plugins: [cms(), sveltekit()]
+});
+```
+
+`cms()` should be registered **before** `sveltekit()`. The plugin sets
+`enforce: 'pre'` so its `transform` hook runs before vite-plugin-svelte
+compiles the route file.
+
+## Options
+
+```ts
+type CmsPluginOptions = {
+	routesDir?: string; // default: 'src/routes' (relative to vite root)
+	libDir?: string; // default: 'src/lib'
+	components?: ExternalCmsComponentSpec[];
+	traverse?: (string | RegExp)[];
+};
+
+type ExternalCmsComponentSpec =
+	| { source: string; names: string[] } // bare specifier with named CMS exports
+	| { source: string; default: true }; // bare specifier whose default export is a CMS component
+```
+
+- `routesDir` / `libDir` — only override if your project diverges from the
+  SvelteKit defaults.
+- `components` — third-party CMS component packs the walker should recognize.
+  Auto-discovered for everything inside `<libDir>/components/cms/` and the
+  `@velastack/cms` package itself; use this for components installed from npm.
+- `traverse` — bare specifiers whose `.svelte` files contain CMS usages but
+  aren't themselves CMS components (wrapper packages). Strings match
+  `source === pattern || source.startsWith(pattern + '/')`. Auto-populated with
+  every `components[].source`.
+
+## Virtual modules
+
+### `virtual:vela-cms/manifest`
+
+```ts
+import { cmsManifest } from 'virtual:vela-cms/manifest';
+
+type CmsManifest = {
+	version: 1;
+	routes: Record<string, { scopes: CmsManifestScope[] }>;
+};
+
+type CmsManifestScope = {
+	scopeId: string; // 'layout:/(marketing)' or 'page:/(marketing)/rooms/[slug]'
+	kind: 'layout' | 'page';
+	routeId: string; // route the scope is rooted at
+	ownedParams: string[]; // params introduced at this scope (deduped up-chain)
+	fields: string[]; // CMS field names referenced anywhere in the scope
+	metadata?: string[]; // page-only — editable metadata field names
+};
+```
+
+One entry per route id whose chain ends in a `+page.svelte`. Each entry's
+`scopes` array goes from root layout → leaf page; layouts that contribute
+nothing are still included. `loadCms` consumes this map at request time.
+
+### `virtual:vela-cms/pages`
+
+```ts
+import { pages } from 'virtual:vela-cms/pages';
+// pages: Record<string, { routeId: string; /* …user definePage(...) config */ }>
+```
+
+Aggregates every `page.cms.ts` next to a `+page.svelte` (one per route).
+Each entry is the `definePage(...)` config plus the auto-injected `routeId`.
+The AdminBar reads this to know what's editable per page.
+
+## Auto-injection
+
+### Scope install in route `.svelte` files
+
+For every `+layout.svelte` and `+page.svelte` whose route appears in the
+manifest, the plugin prepends an `installCmsScope({...})` call into the
+instance script (or creates one if absent). Authors never write
+`setContext(CMS_SCOPE, ...)` manually.
+
+### `routeId` into zero-arg `generateEntries()` calls
+
+In any `+page.ts` or `+page.server.ts` that imports `generateEntries` (from
+anywhere — typically `$lib/cms.ts`), zero-argument calls
+`generateEntries()` are rewritten to `generateEntries('<routeId>')`. Calls
+with any explicit argument are left alone — that's the documented opt-out.
+
+## What gets walked
+
+For each route entrypoint (`+page.svelte` or `+layout.svelte`), the plugin
+parses with `svelte/compiler` and follows static imports of `.svelte` files.
+Imports get classified as CMS components by:
+
+1. **In-tree barrel** — anything from `<libDir>/components/cms/index.{ts,js}`.
+   Named imports are CMS components; default isn't.
+2. **In-tree files** — `.svelte` files directly under `<libDir>/components/cms/`.
+   Default imports are CMS components.
+3. **`@velastack/cms` package** — any import resolving inside the `@velastack/cms`
+   package itself (named exports, plus `.svelte` default imports).
+4. **External `components` spec** — user-declared packs.
+
+Component usages with a `name=<static>` prop are recorded as field
+references; `value=<…>` opts the call out (it's a runtime override, not a
+field). Dynamic `name={expr}` props are ignored.
+
+## HMR
+
+The plugin invalidates `virtual:vela-cms/manifest` and
+`virtual:vela-cms/pages` (plus the per-`page.cms.ts` synthetic ids) when:
+
+- a `.svelte` file already in the visited graph changes, or
+- any file in `routesDir/` changes (route added/removed), or
+- a `+page.ts` / `+page.server.ts` / `page.cms.ts` changes.
+
+The walker re-runs lazily on the next `load` of the virtual module.
+
+## Stability
+
+Pre-1.0. The `CmsManifest` shape is part of the public surface; the
+synthetic `page-cms-N` ids and the install-call code template are
+internal implementation details and may change.

package/plugin/dist/adapter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Wraps `@sveltejs/adapter-static`. After the inner adapter writes prerendered
+ * pages, scans `builder.routes` for parameterized routes and emits a
+ * `__fallback.json` next to each parent URL directory. The fallback is built
+ * from a real prerendered `__data.json` for that route, with `cms.metadata`
+ * and `cms.docs[pageScope]` cleared and every `params[name]` replaced by
+ * `%name%`. The runtime can fetch the fallback when navigating to a CMS page
+ * that wasn't prerendered, then substitute the actual params client-side.
+ *
+ * @param {StaticAdapterOptions} [options]
+ */
+export default function adapter(options?: StaticAdapterOptions): {
+    name: string;
+    /** @param {import('@sveltejs/kit').Builder} builder */
+    adapt(builder: import("@sveltejs/kit").Builder): Promise<void>;
+};
+export function parseRouteSegments(routeId: string): ParsedSegment[];
+export function buildParamExtractor(segments: ParsedSegment[]): ((url: string) => Record<string, string> | null) | null;
+export type StaticAdapterOptions = Parameters<typeof staticAdapter>[0];
+export type ParsedSegment = {
+    kind: "static";
+    value: string;
+} | {
+    kind: "dynamic";
+    name: string;
+} | {
+    kind: "rest";
+    name: string;
+} | {
+    kind: "optional";
+    name: string;
+} | {
+    kind: "unsupported";
+};
+import staticAdapter from '@sveltejs/adapter-static';