@o-a/cms-agent 0.1.0

package/dist/routes/public.js

@@ -0,0 +1,117 @@
+import { join } from 'node:path';
+import { PageRenderError, renderPage } from "../renderer/render-page.js";
+import { PathSafetyError } from "../services/path-safety.js";
+import { isBlogUrl } from "../services/post-urls.js";
+import { resolveBlogUrl } from "../services/resolve-blog-url.js";
+import { resolveUrl } from "../services/resolve-url.js";
+import { findStaticFile, sendStaticFile } from "../services/static-file.js";
+// resolveUrl's relativePath is relative to pagesRoot (e.g. "about.json"),
+// but renderPage's relativePath is relative to contentRoot/draftsRoot
+// directly (e.g. "pages/about.json") - two already-correct modules with
+// two different conventions for the same string. This is the seam
+// between them, not an arbitrary literal.
+function toRenderPath(pagesRelativePath) {
+    return join('pages', pagesRelativePath);
+}
+// Same seam as toRenderPath above, for posts: resolveBlogUrl's
+// relativePath is relative to postsRoot, renderPage's is relative to
+// contentRoot/draftsRoot directly.
+function toPostsRenderPath(postsRelativePath) {
+    return join('posts', postsRelativePath);
+}
+// A themed 404: content/pages/404.json, if it exists and is published,
+// is rendered through the ordinary public renderPage pipeline (layout +
+// sections + blocks, same as any other page) - no special-casing in
+// render-page.ts itself, no separate "is this the 404 page" concept.
+// The HTTP status is always 404 regardless, even though the body is a
+// full HTML page. Any failure at all while attempting this - no
+// 404.json, it's unpublished, or its own theme is broken - falls back
+// to today's plain JSON error rather than ever turning a 404 into a
+// 500 for a visitor who was already looking at a missing page.
+async function sendNotFound(reply, config, themeTemplates, layouts, engine, url) {
+    try {
+        const html = await renderPage(config, themeTemplates, layouts, engine, toRenderPath('404.json'), 'public');
+        reply.code(404).type('text/html; charset=utf-8').send(html);
+    }
+    catch {
+        reply.code(404).send({ statusCode: 404, error: 'Not Found', message: `No page at "${url}"` });
+    }
+}
+async function handlePublicRequest(request, reply, config, themeTemplates, layouts, engine) {
+    // The public catch-all is registered without a /v1 prefix alongside
+    // v1Routes (which has its own exact/prefixed routes). Fastify's
+    // router already prefers exact matches over this wildcard regardless
+    // of registration order, but an *unmatched* /v1/* path would
+    // otherwise fall through to here and get treated as a page lookup
+    // instead of Fastify's real 404 - this guard is what actually keeps
+    // A4 true for any future typo'd or removed /v1/* route, not
+    // registration order.
+    if (request.url === '/v1' || request.url.startsWith('/v1/')) {
+        return reply.callNotFound();
+    }
+    // theme/root/ mirrors arbitrary bare paths (robots.txt, .well-known/*)
+    // at the site root, checked before page resolution - unlike /assets/
+    // or /media/, these aren't distinguishable by a fixed prefix, so
+    // Fastify's own "specific route beats /*" behaviour can't do this for
+    // us automatically. A miss (including the bare "/" itself - a
+    // directory, never a file) falls straight through to the existing
+    // page-lookup logic below, unchanged.
+    const rootMirrorMatch = findStaticFile(config.rootMirrorRoot, request.params['*']);
+    if (rootMirrorMatch) {
+        sendStaticFile(reply, rootMirrorMatch);
+        return;
+    }
+    const url = `/${request.params['*']}`;
+    try {
+        // /blog is a permanently reserved namespace (confirmed design
+        // decision): checked first, and never falls through to page
+        // resolution even on a miss - a page manually placed at
+        // content/pages/blog/x.json is deliberately unreachable.
+        if (isBlogUrl(url)) {
+            const resolved = resolveBlogUrl(config, url);
+            if (resolved.kind === 'not-found') {
+                await sendNotFound(reply, config, themeTemplates, layouts, engine, url);
+                return;
+            }
+            if (resolved.kind === 'redirect') {
+                reply.code(301).header('location', resolved.to).send();
+                return;
+            }
+            const html = await renderPage(config, themeTemplates, layouts, engine, toPostsRenderPath(resolved.relativePath), 'public');
+            reply.type('text/html; charset=utf-8').send(html);
+            return;
+        }
+        const resolved = resolveUrl(config, url);
+        if (resolved.kind === 'not-found') {
+            await sendNotFound(reply, config, themeTemplates, layouts, engine, url);
+            return;
+        }
+        if (resolved.kind === 'redirect') {
+            reply.code(301).header('location', resolved.to).send();
+            return;
+        }
+        const html = await renderPage(config, themeTemplates, layouts, engine, toRenderPath(resolved.relativePath), 'public');
+        reply.type('text/html; charset=utf-8').send(html);
+    }
+    catch (error) {
+        // A traversal attempt and an ordinary miss get the identical 404 -
+        // deliberately not 400, so a public, unauthenticated route never
+        // gives an attacker a signal that distinguishes the two.
+        if (error instanceof PathSafetyError) {
+            await sendNotFound(reply, config, themeTemplates, layouts, engine, url);
+            return;
+        }
+        if (error instanceof PageRenderError && error.reason === 'page-not-found') {
+            await sendNotFound(reply, config, themeTemplates, layouts, engine, url);
+            return;
+        }
+        // Any other PageRenderError reason (missing-section-type,
+        // missing-block-type, template-error) is a broken theme/content
+        // problem, not something to explain to a public visitor - rethrow
+        // and let the global error handler sanitise it as a 500 (A5).
+        throw error;
+    }
+}
+export const publicRoutes = async (fastify, opts) => {
+    fastify.get('/*', async (request, reply) => handlePublicRequest(request, reply, opts.config, opts.themeTemplates, opts.layouts, opts.engine));
+};

