@cogenta/schema 0.1.0

package/dist/search/query.d.ts

@@ -0,0 +1,35 @@
+import type { ContentStatus } from '../types.js';
+import type { SearchDocument, SearchQuery, SearchReference, SearchResults } from './types.js';
+export interface NormalisedQuery {
+    readonly tokens: readonly string[];
+    readonly locale: string;
+    readonly status: ContentStatus;
+    readonly collections: readonly string[];
+    readonly size: number;
+    readonly offset: number;
+}
+/**
+ * Validates a query and reduces it to what every engine needs.
+ *
+ * The locale is required rather than defaulted: a default would be a guess
+ * about which language a reader is entitled to, and guessing there is how a
+ * site leaks a half-translated page.
+ */
+export declare function normaliseQuery(query: SearchQuery): NormalisedQuery;
+export declare function assertReference(reference: SearchReference): void;
+/** The document as it is stored: title trimmed, body folded by the caller. */
+export declare function assertDocument(document: SearchDocument): void;
+export declare function storedTitle(document: SearchDocument): string;
+/**
+ * Turns the fetched rows into a page.
+ *
+ * One row more than the page size is always fetched, and its presence is the
+ * answer to "is there a next page" — the same trick the content store uses, and
+ * for the same reason: a second `count(*)` over a full-text match is as
+ * expensive as the search itself.
+ */
+export declare function toResults(rows: readonly Record<string, unknown>[], scoreOf: (row: Record<string, unknown>) => number, normalised: NormalisedQuery): SearchResults;
+/** The answer to a query no engine can match: no terms left after tokenising. */
+export declare const EMPTY_RESULTS: SearchResults;
+export declare function numeric(value: unknown): number;
+//# sourceMappingURL=query.d.ts.map

package/dist/search/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/search/query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,OAAO,KAAK,EACV,cAAc,EAEd,WAAW,EACX,eAAe,EACf,aAAa,EACd,MAAM,YAAY,CAAA;AAiBnB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;IAC9B,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAuBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CA6BlE;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAShE;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAW7D;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAE5D;AAUD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACxC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,EACjD,UAAU,EAAE,eAAe,GAC1B,aAAa,CAkBf;AAED,iFAAiF;AACjF,eAAO,MAAM,aAAa,EAAE,aAA8D,CAAA;AAE1F,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAG9C"}

package/dist/search/query.js

