@minamocms/framework 0.0.0-stage → 0.10.2

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 { 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, relativePath) {
+    try {
+        const { bytes } = readContentFile(contentRoot, join('pages', 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.
+// Exported for site-check/run-check.ts's own reuse - it needs the
+// identical "every published page's own URL" walk this route already
+// does, and duplicating it would be the exact kind of drift this
+// codebase avoids elsewhere (see slugify.ts's own "second use
+// justifies the abstraction" precedent, cited directly in this
+// project's own admin sibling repo).
+export 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/guide-content-authoring.md), not real content.
+        if (relativePath === '404.json') {
+            continue;
+        }
+        if (isPublished(config.contentRoot, relativePath)) {
+            urls.push(pagePathToUrl(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 { SiteConfig } from '../config.ts';
+import type { ThemeState } from '../theme-state.ts';
+import type { TokenEntry } from '../server-config.ts';
+export interface ThemeRouteOptions {
+    config: SiteConfig;
+    theme: ThemeState;
+    tokens: TokenEntry[];
+}
+export declare const themeRoutes: FastifyPluginAsync<ThemeRouteOptions>;

package/dist/routes/theme.js

@@ -0,0 +1,116 @@
+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 { isValidThemePath, listThemeFiles, pushTheme, readThemeFile, ThemePushError, } from "../services/theme-files.js";
+import { requireScope } from "../services/token-auth.js";
+// A whole theme in one request, fonts and images included, sent as
+// base64 - far past Fastify's 1 MB default, so this route sets its own.
+const THEME_PUSH_BODY_LIMIT = 100 * 1024 * 1024;
+function parseThemePushBody(body) {
+    if (typeof body !== 'object' || body === null) {
+        return null;
+    }
+    const { writes, deletes, message, author } = body;
+    if (!Array.isArray(writes) || !Array.isArray(deletes) || typeof message !== 'string' || message === '') {
+        return null;
+    }
+    if (!isValidCommitAuthor(author)) {
+        return null;
+    }
+    const parsedWrites = [];
+    for (const raw of writes) {
+        const { path, content, expected } = (raw ?? {});
+        if (typeof path !== 'string' || typeof content !== 'string' || (expected !== null && typeof expected !== 'string')) {
+            return null;
+        }
+        parsedWrites.push({ path, bytes: Buffer.from(content, 'base64'), expected });
+    }
+    const parsedDeletes = [];
+    for (const raw of deletes) {
+        const { path, expected } = (raw ?? {});
+        if (typeof path !== 'string' || typeof expected !== 'string') {
+            return null;
+        }
+        parsedDeletes.push({ path, expected });
+    }
+    if (parsedWrites.length === 0 && parsedDeletes.length === 0) {
+        return null;
+    }
+    return { writes: parsedWrites, deletes: parsedDeletes, message, author };
+}
+async function handleThemePush(request, reply, opts) {
+    const parsed = parseThemePushBody(request.body);
+    if (!parsed) {
+        reply.code(400).send({
+            statusCode: 400,
+            error: 'Bad Request',
+            message: 'Expected { writes: { path, content (base64), expected (hash or null) }[], deletes: { path, expected }[], message, author: { name, email } }, with at least one write or delete',
+        });
+        return;
+    }
+    try {
+        const result = await pushTheme(opts.config, opts.theme, parsed.writes, parsed.deletes, parsed.message, parsed.author);
+        reply.send({ ok: true, ...result });
+    }
+    catch (error) {
+        if (error instanceof PathSafetyError || (error instanceof ThemePushError && error.reason === 'invalid-path')) {
+            reply.code(400).send({ statusCode: 400, error: 'Bad Request', message: error.message });
+            return;
+        }
+        if (error instanceof ThemePushError && error.reason === 'invalid-liquid') {
+            reply.code(400).send({ statusCode: 400, error: 'Bad Request', message: error.message });
+            return;
+        }
+        if (error instanceof ThemePushError && error.reason === 'conflict') {
+            reply.code(409).send({ statusCode: 409, error: 'Conflict', message: error.message });
+            return;
+        }
+        throw error;
+    }
+}
+// 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.theme.current.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.theme.current.pageTemplates }));
+    // The theme's own files, for npm run pull / push. All three need the
+    // "theme" scope: a token that can only edit content can't read or
+    // change the site's code.
+    fastify.get('/theme/files', { preHandler: requireScope(opts.tokens, 'theme') }, async () => listThemeFiles(opts.config));
+    fastify.get('/theme/files/*', { preHandler: requireScope(opts.tokens, 'theme') }, async (request, reply) => {
+        const path = request.params['*'];
+        let bytes = null;
+        try {
+            bytes = isValidThemePath(path) ? readThemeFile(opts.config, path) : null;
+        }
+        catch (error) {
+            if (!(error instanceof PathSafetyError)) {
+                throw error;
+            }
+        }
+        if (bytes === null) {
+            reply.code(404).send({ statusCode: 404, error: 'Not Found', message: `No theme file at "${path}"` });
+            return;
+        }
+        reply.type('application/octet-stream').send(bytes);
+    });
+    // Writes and deletes theme files as one commit, then switches the
+    // running site to the new theme with no restart. Refused (409) if any
+    // file changed on the site since the client last saw it, and (400) if
+    // any Liquid template can't be parsed.
+    fastify.post('/theme/push', {
+        preHandler: requireScope(opts.tokens, 'theme'),
+        config: WRITE_ROUTE_RATE_LIMIT,
+        bodyLimit: THEME_PUSH_BODY_LIMIT,
+    }, async (request, reply) => handleThemePush(request, reply, opts));
+};

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,24 @@
+{
+  "$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 },
+    "name": { "type": "string", "minLength": 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,26 @@
+{
+  "$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" },
+    "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,7 @@
+import type { SearchDriver } from './driver.ts';
+export declare const DRIVER_NAME = "node:sqlite";
+export interface OpenDriverOptions {
+    readOnly?: boolean;
+    timeout?: number;
+}
+export declare function openNodeSqliteDriver(path: string, options?: OpenDriverOptions): SearchDriver;

package/dist/search/drivers/node-sqlite-driver.js

@@ -0,0 +1,19 @@
+import { DatabaseSync } from 'node:sqlite';
+// A plain string constant, not the raw node:sqlite import itself - safe
+// for the capabilities endpoint (Phase 2 Group A) to import without
+// tripping the G5 grep test, and avoids hardcoding this name a second
+// time as a literal that could drift from the actual active driver.
+export const DRIVER_NAME = 'node:sqlite';
+// The only file in the codebase allowed to import node:sqlite
+// (checklist G5, enforced by a grep test in
+// test/static/static-analysis.test.ts). DatabaseSync's own
+// prepare()/exec()/close() already structurally match SearchDriver,
+// so this is a thin adapter, not a reimplementation.
+export function openNodeSqliteDriver(path, options = {}) {
+    const db = new DatabaseSync(path, options);
+    return {
+        exec: (sql) => db.exec(sql),
+        prepare: (sql) => db.prepare(sql),
+        close: () => db.close(),
+    };
+}

package/dist/search/query-content.d.ts

@@ -0,0 +1,32 @@
+export type FieldOp = 'eq' | 'gt' | 'gte' | 'lt' | 'lte';
+export interface FieldFilter {
+    field: string;
+    op: FieldOp;
+    value: string;
+}
+export interface SortParam {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface SearchParams {
+    q?: string;
+    pageType?: string;
+    filters: FieldFilter[];
+    sort?: SortParam;
+    limit: number;
+    offset: number;
+}
+export type FieldValue = string | number | boolean;
+export interface SearchResultItem {
+    url: string;
+    title: string;
+    pageType: string;
+    fields: Record<string, FieldValue | FieldValue[]>;
+}
+export interface SearchResponse {
+    results: SearchResultItem[];
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+export declare function queryContent(searchIndexPath: string, params: SearchParams): SearchResponse;

package/dist/search/query-content.js

@@ -0,0 +1,207 @@
+import { existsSync } from 'node:fs';
+import { openNodeSqliteDriver } from "./drivers/node-sqlite-driver.js";
+function toFiniteNumber(raw) {
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+const COMPARATORS = {
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+};
+// Never passes raw user input straight into FTS5 MATCH - a public
+// search box gets real, messy input (unbalanced quotes, a lone
+// trailing "-", a word FTS5 treats as an operator like "AND" or "NOT")
+// which throws a syntax error against a bare MATCH ? (the previous
+// query-index.ts never guarded this at all). Each whitespace-separated
+// token becomes its own quoted, prefix-matched literal - "hello world"
+// becomes "hello"* AND "world"*, embedded quotes doubled per FTS5's own
+// escaping rule - so the constructed expression can never be
+// misinterpreted as an operator, regardless of what the user typed.
+function buildMatchExpression(q) {
+    const tokens = q
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        return undefined;
+    }
+    return tokens.map((token) => `"${token.replace(/"/g, '""')}"*`).join(' AND ');
+}
+// One INNER JOIN per filter - a page must satisfy every filter to
+// appear at all, so a page missing that field entirely (or with a
+// non-matching value) is correctly excluded, not just left with a
+// null comparison. Same typed-column branch logic query-fields.ts
+// (now retired) already proved out for a single filter.
+function buildFilterJoin(alias, filter) {
+    const args = [filter.field];
+    if (filter.op === 'eq') {
+        const branches = [`${alias}.value_text = ?`];
+        args.push(filter.value);
+        const numeric = toFiniteNumber(filter.value);
+        if (numeric !== undefined) {
+            branches.push(`${alias}.value_number = ?`);
+            args.push(numeric);
+        }
+        if (filter.value === 'true' || filter.value === 'false') {
+            branches.push(`${alias}.value_bool = ?`);
+            args.push(filter.value === 'true' ? 1 : 0);
+        }
+        return {
+            sql: `JOIN page_fields ${alias} ON ${alias}.url = f.url AND ${alias}.field_key = ? AND (${branches.join(' OR ')})`,
+            args,
+        };
+    }
+    const numeric = toFiniteNumber(filter.value);
+    if (numeric === undefined) {
+        // The route validates a numeric op against a numeric value before
+        // ever calling in - reaching here regardless just means "nothing
+        // could possibly match", not an error this layer needs to raise.
+        return { sql: `JOIN page_fields ${alias} ON ${alias}.url = f.url AND ${alias}.field_key = ? AND 1 = 0`, args };
+    }
+    args.push(numeric);
+    return {
+        sql: `JOIN page_fields ${alias} ON ${alias}.url = f.url AND ${alias}.field_key = ? AND ${alias}.value_number ${COMPARATORS[filter.op]} ?`,
+        args,
+    };
+}
+// LEFT, not INNER - unlike a filter, sorting by a field a given page
+// doesn't have shouldn't drop that page from the results, just leave
+// it ordered with a null value (SQLite sorts NULL first in ASC order).
+// COALESCE across both typed columns since this layer has no schema in
+// hand at query time to know in advance which one a given field
+// actually uses.
+function buildSortJoin(field) {
+    return {
+        sql: 'LEFT JOIN page_fields sort_field ON sort_field.url = f.url AND sort_field.field_key = ?',
+        args: [field],
+        column: 'COALESCE(sort_field.value_number, sort_field.value_text)',
+    };
+}
+function fieldRowValue(row) {
+    if (row.value_text !== null) {
+        return row.value_text;
+    }
+    if (row.value_number !== null) {
+        return row.value_number;
+    }
+    if (row.value_bool !== null) {
+        return row.value_bool === 1;
+    }
+    return undefined;
+}
+// The one query surface a front-end talks to directly - covers a
+// blog listing (pageType + sort by publishDate + pagination), a
+// product grid (several ANDed filters + sort by a numeric field), and
+// general site search (q), rather than three narrow endpoints each
+// covering one of those. Two queries total, never N+1: one for the
+// (already paginated) matching urls, one gathering every indexed
+// field for just that page of urls to build each result's own
+// "fields" map - a product grid needs price to render, not just to
+// have matched.
+export function queryContent(searchIndexPath, params) {
+    // readOnly: true (below) throws if the file doesn't exist rather
+    // than silently auto-creating an empty one the way a normal open
+    // would - checked here instead, so "no rebuild has ever run yet" (a
+    // real, expected state for a brand new site) reads as an empty
+    // result set, not a 500.
+    if (!existsSync(searchIndexPath)) {
+        return { results: [], limit: params.limit, offset: params.offset, hasMore: false };
+    }
+    const driver = openNodeSqliteDriver(searchIndexPath, { readOnly: true, timeout: 2000 });
+    try {
+        const joins = [];
+        const joinArgs = [];
+        params.filters.forEach((filter, index) => {
+            const built = buildFilterJoin(`pf${index}`, filter);
+            joins.push(built.sql);
+            joinArgs.push(...built.args);
+        });
+        const where = [];
+        const whereArgs = [];
+        const matchExpression = params.q ? buildMatchExpression(params.q) : undefined;
+        if (matchExpression) {
+            // FTS5's own "tbl MATCH expr" special syntax only recognises the
+            // real table name here, not an alias (confirmed live - "f MATCH
+            // ?" throws "no such column: f" even though ordinary column
+            // references through the same alias work fine everywhere else in
+            // this query).
+            where.push('pages_fts MATCH ?');
+            whereArgs.push(matchExpression);
+        }
+        if (params.pageType !== undefined) {
+            where.push('f.page_type = ?');
+            whereArgs.push(params.pageType);
+        }
+        let orderJoin = '';
+        const orderJoinArgs = [];
+        let orderBy = 'f.url ASC';
+        if (params.sort) {
+            const built = buildSortJoin(params.sort.field);
+            orderJoin = built.sql;
+            orderJoinArgs.push(...built.args);
+            orderBy = `${built.column} ${params.sort.direction === 'desc' ? 'DESC' : 'ASC'}`;
+        }
+        else if (matchExpression) {
+            // FTS5's own bm25-derived rank: more negative is more relevant,
+            // so plain ascending order is "best match first".
+            orderBy = 'rank';
+        }
+        const sql = [
+            'SELECT DISTINCT f.url, f.title, f.page_type',
+            'FROM pages_fts f',
+            ...joins,
+            orderJoin,
+            where.length > 0 ? `WHERE ${where.join(' AND ')}` : '',
+            `ORDER BY ${orderBy}`,
+            'LIMIT ? OFFSET ?',
+        ]
+            .filter((part) => part !== '')
+            .join(' ');
+        // Request one extra row to know whether there's a next page,
+        // rather than a separate COUNT(*) query - a real, doubled cost on
+        // every single paginated request neither stated use case (infinite
+        // scroll, a grid's own "next" button) actually needs an exact
+        // total for.
+        const args = [...joinArgs, ...orderJoinArgs, ...whereArgs, params.limit + 1, params.offset];
+        const mainRows = driver.prepare(sql).all(...args);
+        const hasMore = mainRows.length > params.limit;
+        const pageRows = mainRows.slice(0, params.limit);
+        const fieldsByUrl = new Map();
+        if (pageRows.length > 0) {
+            const placeholders = pageRows.map(() => '?').join(', ');
+            const fieldRows = driver
+                .prepare(`SELECT url, field_key, value_text, value_number, value_bool FROM page_fields WHERE url IN (${placeholders})`)
+                .all(...pageRows.map((row) => row.url));
+            for (const row of fieldRows) {
+                const value = fieldRowValue(row);
+                if (value === undefined) {
+                    continue;
+                }
+                const entry = fieldsByUrl.get(row.url) ?? {};
+                const existing = entry[row.field_key];
+                if (existing === undefined) {
+                    entry[row.field_key] = value;
+                }
+                else if (Array.isArray(existing)) {
+                    existing.push(value);
+                }
+                else {
+                    entry[row.field_key] = [existing, value];
+                }
+                fieldsByUrl.set(row.url, entry);
+            }
+        }
+        const results = pageRows.map((row) => ({
+            url: row.url,
+            title: row.title,
+            pageType: row.page_type,
+            fields: fieldsByUrl.get(row.url) ?? {},
+        }));
+        return { results, limit: params.limit, offset: params.offset, hasMore };
+    }
+    finally {
+        driver.close();
+    }
+}

package/dist/search/query-index.d.ts

@@ -0,0 +1,5 @@
+export interface SearchResult {
+    url: string;
+    title: string;
+}
+export declare function queryIndex(searchIndexPath: string, term: string): SearchResult[];

package/dist/search/query-index.js

@@ -0,0 +1,21 @@
+import { openNodeSqliteDriver } from "./drivers/node-sqlite-driver.js";
+// Never queued: an in-flight query holding an open handle during a
+// concurrent rebuild's unlink just keeps reading the pre-rebuild inode
+// (stale but consistent, never torn) - queuing a read against the same
+// queue as writes would only add latency for no correctness benefit.
+export function queryIndex(searchIndexPath, term) {
+    const driver = openNodeSqliteDriver(searchIndexPath);
+    try {
+        const rows = driver.prepare('SELECT url, title FROM pages_fts WHERE pages_fts MATCH ?').all(term);
+        // node:sqlite returns rows as [Object: null prototype] instances;
+        // rebuilt here as plain objects so callers (and assert.deepEqual)
+        // never have to know that's a driver implementation detail.
+        return rows.map((row) => {
+            const { url, title } = row;
+            return { url, title };
+        });
+    }
+    finally {
+        driver.close();
+    }
+}

package/dist/search/rebuild-index.d.ts

@@ -0,0 +1,3 @@
+import type { SiteConfig } from '../config.ts';
+export declare function rebuildIndex(config: SiteConfig): Promise<void>;
+export declare function rebuildIndexIfMissing(config: SiteConfig): Promise<void>;