package/dist/routes/publish.d.ts

@@ -0,0 +1,10 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { SiteConfig } from '../config.ts';
+import type { ThemeSchemas } from '../services/validation.ts';
+import type { TokenEntry } from '../server-config.ts';
+export interface PublishRouteOptions {
+    config: SiteConfig;
+    themeSchemas: ThemeSchemas;
+    tokens: TokenEntry[];
+}
+export declare const publishRoutes: FastifyPluginAsync<PublishRouteOptions>;

package/dist/routes/publish.js

@@ -0,0 +1,105 @@
+import { isValidCommitAuthor } from "../services/git.js";
+import { PathSafetyError } from "../services/path-safety.js";
+import { WRITE_ROUTE_RATE_LIMIT } from "../services/rate-limit-config.js";
+import { PublishError, publishDrafts, unpublishPage } from "../services/publish.js";
+import { requireScope } from "../services/token-auth.js";
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function parsePublishBody(body) {
+    if (typeof body !== 'object' || body === null) {
+        return null;
+    }
+    const { paths, message, author } = body;
+    if (!Array.isArray(paths) || paths.length === 0 || !paths.every(isNonEmptyString)) {
+        return null;
+    }
+    if (!isNonEmptyString(message) || !isValidCommitAuthor(author)) {
+        return null;
+    }
+    return { paths, message, author };
+}
+function parseUnpublishBody(body) {
+    if (typeof body !== 'object' || body === null) {
+        return null;
+    }
+    const { message, author } = body;
+    if (!isNonEmptyString(message) || !isValidCommitAuthor(author)) {
+        return null;
+    }
+    return { message, author };
+}
+// Shared by both handlers below: each only ever sees the subset of
+// reasons its own service function can actually throw.
+function replyForPublishError(reply, error) {
+    if (error.reason === 'validation-failed' || error.reason === 'duplicate-path') {
+        reply.code(400).send({ statusCode: 400, error: 'Bad Request', message: error.message });
+        return;
+    }
+    if (error.reason === 'draft-not-found' || error.reason === 'page-not-found') {
+        reply.code(404).send({ statusCode: 404, error: 'Not Found', message: error.message });
+        return;
+    }
+    throw error;
+}
+export const publishRoutes = async (fastify, opts) => {
+    fastify.post('/publish', { preHandler: requireScope(opts.tokens, 'content'), config: WRITE_ROUTE_RATE_LIMIT }, async (request, reply) => {
+        const parsed = parsePublishBody(request.body);
+        if (!parsed) {
+            reply.code(400).send({
+                statusCode: 400,
+                error: 'Bad Request',
+                message: 'Expected { paths: string[], message: string, author: { name, email } }',
+            });
+            return;
+        }
+        try {
+            await publishDrafts(opts.config, opts.themeSchemas, parsed.paths, parsed.message, parsed.author);
+            reply.send({ ok: true });
+        }
+        catch (error) {
+            // PathSafetyError has no .statusCode - left uncaught it falls
+            // through to the global handler's sanitised 500, the same gap
+            // every other route touching a :path already guards against.
+            if (error instanceof PathSafetyError) {
+                reply.code(404).send({ statusCode: 404, error: 'Not Found', message: 'No content at that path' });
+                return;
+            }
+            if (error instanceof PublishError) {
+                replyForPublishError(reply, error);
+                return;
+            }
+            throw error;
+        }
+    });
+    fastify.post('/unpublish/*', { preHandler: requireScope(opts.tokens, 'content'), config: WRITE_ROUTE_RATE_LIMIT }, async (request, reply) => {
+        const parsed = parseUnpublishBody(request.body);
+        if (!parsed) {
+            reply.code(400).send({
+                statusCode: 400,
+                error: 'Bad Request',
+                message: 'Expected { message: string, author: { name, email } }',
+            });
+            return;
+        }
+        const relativePath = request.params['*'];
+        try {
+            await unpublishPage(opts.config, relativePath, parsed.message, parsed.author);
+            reply.send({ ok: true });
+        }
+        catch (error) {
+            // PathSafetyError has no .statusCode - left uncaught it falls
+            // through to the global handler's sanitised 500, the same gap
+            // every other route touching a :path already guards against.
+            if (error instanceof PathSafetyError) {
+                reply.code(404).send({ statusCode: 404, error: 'Not Found', message: 'No content at that path' });
+                return;
+            }
+            if (error instanceof PublishError) {
+                replyForPublishError(reply, error);
+                return;
+            }
+            throw error;
+        }
+    });
+};