@@ -0,0 +1,116 @@
+import { CogentaError } from '@cogenta/core';
+import { condense, queryTokens } from './text.js';
+/** A page big enough for a result list, small enough that a bad caller cannot
+ * ask the database to rank the whole site. */
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+/**
+ * Past this the ranking is meaningless anyway, and a deep offset makes every
+ * engine sort the whole matching set to throw it away. A search that needs page
+ * five hundred is a report, not a search.
+ */
+const MAX_OFFSET = 1000;
+/** Titles are a label, not a document; a runaway one would bloat every row. */
+const MAX_TITLE_LENGTH = 500;
+function invalid(message, hint, details) {
+    return new CogentaError({ code: 'QUERY_INVALID', message, hint, details });
+}
+function boundedInteger(value, fallback, max, name) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw invalid(`The search ${name} must be a whole number of zero or more, received ${String(value)}.`, 'Pass a plain integer, or leave it out to take the default.', { [name]: value });
+    }
+    return Math.min(value, max);
+}
+/**
+ * Validates a query and reduces it to what every engine needs.
+ *
+ * The locale is required rather than defaulted: a default would be a guess
+ * about which language a reader is entitled to, and guessing there is how a
+ * site leaks a half-translated page.
+ */
+export function normaliseQuery(query) {
+    if (typeof query.locale !== 'string' || query.locale.trim().length === 0) {
+        throw invalid('A search needs a locale.', "Pass the locale the reader is browsing, such as { locale: 'fr' }. Search never spans languages.", { locale: query.locale });
+    }
+    for (const collection of query.collections ?? []) {
+        if (typeof collection !== 'string' || collection.length === 0) {
+            throw invalid('A collection name in a search filter is empty.', 'Pass the names of collections to restrict to, or leave `collections` out to search all of them.', { collections: query.collections });
+        }
+    }
+    return {
+        tokens: queryTokens(query.text ?? ''),
+        locale: query.locale,
+        // The default is the only safe one: a caller that forgets to say gets what
+        // the public may see, never a draft.
+        status: query.status ?? 'published',
+        collections: query.collections ?? [],
+        size: Math.max(1, boundedInteger(query.limit, DEFAULT_LIMIT, MAX_LIMIT, 'limit')),
+        offset: boundedInteger(query.offset, 0, MAX_OFFSET, 'offset'),
+    };
+}
+export function assertReference(reference) {
+    if (reference.id.length === 0 || reference.collection.length === 0) {
+        throw new CogentaError({
+            code: 'CONTENT_INVALID',
+            message: 'A search index reference needs both an entry id and a collection.',
+            hint: 'Pass { id, collection } from the entry being indexed.',
+            details: { reference },
+        });
+    }
+}
+/** The document as it is stored: title trimmed, body folded by the caller. */
+export function assertDocument(document) {
+    assertReference(document);
+    if (document.locale.length === 0) {
+        throw new CogentaError({
+            code: 'CONTENT_INVALID',
+            message: `The entry "${document.id}" has no locale, so it cannot be indexed.`,
+            hint: 'Every entry carries a locale (ADR-0014); index the entry as it was read, not a partial copy.',
+            details: { id: document.id, collection: document.collection },
+        });
+    }
+}
+export function storedTitle(document) {
+    return condense(document.title).slice(0, MAX_TITLE_LENGTH);
+}
+function text(value) {
+    return typeof value === 'string'
+        ? value
+        : value === null || value === undefined
+            ? ''
+            : String(value);
+}
+/**
+ * Turns the fetched rows into a page.
+ *
+ * One row more than the page size is always fetched, and its presence is the
+ * answer to "is there a next page" — the same trick the content store uses, and
+ * for the same reason: a second `count(*)` over a full-text match is as
+ * expensive as the search itself.
+ */
+export function toResults(rows, scoreOf, normalised) {
+    const hasMore = rows.length > normalised.size;
+    const page = rows.slice(0, normalised.size);
+    const hits = page.map((row) => ({
+        id: text(row['entry_id']),
+        collection: text(row['collection']),
+        locale: text(row['locale']),
+        status: text(row['status']),
+        title: text(row['title']),
+        score: scoreOf(row),
+    }));
+    return {
+        hits,
+        hasMore,
+        nextOffset: hasMore ? normalised.offset + normalised.size : null,
+    };
+}
+/** The answer to a query no engine can match: no terms left after tokenising. */
+export const EMPTY_RESULTS = { hits: [], hasMore: false, nextOffset: null };
+export function numeric(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+//# sourceMappingURL=query.js.map

package/dist/search/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/search/query.ts"],"names":[],"mappings":"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"}

package/dist/search/sqlite.d.ts

@@ -0,0 +1,16 @@
+import { type DatabaseHandle } from '@cogenta/core';
+import type { SearchDriver } from './types.js';
+export interface SqliteSearchOptions {
+    readonly db: DatabaseHandle;
+    /**
+     * Whether to use FTS5 when it is available.
+     *
+     * Defaults to true. Setting it to false forces the substring fallback, which
+     * an operator may want on a build whose FTS5 is present but broken — and which
+     * is how the contract suite proves the degraded path still honours the same
+     * guarantees as the optimal one.
+     */
+    readonly fts5?: boolean;
+}
+export declare function createSqliteSearch(options: SqliteSearchOptions): Promise<SearchDriver>;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/search/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/search/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAMpB,MAAM,eAAe,CAAA;AAsBtB,OAAO,KAAK,EAAkB,YAAY,EAAgC,MAAM,YAAY,CAAA;AA8B5F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,cAAc,CAAA;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAmL5F"}

package/dist/search/sqlite.js

@@ -0,0 +1,166 @@
+import { identifier, sql, limit as sqlLimit, } from '@cogenta/core';
+import { joinFragments } from '../store/fragments.js';
+import { assertDocument, assertReference, EMPTY_RESULTS, normaliseQuery, numeric, storedTitle, toResults, } from './query.js';
+import { allOf, baseColumns, primaryKey, SEARCH_COLUMNS, SEARCH_FTS_TABLE, SEARCH_TABLE, scopeFilters, selectedColumns, } from './table.js';
+import { foldText } from './text.js';
+/**
+ * SQLite full-text search: FTS5 when the runtime has it, `LIKE` when it does not.
+ *
+ * FTS5 is a compile-time option. `node:sqlite` ships with it enabled in the
+ * official Node builds, but Cogenta also has to run on a distribution build, on
+ * a shared host, and on whatever Node an ARM box happens to carry — and rule R1
+ * says an infrastructure need must have an implementation that requires nothing.
+ * So availability is *probed*, once, by trying to create the virtual table, and
+ * a failure degrades to a substring scan instead of taking the site down.
+ *
+ * The degraded path is genuinely worse and says so in `health()`: no ranking, no
+ * stemming, a full scan of the index table. It is not a silent fallback — an
+ * administrator reading `cogenta doctor` sees which of the two is running.
+ */
+const SCOPE_INDEX = 'cogenta_search_scope';
+/**
+ * `"term"*` for every term, all required.
+ *
+ * The quotes turn each token into an FTS5 string literal, so even a token that
+ * collided with a keyword (`AND`, `NEAR`, `NOT`) is read as a word. Tokens are
+ * letters and digits only, so the closing quote can never be escaped out of.
+ */
+function matchExpression(tokens) {
+    return tokens.map((token) => `"${token}"*`).join(' AND ');
+}
+export async function createSqliteSearch(options) {
+    const { db } = options;
+    const dialect = 'sqlite';
+    const wanted = options.fts5 ?? true;
+    const fts = identifier(SEARCH_FTS_TABLE, dialect);
+    const table = identifier(SEARCH_TABLE, dialect);
+    const content = identifier(SEARCH_COLUMNS.content, dialect);
+    const entryId = identifier(SEARCH_COLUMNS.entryId, dialect);
+    const collection = identifier(SEARCH_COLUMNS.collection, dialect);
+    const available = wanted && (await createFtsTable());
+    const target = available ? fts : table;
+    if (!available) {
+        await db.query(sql `create table if not exists ${table} (${joinFragments([...baseColumns(dialect), primaryKey(dialect)], ', ')})`);
+        await db.query(sql `create index if not exists ${identifier(SCOPE_INDEX, dialect)}
+          on ${table} (${identifier(SEARCH_COLUMNS.locale, dialect)},
+                       ${identifier(SEARCH_COLUMNS.status, dialect)})`);
+    }
+    return {
+        dialect,
+        index: async (entry) => {
+            assertDocument(entry);
+            const values = sql `(${entry.id}, ${entry.collection}, ${entry.locale}, ${entry.status},
+                          ${storedTitle(entry)}, ${foldText(`${entry.title} ${entry.body}`)})`;
+            const columns = joinFragments([
+                entryId,
+                collection,
+                identifier(SEARCH_COLUMNS.locale, dialect),
+                identifier(SEARCH_COLUMNS.status, dialect),
+                identifier(SEARCH_COLUMNS.title, dialect),
+                content,
+            ], ', ');
+            if (!available) {
+                // A primary key exists on the plain table, so one statement does it.
+                await db.query(sql `insert or replace into ${table} (${columns}) values ${values}`);
+                return;
+            }
+            // An FTS5 table has no unique constraint to conflict on, so re-indexing is
+            // a delete and an insert. Both inside one immediate transaction: a reader
+            // that lands between them would otherwise find the entry missing from an
+            // index that never stopped being complete.
+            await db.transaction(async (tx) => {
+                await tx.query(sql `delete from ${fts} where ${entryId} = ${entry.id} and ${collection} = ${entry.collection}`);
+                await tx.query(sql `insert into ${fts} (${columns}) values ${values}`);
+            }, { immediate: true });
+        },
+        remove: async (reference) => {
+            assertReference(reference);
+            await db.query(sql `delete from ${target}
+            where ${collection} = ${reference.collection} and ${entryId} = ${reference.id}`);
+        },
+        search: async (query) => {
+            const normalised = normaliseQuery(query);
+            if (normalised.tokens.length === 0)
+                return EMPTY_RESULTS;
+            const filters = scopeFilters(dialect, normalised);
+            if (!available) {
+                // No ranking to offer, so none is invented: every hit scores zero and
+                // the order is the stable one. A caller that sorted on `score` would
+                // otherwise believe a substring scan had an opinion about relevance.
+                const like = normalised.tokens.map((token) => sql `${content} like ${`%${token}%`}`);
+                const scanned = await db.query(sql `select ${selectedColumns(dialect)}
+              from ${table}
+              where ${allOf([...like, ...filters])}
+              order by ${entryId} asc
+              limit ${sqlLimit(normalised.size + 1)} offset ${sqlLimit(normalised.offset)}`);
+                return toResults(scanned.rows, () => 0, normalised);
+            }
+            // bm25() returns a negative number, best first. Negating it makes `score`
+            // mean the same thing here as on the other two dialects: higher is better.
+            const score = sql `-bm25(${fts})`;
+            const found = await db.query(sql `select ${selectedColumns(dialect)}, ${score} as ${identifier('score', dialect)}
+            from ${fts}
+            where ${allOf([sql `${fts} match ${matchExpression(normalised.tokens)}`, ...filters])}
+            order by ${identifier('score', dialect)} desc, ${entryId} asc
+            limit ${sqlLimit(normalised.size + 1)} offset ${sqlLimit(normalised.offset)}`);
+            return toResults(found.rows, (row) => numeric(row['score']), normalised);
+        },
+        clear: async (scope) => {
+            const where = scope?.collection === undefined ? sql `` : sql ` where ${collection} = ${scope.collection}`;
+            await db.query(sql `delete from ${target}${where}`);
+        },
+        health: async () => {
+            const started = Date.now();
+            const counted = await db.query(sql `select count(*) as ${identifier('total', dialect)} from ${target}`);
+            const documents = numeric(counted.rows[0]?.total);
+            if (available) {
+                return {
+                    status: 'ok',
+                    driver: 'sqlite',
+                    tier: 'degraded',
+                    latencyMs: Date.now() - started,
+                    message: 'Full-text search on an FTS5 table, ranked with BM25.',
+                    details: { documents, engine: 'fts5' },
+                };
+            }
+            return {
+                status: 'degraded',
+                driver: 'sqlite',
+                tier: 'degraded',
+                latencyMs: Date.now() - started,
+                message: wanted
+                    ? 'This SQLite build has no FTS5, so search falls back to a substring scan: no ranking, no stemming, and it slows down as the site grows. Rebuild Node with FTS5, or move to Postgres or MySQL.'
+                    : 'FTS5 is turned off, so search falls back to a substring scan: no ranking and no stemming.',
+                details: { documents, engine: 'like' },
+            };
+        },
+    };
+    /**
+     * Probes FTS5 by trying to use it.
+     *
+     * Reading `pragma compile_options` would be the obvious test and is the wrong
+     * one: it reports how the library was built, not whether this connection can
+     * create the module — a distribution can ship FTS5 disabled at runtime. The
+     * statement that would fail later is the honest probe.
+     */
+    async function createFtsTable() {
+        const columns = [
+            // Only `content` is indexed. The rest are stored so a hit needs no join,
+            // but tokenising an id or a status would pollute every ranking.
+            sql `${entryId} unindexed`,
+            sql `${collection} unindexed`,
+            sql `${identifier(SEARCH_COLUMNS.locale, dialect)} unindexed`,
+            sql `${identifier(SEARCH_COLUMNS.status, dialect)} unindexed`,
+            sql `${identifier(SEARCH_COLUMNS.title, dialect)} unindexed`,
+            content,
+        ];
+        try {
+            await db.query(sql `create virtual table if not exists ${fts} using fts5(${joinFragments(columns, ', ')})`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/search/sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.js","sourceRoot":"","sources":["../../src/search/sqlite.ts"],"names":[],"mappings":"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"}

package/dist/search/table.d.ts

@@ -0,0 +1,49 @@
+import { type DatabaseDialect, type SqlFragment } from '@cogenta/core';
+/**
+ * The physical index, shared by the three engines.
+ *
+ * One table for every collection rather than one per collection: a search box
+ * is site-wide, and a union across twenty collection tables would have to be
+ * rebuilt every time a schema changes. The engine-specific machinery — a
+ * `tsvector` column, a `FULLTEXT` key, an FTS5 twin — hangs off this same set
+ * of columns, so the filters and the row mapping are written once.
+ *
+ * The name is fixed rather than derived from a collection, so it is a constant
+ * and not a `naming.ts` function.
+ */
+export declare const SEARCH_TABLE = "cogenta_search";
+/** SQLite only: the FTS5 virtual table. See `sqlite.ts`. */
+export declare const SEARCH_FTS_TABLE = "cogenta_search_fts";
+export declare const SEARCH_COLUMNS: {
+    readonly entryId: 'entry_id';
+    readonly collection: 'collection';
+    readonly locale: 'locale';
+    readonly status: 'status';
+    readonly title: 'title';
+    /** The folded, extracted text. Never the stored JSON. */
+    readonly content: 'content';
+};
+export declare function baseColumns(dialect: DatabaseDialect): SqlFragment[];
+/**
+ * The collection leads the key so that clearing or re-indexing one collection
+ * touches a contiguous range rather than the whole index. It is also what makes
+ * indexing the same entry twice a rewrite instead of a duplicate row, which is
+ * what every driver's upsert relies on.
+ */
+export declare function primaryKey(dialect: DatabaseDialect): SqlFragment;
+/**
+ * The filters that make a result legitimate.
+ *
+ * Every engine's `search` composes these before its own matching clause, and
+ * none of them is optional: the locale and the state are what stop a draft or
+ * another language reaching a reader who has no right to it.
+ */
+export declare function scopeFilters(dialect: DatabaseDialect, scope: {
+    readonly locale: string;
+    readonly status: string;
+    readonly collections?: readonly string[];
+}): SqlFragment[];
+export declare function allOf(filters: readonly SqlFragment[]): SqlFragment;
+/** The projected columns, in one place so the row type matches on all three. */
+export declare function selectedColumns(dialect: DatabaseDialect): SqlFragment;
+//# sourceMappingURL=table.d.ts.map

package/dist/search/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/search/table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAc,KAAK,WAAW,EAAkB,MAAM,eAAe,CAAA;AAIlG;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,mBAAmB,CAAA;AAE5C,4DAA4D;AAC5D,eAAO,MAAM,gBAAgB,uBAAuB,CAAA;AAEpD,eAAO,MAAM,cAAc;aACzB,OAAO,EAAE,UAAU;aACnB,UAAU,EAAE,YAAY;aACxB,MAAM,EAAE,QAAQ;aAChB,MAAM,EAAE,QAAQ;aAChB,KAAK,EAAE,OAAO;IACd,yDAAyD;aACzD,OAAO,EAAE,SAAS;CACV,CAAA;AAWV,wBAAgB,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW,EAAE,CASnE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW,CAGhE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE;IACL,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACzC,GACA,WAAW,EAAE,CAaf;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,CAElE;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW,CAWrE"}

package/dist/search/table.js

@@ -0,0 +1,86 @@
+import { identifier, sql, unsafeRaw } from '@cogenta/core';
+import { textColumn, uuidColumn } from '../store/columns.js';
+import { joinFragments, valueList } from '../store/fragments.js';
+/**
+ * The physical index, shared by the three engines.
+ *
+ * One table for every collection rather than one per collection: a search box
+ * is site-wide, and a union across twenty collection tables would have to be
+ * rebuilt every time a schema changes. The engine-specific machinery — a
+ * `tsvector` column, a `FULLTEXT` key, an FTS5 twin — hangs off this same set
+ * of columns, so the filters and the row mapping are written once.
+ *
+ * The name is fixed rather than derived from a collection, so it is a constant
+ * and not a `naming.ts` function.
+ */
+export const SEARCH_TABLE = 'cogenta_search';
+/** SQLite only: the FTS5 virtual table. See `sqlite.ts`. */
+export const SEARCH_FTS_TABLE = 'cogenta_search_fts';
+export const SEARCH_COLUMNS = {
+    entryId: 'entry_id',
+    collection: 'collection',
+    locale: 'locale',
+    status: 'status',
+    title: 'title',
+    /** The folded, extracted text. Never the stored JSON. */
+    content: 'content',
+};
+/**
+ * `text` holds 64 KiB on MySQL, which a long article passes without trying.
+ * Silently truncating an article's tail out of the index is the kind of bug
+ * that is only ever noticed as "search does not find the end of my pages".
+ */
+function contentColumn(dialect) {
+    return unsafeRaw(dialect === 'mysql' ? 'longtext' : 'text');
+}
+export function baseColumns(dialect) {
+    return [
+        sql `${identifier(SEARCH_COLUMNS.entryId, dialect)} ${uuidColumn(dialect)} not null`,
+        sql `${identifier(SEARCH_COLUMNS.collection, dialect)} ${textColumn(dialect, 64)} not null`,
+        sql `${identifier(SEARCH_COLUMNS.locale, dialect)} ${textColumn(dialect, 16)} not null`,
+        sql `${identifier(SEARCH_COLUMNS.status, dialect)} ${textColumn(dialect, 16)} not null`,
+        sql `${identifier(SEARCH_COLUMNS.title, dialect)} ${textColumn(dialect, 500)} not null`,
+        sql `${identifier(SEARCH_COLUMNS.content, dialect)} ${contentColumn(dialect)} not null`,
+    ];
+}
+/**
+ * The collection leads the key so that clearing or re-indexing one collection
+ * touches a contiguous range rather than the whole index. It is also what makes
+ * indexing the same entry twice a rewrite instead of a duplicate row, which is
+ * what every driver's upsert relies on.
+ */
+export function primaryKey(dialect) {
+    return sql `primary key (${identifier(SEARCH_COLUMNS.collection, dialect)},
+                          ${identifier(SEARCH_COLUMNS.entryId, dialect)})`;
+}
+/**
+ * The filters that make a result legitimate.
+ *
+ * Every engine's `search` composes these before its own matching clause, and
+ * none of them is optional: the locale and the state are what stop a draft or
+ * another language reaching a reader who has no right to it.
+ */
+export function scopeFilters(dialect, scope) {
+    const filters = [
+        sql `${identifier(SEARCH_COLUMNS.locale, dialect)} = ${scope.locale}`,
+        sql `${identifier(SEARCH_COLUMNS.status, dialect)} = ${scope.status}`,
+    ];
+    if (scope.collections !== undefined && scope.collections.length > 0) {
+        filters.push(sql `${identifier(SEARCH_COLUMNS.collection, dialect)} in (${valueList([...scope.collections])})`);
+    }
+    return filters;
+}
+export function allOf(filters) {
+    return joinFragments(filters, ' and ');
+}
+/** The projected columns, in one place so the row type matches on all three. */
+export function selectedColumns(dialect) {
+    return joinFragments([
+        identifier(SEARCH_COLUMNS.entryId, dialect),
+        identifier(SEARCH_COLUMNS.collection, dialect),
+        identifier(SEARCH_COLUMNS.locale, dialect),
+        identifier(SEARCH_COLUMNS.status, dialect),
+        identifier(SEARCH_COLUMNS.title, dialect),
+    ], ', ');
+}
+//# sourceMappingURL=table.js.map

package/dist/search/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../src/search/table.ts"],"names":[],"mappings":"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"}

package/dist/search/text.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Normalisation shared by the three engines.
+ *
+ * The reason it exists at all: accent handling is the one thing the three
+ * dialects disagree about that a *caller* would notice. Postgres folds accents
+ * only with the `unaccent` extension, which a managed instance may not allow;
+ * MySQL folds them through the collation, so `café` and `cafe` already match;
+ * SQLite's FTS5 unicode61 tokeniser folds them by default. Left alone, the same
+ * search would answer differently on each — the divergence the contract suite
+ * exists to prevent.
+ *
+ * So the text is folded **before** it reaches the database, on both the write
+ * and the read side, and every engine indexes the folded form. The cost is that
+ * Postgres stems `ete` rather than `été`; the gain is that "does searching for
+ * `cafe` find `Café` ?" has one answer everywhere, and that answer does not
+ * depend on an extension being installed.
+ */
+/** Lower-cased and stripped of diacritics. */
+export declare function foldText(value: string): string;
+/**
+ * The words of a query or a document, folded.
+ *
+ * Splitting on anything that is not a letter or a digit is what makes the
+ * query safe to hand to three engines with three query languages: a token can
+ * never carry `+`, `-`, `*`, `"` or `(`, so no user input is ever read as a
+ * boolean-mode operator or an FTS5 expression.
+ */
+export declare function tokenize(value: string): string[];
+/** Collapses runs of whitespace so the stored text has no accidental structure. */
+export declare function condense(value: string): string;
+/**
+ * Length below which MySQL ignores a word.
+ *
+ * InnoDB's `innodb_ft_min_token_size` defaults to 3, so `+ai*` in boolean mode
+ * matches nothing and, because of the `+`, makes the whole query match nothing.
+ * Dropping such tokens everywhere rather than only on MySQL keeps the three
+ * engines answering the same thing, which is worth more than two extra letters
+ * of precision on the two dialects that could have handled them.
+ */
+export declare const MIN_TOKEN_LENGTH = 3;
+export declare function queryTokens(text: string): string[];
+//# sourceMappingURL=text.d.ts.map

package/dist/search/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/search/text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,8CAA8C;AAC9C,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhD;AAED,mFAAmF;AACnF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAA;AAEjC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAElD"}

package/dist/search/text.js

@@ -0,0 +1,56 @@
+/**
+ * Normalisation shared by the three engines.
+ *
+ * The reason it exists at all: accent handling is the one thing the three
+ * dialects disagree about that a *caller* would notice. Postgres folds accents
+ * only with the `unaccent` extension, which a managed instance may not allow;
+ * MySQL folds them through the collation, so `café` and `cafe` already match;
+ * SQLite's FTS5 unicode61 tokeniser folds them by default. Left alone, the same
+ * search would answer differently on each — the divergence the contract suite
+ * exists to prevent.
+ *
+ * So the text is folded **before** it reaches the database, on both the write
+ * and the read side, and every engine indexes the folded form. The cost is that
+ * Postgres stems `ete` rather than `été`; the gain is that "does searching for
+ * `cafe` find `Café` ?" has one answer everywhere, and that answer does not
+ * depend on an extension being installed.
+ */
+/** Lower-cased and stripped of diacritics. */
+export function foldText(value) {
+    // NFD splits `é` into `e` + combining acute, which the second step removes.
+    // `\p{Diacritic}` rather than a range: it also covers Greek, Vietnamese and
+    // the Hebrew points, which a Latin-1 range would leave accented.
+    return value
+        .normalize('NFD')
+        .replace(/\p{Diacritic}/gu, '')
+        .toLowerCase();
+}
+/**
+ * The words of a query or a document, folded.
+ *
+ * Splitting on anything that is not a letter or a digit is what makes the
+ * query safe to hand to three engines with three query languages: a token can
+ * never carry `+`, `-`, `*`, `"` or `(`, so no user input is ever read as a
+ * boolean-mode operator or an FTS5 expression.
+ */
+export function tokenize(value) {
+    return foldText(value).match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+/** Collapses runs of whitespace so the stored text has no accidental structure. */
+export function condense(value) {
+    return value.replace(/\s+/gu, ' ').trim();
+}
+/**
+ * Length below which MySQL ignores a word.
+ *
+ * InnoDB's `innodb_ft_min_token_size` defaults to 3, so `+ai*` in boolean mode
+ * matches nothing and, because of the `+`, makes the whole query match nothing.
+ * Dropping such tokens everywhere rather than only on MySQL keeps the three
+ * engines answering the same thing, which is worth more than two extra letters
+ * of precision on the two dialects that could have handled them.
+ */
+export const MIN_TOKEN_LENGTH = 3;
+export function queryTokens(text) {
+    return tokenize(text).filter((token) => token.length >= MIN_TOKEN_LENGTH);
+}
+//# sourceMappingURL=text.js.map

package/dist/search/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../src/search/text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,8CAA8C;AAC9C,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,4EAA4E;IAC5E,4EAA4E;IAC5E,iEAAiE;IACjE,OAAO,KAAK;SACT,SAAS,CAAC,KAAK,CAAC;SAChB,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC;SAC9B,WAAW,EAAE,CAAA;AAClB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAA;AACvD,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,OAAO,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAA;AAC3C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAA;AAEjC,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,gBAAgB,CAAC,CAAA;AAC3E,CAAC"}