package/dist/routes/redirects.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { SiteConfig } from '../config.ts';
+import type { TokenEntry } from '../server-config.ts';
+export interface RedirectsRouteOptions {
+    config: SiteConfig;
+    tokens: TokenEntry[];
+}
+export declare const redirectsRoutes: FastifyPluginAsync<RedirectsRouteOptions>;

package/dist/routes/redirects.js

@@ -0,0 +1,132 @@
+import { isValidCommitAuthor } from "../services/git.js";
+import { ManageRedirectError, createRedirect, deleteRedirect, updateRedirect } from "../services/manage-redirects.js";
+import { loadRedirects } from "../services/redirects.js";
+import { WRITE_ROUTE_RATE_LIMIT } from "../services/rate-limit-config.js";
+import { requireScope } from "../services/token-auth.js";
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function parseUpsertRedirectBody(body) {
+    if (typeof body !== 'object' || body === null) {
+        return null;
+    }
+    const { from, to, note, message, author } = body;
+    if (!isNonEmptyString(from) || !isNonEmptyString(to)) {
+        return null;
+    }
+    if (note !== undefined && typeof note !== 'string') {
+        return null;
+    }
+    if (!isNonEmptyString(message) || !isValidCommitAuthor(author)) {
+        return null;
+    }
+    return { from, to, note, message, author };
+}
+function parseDeleteRedirectBody(body) {
+    if (typeof body !== 'object' || body === null) {
+        return null;
+    }
+    const { from, message, author } = body;
+    if (!isNonEmptyString(from) || !isNonEmptyString(message) || !isValidCommitAuthor(author)) {
+        return null;
+    }
+    return { from, message, author };
+}
+function sendManageRedirectError(reply, error) {
+    if (error.reason === 'invalid-from' || error.reason === 'invalid-target' || error.reason === 'redirect-cycle') {
+        reply.code(400).send({ statusCode: 400, error: 'Bad Request', message: error.message });
+        return;
+    }
+    if (error.reason === 'not-found') {
+        reply.code(404).send({ statusCode: 404, error: 'Not Found', message: error.message });
+        return;
+    }
+    if (error.reason === 'already-exists' || error.reason === 'live-content-exists') {
+        reply.code(409).send({ statusCode: 409, error: 'Conflict', message: error.message });
+        return;
+    }
+    throw error;
+}
+async function handleListRedirects(_request, reply, config) {
+    reply.send(loadRedirects(config));
+}
+async function handleCreateRedirect(request, reply, config) {
+    const parsed = parseUpsertRedirectBody(request.body);
+    if (!parsed) {
+        reply.code(400).send({
+            statusCode: 400,
+            error: 'Bad Request',
+            message: 'Expected { from: string, to: string, note?: string, message: string, author: { name, email } }',
+        });
+        return;
+    }
+    try {
+        const result = await createRedirect(config, parsed.from, parsed.to, parsed.note, parsed.message, parsed.author);
+        reply.send(result);
+    }
+    catch (error) {
+        if (error instanceof ManageRedirectError) {
+            sendManageRedirectError(reply, error);
+            return;
+        }
+        throw error;
+    }
+}
+async function handleUpdateRedirect(request, reply, config) {
+    const parsed = parseUpsertRedirectBody(request.body);
+    if (!parsed) {
+        reply.code(400).send({
+            statusCode: 400,
+            error: 'Bad Request',
+            message: 'Expected { from: string, to: string, note?: string, message: string, author: { name, email } }',
+        });
+        return;
+    }
+    try {
+        const result = await updateRedirect(config, parsed.from, parsed.to, parsed.note, parsed.message, parsed.author);
+        reply.send(result);
+    }
+    catch (error) {
+        if (error instanceof ManageRedirectError) {
+            sendManageRedirectError(reply, error);
+            return;
+        }
+        throw error;
+    }
+}
+async function handleDeleteRedirect(request, reply, config) {
+    const parsed = parseDeleteRedirectBody(request.body);
+    if (!parsed) {
+        reply.code(400).send({
+            statusCode: 400,
+            error: 'Bad Request',
+            message: 'Expected { from: string, message: string, author: { name, email } }',
+        });
+        return;
+    }
+    try {
+        await deleteRedirect(config, parsed.from, parsed.message, parsed.author);
+        reply.code(204).send();
+    }
+    catch (error) {
+        if (error instanceof ManageRedirectError) {
+            sendManageRedirectError(reply, error);
+            return;
+        }
+        throw error;
+    }
+}
+// from/to are always taken from the JSON body, never a URL path
+// segment: they are arbitrary public URLs that may contain slashes,
+// and critically none of these operations address a filesystem path
+// at all (this mutates one entry inside redirects.json, not a file at
+// a client-supplied path) - sanitisePath/path-traversal simply doesn't
+// apply here, matching POST /content/move's existing body-carries-the-
+// identity precedent rather than forcing an arbitrary URL into a route
+// segment.
+export const redirectsRoutes = async (fastify, opts) => {
+    fastify.get('/redirects', { preHandler: requireScope(opts.tokens, 'content') }, async (request, reply) => handleListRedirects(request, reply, opts.config));
+    fastify.post('/redirects', { preHandler: requireScope(opts.tokens, 'content'), config: WRITE_ROUTE_RATE_LIMIT }, async (request, reply) => handleCreateRedirect(request, reply, opts.config));
+    fastify.put('/redirects', { preHandler: requireScope(opts.tokens, 'content'), config: WRITE_ROUTE_RATE_LIMIT }, async (request, reply) => handleUpdateRedirect(request, reply, opts.config));
+    fastify.delete('/redirects', { preHandler: requireScope(opts.tokens, 'content'), config: WRITE_ROUTE_RATE_LIMIT }, async (request, reply) => handleDeleteRedirect(request, reply, opts.config));
+};

package/dist/routes/search.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { SiteConfig } from '../config.ts';
+import type { TokenEntry } from '../server-config.ts';
+export interface SearchRouteOptions {
+    config: SiteConfig;
+    tokens: TokenEntry[];
+}
+export declare const searchRoutes: FastifyPluginAsync<SearchRouteOptions>;

package/dist/routes/search.js

@@ -0,0 +1,11 @@
+import { rebuildIndex } from "../search/rebuild-index.js";
+import { WRITE_ROUTE_RATE_LIMIT } from "../services/rate-limit-config.js";
+import { requireScope } from "../services/token-auth.js";
+export const searchRoutes = async (fastify, opts) => {
+    fastify.post('/search/rebuild', { preHandler: requireScope(opts.tokens, 'content'), config: WRITE_ROUTE_RATE_LIMIT }, async (_request, reply) => {
+        // rebuildIndex is already self-enqueue()d (search/rebuild-index.ts) -
+        // never wrap it in a second enqueue() here, nested calls deadlock.
+        await rebuildIndex(opts.config);
+        reply.send({ ok: true });
+    });
+};

package/dist/routes/sitemap.d.ts

@@ -0,0 +1,6 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { SiteConfig } from '../config.ts';
+export interface SitemapRouteOptions {
+    config: SiteConfig;
+}
+export declare const sitemapRoutes: FastifyPluginAsync<SitemapRouteOptions>;

package/dist/routes/sitemap.js

@@ -0,0 +1,79 @@
+import { join } from 'node:path';
+import { readContentFile } from "../services/content-read.js";
+import { listFilesRecursively } from "../services/fs-walk.js";
+import { postPathToUrl } from "../services/post-urls.js";
+import { pagePathToUrl } from "../services/urls.js";
+// Reads through readContentFile/listFilesRecursively (both already
+// gated behind sanitisePath/agent-configured roots - see their own
+// files) rather than touching fs directly, so this route needs no
+// allowlist entry of its own (docs/phase-1-checklist.md Group B).
+function isPublished(contentRoot, subdir, relativePath) {
+    try {
+        const { bytes } = readContentFile(contentRoot, join(subdir, relativePath));
+        const parsed = JSON.parse(bytes.toString('utf-8'));
+        return parsed.published === true;
+    }
+    catch {
+        // Unreadable, malformed, or vanished between listing and reading -
+        // never worth failing the whole sitemap over one bad entry.
+        return false;
+    }
+}
+// Generated fresh on every request, never a saved file - matches this
+// project's own standing philosophy for exactly this class of problem
+// (the search index is explicitly "a derived, disposable index...
+// never authoritative", see cms-build-plan.md). A saved sitemap would
+// go stale the moment anything is published or unpublished; this
+// can't.
+function buildSitemapUrls(config) {
+    const urls = [];
+    for (const relativePath of listFilesRecursively(config.pagesRoot, config.pagesRoot, '.json')) {
+        // The 404 page must never be listed as a real crawlable URL,
+        // regardless of its own published flag - it's a fallback
+        // convention (docs/content-authoring-guide.md), not real content.
+        if (relativePath === '404.json') {
+            continue;
+        }
+        if (isPublished(config.contentRoot, 'pages', relativePath)) {
+            urls.push(pagePathToUrl(relativePath));
+        }
+    }
+    for (const relativePath of listFilesRecursively(config.postsRoot, config.postsRoot, '.json')) {
+        if (isPublished(config.contentRoot, 'posts', relativePath)) {
+            urls.push(postPathToUrl(relativePath));
+        }
+    }
+    return urls;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+async function handleSitemapRequest(request, reply, config) {
+    // request.protocol/request.host already respect trustProxy (wired
+    // natively into the Fastify() constructor, server.ts) - no separate
+    // config field needed for this. request.host, not request.hostname:
+    // the latter unconditionally strips the port (confirmed against
+    // Fastify's own source), which silently produces a wrong origin for
+    // any site not on a standard 80/443 port - request.host is the raw
+    // Host header (or the trustProxy-forwarded equivalent), port
+    // included when present.
+    const origin = `${request.protocol}://${request.host}`;
+    const urls = buildSitemapUrls(config);
+    const entries = urls.map((url) => `  <url><loc>${escapeXml(origin + url)}</loc></url>`).join('\n');
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${entries}\n</urlset>\n`;
+    reply.type('application/xml; charset=utf-8').send(xml);
+}
+// Deliberately and permanently unauthenticated, same reasoning as
+// assetsRoutes/mediaPublicRoutes: a sitemap must be fetchable by any
+// crawler without a token. This exact path always wins over a
+// same-named static file at theme/root/sitemap.xml, if a developer
+// ever creates one - a dynamic route is a more specific match than
+// the root-mirror check inside publicRoutes' own catch-all.
+export const sitemapRoutes = async (fastify, opts) => {
+    fastify.get('/sitemap.xml', async (request, reply) => handleSitemapRequest(request, reply, opts.config));
+};

package/dist/routes/theme.d.ts

@@ -0,0 +1,10 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { ThemeSchemas } from '../services/validation.ts';
+import type { PageTemplate } from '../services/theme-page-templates.ts';
+import type { TokenEntry } from '../server-config.ts';
+export interface ThemeRouteOptions {
+    themeSchemas: ThemeSchemas;
+    pageTemplates: PageTemplate[];
+    tokens: TokenEntry[];
+}
+export declare const themeRoutes: FastifyPluginAsync<ThemeRouteOptions>;

package/dist/routes/theme.js

@@ -0,0 +1,17 @@
+import { requireScope } from "../services/token-auth.js";
+// Group I: the only place a caller can learn what section/block types
+// the active theme supports and what settings each one accepts - the
+// admin needs this to build a schema-driven editing UI instead of a
+// hardcoded one. themeSchemas is already fully computed at boot
+// (loadThemeSchemas) purely for internal write-time validation; this
+// route just serialises the same object out, verbatim, read-only.
+export const themeRoutes = async (fastify, opts) => {
+    fastify.get('/theme/schemas', { preHandler: requireScope(opts.tokens, 'content') }, async () => opts.themeSchemas);
+    // Group Q: lets the admin offer a template picker when creating a new
+    // page. No dedicated "create from template" endpoint - pageTemplates
+    // is already fully computed at boot (loadPageTemplates), same
+    // verbatim read-only serialisation as /theme/schemas above; actually
+    // creating a page from one is just the admin doing a normal
+    // PUT /v1/drafts/* with the chosen template's own content as the body.
+    fastify.get('/theme/page-templates', { preHandler: requireScope(opts.tokens, 'content') }, async () => ({ templates: opts.pageTemplates }));
+};

package/dist/schemas/instance.schema.json

@@ -0,0 +1,17 @@
+{
+  "$id": "instance.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Section or block instance",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["id", "type", "settings"],
+  "properties": {
+    "id": { "type": "string", "minLength": 1 },
+    "type": { "type": "string", "minLength": 1, "pattern": "^[a-z0-9][a-z0-9-]*$" },
+    "settings": { "type": "object" },
+    "blocks": {
+      "type": "array",
+      "items": { "$ref": "#" }
+    }
+  }
+}

package/dist/schemas/menu.schema.json

@@ -0,0 +1,23 @@
+{
+  "$id": "menu.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Menu",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "items"],
+  "properties": {
+    "schemaVersion": { "type": "integer", "minimum": 1 },
+    "items": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["label", "url"],
+        "properties": {
+          "label": { "type": "string", "minLength": 1 },
+          "url": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  }
+}

package/dist/schemas/page.schema.json

@@ -0,0 +1,20 @@
+{
+  "$id": "page.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Page",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "name", "title", "type", "layout", "published", "sections"],
+  "properties": {
+    "schemaVersion": { "type": "integer", "minimum": 1 },
+    "name": { "type": "string", "minLength": 1 },
+    "title": { "type": "string", "minLength": 1 },
+    "type": { "type": "string", "minLength": 1 },
+    "layout": { "type": "string", "minLength": 1 },
+    "published": { "type": "boolean" },
+    "sections": {
+      "type": "array",
+      "items": { "$ref": "instance.schema.json" }
+    }
+  }
+}

package/dist/schemas/post.schema.json

@@ -0,0 +1,25 @@
+{
+  "$id": "post.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Post",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "title", "type", "layout", "published", "author", "publishDate", "tags", "sections"],
+  "properties": {
+    "schemaVersion": { "type": "integer", "minimum": 1 },
+    "title": { "type": "string", "minLength": 1 },
+    "type": { "const": "post" },
+    "layout": { "type": "string", "minLength": 1 },
+    "published": { "type": "boolean" },
+    "author": { "type": "string", "minLength": 1 },
+    "publishDate": { "type": "string", "minLength": 1 },
+    "tags": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "sections": {
+      "type": "array",
+      "items": { "$ref": "instance.schema.json" }
+    }
+  }
+}

package/dist/schemas/redirects.schema.json

@@ -0,0 +1,24 @@
+{
+  "$id": "redirects.schema.json",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Redirects",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "entries"],
+  "properties": {
+    "schemaVersion": { "type": "integer", "minimum": 1 },
+    "entries": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["from", "to"],
+        "properties": {
+          "from": { "type": "string", "minLength": 1 },
+          "to": { "type": "string", "minLength": 1 },
+          "note": { "type": "string", "maxLength": 500 }
+        }
+      }
+    }
+  }
+}

package/dist/search/drivers/driver.d.ts

@@ -0,0 +1,9 @@
+export interface PreparedStatement {
+    run(...params: unknown[]): void;
+    all(...params: unknown[]): unknown[];
+}
+export interface SearchDriver {
+    exec(sql: string): void;
+    prepare(sql: string): PreparedStatement;
+    close(): void;
+}

package/dist/search/drivers/driver.js

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

package/dist/search/drivers/node-sqlite-driver.d.ts

@@ -0,0 +1,3 @@
+import type { SearchDriver } from './driver.ts';
+export declare const DRIVER_NAME = "node:sqlite";
+export declare function openNodeSqliteDriver(path: string): SearchDriver;