@dokebi/search 0.0.0-stage → 0.1.0

package/dist/sql.d.ts

@@ -0,0 +1,32 @@
+export type Driver = 'pg' | 'mysql2' | 'mariadb';
+/** The server: PostgreSQL, MySQL or MariaDB (mysql2 can talk to MariaDB too). */
+export type Dialect = 'postgres' | 'mysql' | 'mariadb';
+export type Row = Record<string, unknown>;
+export interface Result {
+    readonly rows: Row[];
+    readonly affected: number;
+    readonly insertId: string | undefined;
+}
+/** A pool, a connection or a transaction client: statements with `?` placeholders. */
+export interface Session {
+    query(sql: string, params?: readonly unknown[]): Promise<Result>;
+}
+interface Queryable {
+    query(sql: string, values?: unknown[]): Promise<unknown>;
+}
+export declare const isQueryable: (value: unknown) => value is Queryable;
+/** Wraps a client of a known driver (the caller's transaction, the plugin's pool). */
+export declare function session(driver: Driver, client: unknown): Session;
+/** Finds the driver of a pool by the shape of one `SELECT 1` answer (no write). */
+export declare function detectDriver(resource: unknown): Promise<Driver | undefined>;
+/** The server behind a pool: PostgreSQL, or MySQL and MariaDB told apart by VERSION(). */
+export declare function serverDialect(driver: Driver, pool: Session): Promise<{
+    dialect: Dialect;
+    version: string;
+}>;
+/** A missing table or column (PostgreSQL 42P01, 42703; MySQL and MariaDB 1146, 1054). */
+export declare function isMissingTable(error: unknown): boolean;
+/** A number from a driver value: pg bigint strings, mariadb BigInt, mysql2 numbers. */
+export declare function num(value: unknown): number;
+export declare function text(value: unknown): string | undefined;
+export {};

package/dist/sql.js

@@ -0,0 +1,104 @@
+import { SearchError } from './errors.js';
+export const isQueryable = (value) => value !== null &&
+    typeof value === 'object' &&
+    typeof value.query === 'function';
+/** `?` placeholders as `$1, $2, …` for pg; cached, the statements are few. */
+const numberedCache = new Map();
+function numbered(sql) {
+    let text = numberedCache.get(sql);
+    if (text === undefined) {
+        let index = 0;
+        text = sql.replace(/\?/g, () => `$${++index}`);
+        if (numberedCache.size < 4096)
+            numberedCache.set(sql, text);
+    }
+    return text;
+}
+function idOf(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value);
+    return text === '0' ? undefined : text;
+}
+/** Wraps a client of a known driver (the caller's transaction, the plugin's pool). */
+export function session(driver, client) {
+    if (!isQueryable(client))
+        throw new SearchError('INVALID_ITEM', 'The transaction client has no query method (pass the pg client or the mysql2/mariadb connection of the transaction)');
+    if (driver === 'pg')
+        return {
+            async query(sql, params = []) {
+                const result = (await client.query(numbered(sql), [...params]));
+                return {
+                    rows: result.rows ?? [],
+                    affected: Number(result.rowCount ?? 0),
+                    insertId: undefined,
+                };
+            },
+        };
+    if (driver === 'mysql2')
+        return {
+            async query(sql, params = []) {
+                const [result] = (await client.query(sql, [...params]));
+                if (Array.isArray(result))
+                    return { rows: result, affected: 0, insertId: undefined };
+                const header = result;
+                return {
+                    rows: [],
+                    affected: Number(header.affectedRows ?? 0),
+                    insertId: idOf(header.insertId),
+                };
+            },
+        };
+    return {
+        async query(sql, params = []) {
+            const result = (await client.query(sql, [...params]));
+            if (Array.isArray(result))
+                return { rows: [...result], affected: 0, insertId: undefined };
+            const header = result;
+            return {
+                rows: [],
+                affected: Number(header.affectedRows ?? 0),
+                insertId: idOf(header.insertId),
+            };
+        },
+    };
+}
+/** Finds the driver of a pool by the shape of one `SELECT 1` answer (no write). */
+export async function detectDriver(resource) {
+    if (!isQueryable(resource))
+        return undefined;
+    const probe = await Promise.resolve(resource.query('SELECT 1 AS one'));
+    if (probe !== null &&
+        typeof probe === 'object' &&
+        Array.isArray(probe.rows))
+        return 'pg';
+    if (Array.isArray(probe) && Array.isArray(probe[0]))
+        return 'mysql2';
+    if (Array.isArray(probe))
+        return 'mariadb';
+    return undefined;
+}
+/** The server behind a pool: PostgreSQL, or MySQL and MariaDB told apart by VERSION(). */
+export async function serverDialect(driver, pool) {
+    if (driver === 'pg') {
+        const { rows } = await pool.query('SHOW server_version');
+        return { dialect: 'postgres', version: String(rows[0]?.server_version ?? '') };
+    }
+    const { rows } = await pool.query('SELECT VERSION() AS version');
+    const version = String(rows[0]?.version ?? '');
+    return { dialect: /mariadb/i.test(version) ? 'mariadb' : 'mysql', version };
+}
+const MISSING_TABLE = new Set(['42P01', 'ER_NO_SUCH_TABLE', '42703', 'ER_BAD_FIELD_ERROR']);
+const MISSING_TABLE_ERRNO = new Set([1146, 1054]);
+/** A missing table or column (PostgreSQL 42P01, 42703; MySQL and MariaDB 1146, 1054). */
+export function isMissingTable(error) {
+    const value = error;
+    return MISSING_TABLE.has(value?.code) || MISSING_TABLE_ERRNO.has(Number(value?.errno));
+}
+/** A number from a driver value: pg bigint strings, mariadb BigInt, mysql2 numbers. */
+export function num(value) {
+    return value === null || value === undefined ? 0 : Number(value);
+}
+export function text(value) {
+    return value === null || value === undefined ? undefined : String(value);
+}

package/dist/store.d.ts

@@ -0,0 +1,66 @@
+import type { SearchHit } from './api.js';
+import type { Dialect, Session } from './sql.js';
+export declare const TERMS_TABLE = "dokebi_search_terms";
+export declare const COUNTS_TABLE = "dokebi_search_counts";
+export declare const INDEXES_TABLE = "dokebi_search_indexes";
+export interface TermRow {
+    readonly field: string;
+    readonly term: string;
+    readonly scope: string;
+}
+export interface StoredRow extends TermRow {
+    readonly sortKey: number;
+}
+export interface CountDelta {
+    readonly field: string;
+    readonly term: string;
+    readonly delta: number;
+}
+export interface Position {
+    readonly sortKey: number;
+    readonly id: string;
+}
+export interface Scanned extends SearchHit {
+    readonly hit: boolean;
+}
+export declare class Store {
+    #private;
+    constructor(dialect: Dialect, slots: number);
+    check(db: Session): Promise<void>;
+    fingerprints(db: Session): Promise<Map<string, string>>;
+    saveFingerprint(db: Session, name: string, fingerprint: string, at: number): Promise<void>;
+    /** The rows of one item (the item index). */
+    itemRows(db: Session, index: string, id: string): Promise<StoredRow[]>;
+    deleteItem(db: Session, index: string, id: string): Promise<number>;
+    deleteRows(db: Session, index: string, id: string, rows: readonly TermRow[]): Promise<void>;
+    insertRows(db: Session, index: string, id: string, sortKey: number, rows: readonly TermRow[]): Promise<void>;
+    /**
+     * Moves the item counts of words by their deltas, in one slot chosen at random, in the order
+     * given (the caller sorts them, so two writers lock the same rows in the same order).
+     */
+    addCounts(db: Session, index: string, deltas: readonly CountDelta[]): Promise<void>;
+    /** The item count of each word (its slots summed); a word without rows is absent. */
+    counts(db: Session, index: string, field: string, terms: readonly string[]): Promise<Map<string, number>>;
+    /** One word: the next rows in display order. */
+    page(db: Session, input: {
+        readonly index: string;
+        readonly field: string;
+        readonly scope: string;
+        readonly term: string;
+        readonly after: Position | undefined;
+        readonly limit: number;
+    }): Promise<SearchHit[]>;
+    /**
+     * Several words: the next `limit` rows of the leading word in display order, each with
+     * whether the item has every other word too (a primary-key lookup per word).
+     */
+    scan(db: Session, input: {
+        readonly index: string;
+        readonly field: string;
+        readonly scope: string;
+        readonly lead: string;
+        readonly others: readonly string[];
+        readonly after: Position | undefined;
+        readonly limit: number;
+    }): Promise<Scanned[]>;
+}

package/dist/store.js

@@ -0,0 +1,137 @@
+import { num } from './sql.js';
+/*
+ * The statements of the search tables (D-0170 §5, @dokebi/db AI.md 6.10). Every read is an
+ * equality on the leading columns of the primary key followed by its order, read backwards:
+ * no sort, no scan beyond the rows asked for. The cursor condition is one row comparison on
+ * PostgreSQL and the expanded form on MySQL and MariaDB (db AI.md 7.4).
+ */
+export const TERMS_TABLE = 'dokebi_search_terms';
+export const COUNTS_TABLE = 'dokebi_search_counts';
+export const INDEXES_TABLE = 'dokebi_search_indexes';
+/** Rows of one multi-row INSERT or DELETE (parameters stay far below every driver's limit). */
+const BATCH = 500;
+export class Store {
+    #dialect;
+    #slots;
+    constructor(dialect, slots) {
+        this.#dialect = dialect;
+        this.#slots = slots;
+    }
+    async check(db) {
+        await db.query(`SELECT index_name, field, term, scope, sort_key, item_id FROM ${TERMS_TABLE} WHERE 1 = 0`);
+        await db.query(`SELECT index_name, field, term, slot, count FROM ${COUNTS_TABLE} WHERE 1 = 0`);
+        await db.query(`SELECT name, fingerprint, updated_at FROM ${INDEXES_TABLE} WHERE 1 = 0`);
+    }
+    async fingerprints(db) {
+        const { rows } = await db.query(`SELECT name, fingerprint FROM ${INDEXES_TABLE}`);
+        return new Map(rows.map((row) => [String(row.name), String(row.fingerprint)]));
+    }
+    async saveFingerprint(db, name, fingerprint, at) {
+        const insert = `INSERT INTO ${INDEXES_TABLE} (name, fingerprint, updated_at) VALUES (?, ?, ?)`;
+        if (this.#dialect === 'postgres')
+            await db.query(`${insert} ON CONFLICT (name) DO UPDATE SET fingerprint = EXCLUDED.fingerprint, updated_at = EXCLUDED.updated_at`, [name, fingerprint, at]);
+        else
+            await db.query(`${insert} ON DUPLICATE KEY UPDATE fingerprint = VALUES(fingerprint), updated_at = VALUES(updated_at)`, [name, fingerprint, at]);
+    }
+    /** The rows of one item (the item index). */
+    async itemRows(db, index, id) {
+        const { rows } = await db.query(`SELECT field, term, scope, sort_key FROM ${TERMS_TABLE} WHERE index_name = ? AND item_id = ?`, [index, id]);
+        return rows.map((row) => ({
+            field: String(row.field),
+            term: String(row.term),
+            scope: String(row.scope),
+            sortKey: num(row.sort_key),
+        }));
+    }
+    async deleteItem(db, index, id) {
+        const result = await db.query(`DELETE FROM ${TERMS_TABLE} WHERE index_name = ? AND item_id = ?`, [index, id]);
+        return result.affected;
+    }
+    async deleteRows(db, index, id, rows) {
+        for (let start = 0; start < rows.length; start += BATCH) {
+            const part = rows.slice(start, start + BATCH);
+            const params = [index, id];
+            const tuples = part.map((row) => {
+                params.push(row.field, row.term, row.scope);
+                return '(?, ?, ?)';
+            });
+            await db.query(`DELETE FROM ${TERMS_TABLE} WHERE index_name = ? AND item_id = ? AND (field, term, scope) IN (${tuples.join(', ')})`, params);
+        }
+    }
+    async insertRows(db, index, id, sortKey, rows) {
+        for (let start = 0; start < rows.length; start += BATCH) {
+            const part = rows.slice(start, start + BATCH);
+            const params = [];
+            const tuples = part.map((row) => {
+                params.push(index, row.field, row.term, row.scope, sortKey, id);
+                return '(?, ?, ?, ?, ?, ?)';
+            });
+            await db.query(`INSERT INTO ${TERMS_TABLE} (index_name, field, term, scope, sort_key, item_id) VALUES ${tuples.join(', ')}`, params);
+        }
+    }
+    /**
+     * Moves the item counts of words by their deltas, in one slot chosen at random, in the order
+     * given (the caller sorts them, so two writers lock the same rows in the same order).
+     */
+    async addCounts(db, index, deltas) {
+        const slot = Math.floor(Math.random() * this.#slots);
+        for (let start = 0; start < deltas.length; start += BATCH) {
+            const part = deltas.slice(start, start + BATCH);
+            const params = [];
+            const tuples = part.map((row) => {
+                params.push(index, row.field, row.term, slot, row.delta);
+                return '(?, ?, ?, ?, ?)';
+            });
+            const insert = `INSERT INTO ${COUNTS_TABLE} (index_name, field, term, slot, count) VALUES ${tuples.join(', ')}`;
+            const upsert = this.#dialect === 'postgres'
+                ? `${insert} ON CONFLICT (index_name, field, term, slot) DO UPDATE SET count = ${COUNTS_TABLE}.count + EXCLUDED.count`
+                : this.#dialect === 'mysql'
+                    ? `${insert} AS added ON DUPLICATE KEY UPDATE count = ${COUNTS_TABLE}.count + added.count`
+                    : `${insert} ON DUPLICATE KEY UPDATE count = count + VALUES(count)`;
+            await db.query(upsert, params);
+        }
+    }
+    /** The item count of each word (its slots summed); a word without rows is absent. */
+    async counts(db, index, field, terms) {
+        const { rows } = await db.query(`SELECT term, SUM(count) AS n FROM ${COUNTS_TABLE} WHERE index_name = ? AND field = ? AND term IN (${terms.map(() => '?').join(', ')}) GROUP BY term`, [index, field, ...terms]);
+        return new Map(rows.map((row) => [String(row.term), num(row.n)]));
+    }
+    #after(alias, after, params) {
+        if (!after)
+            return '';
+        if (this.#dialect === 'postgres') {
+            params.push(after.sortKey, after.id);
+            return ` AND (${alias}sort_key, ${alias}item_id) < (?, ?)`;
+        }
+        params.push(after.sortKey, after.sortKey, after.id);
+        return ` AND (${alias}sort_key < ? OR (${alias}sort_key = ? AND ${alias}item_id < ?))`;
+    }
+    /** One word: the next rows in display order. */
+    async page(db, input) {
+        const params = [input.index, input.field, input.term, input.scope];
+        const after = this.#after('', input.after, params);
+        params.push(input.limit);
+        const { rows } = await db.query(`SELECT sort_key, item_id FROM ${TERMS_TABLE} WHERE index_name = ? AND field = ? AND term = ? AND scope = ?${after} ORDER BY sort_key DESC, item_id DESC LIMIT ?`, params);
+        return rows.map((row) => ({ id: String(row.item_id), sortKey: num(row.sort_key) }));
+    }
+    /**
+     * Several words: the next `limit` rows of the leading word in display order, each with
+     * whether the item has every other word too (a primary-key lookup per word).
+     */
+    async scan(db, input) {
+        const params = [];
+        const checks = input.others.map((term) => {
+            params.push(input.index, input.field, term, input.scope);
+            return `EXISTS (SELECT 1 FROM ${TERMS_TABLE} o WHERE o.index_name = ? AND o.field = ? AND o.term = ? AND o.scope = ? AND o.sort_key = t.sort_key AND o.item_id = t.item_id)`;
+        });
+        params.push(input.index, input.field, input.lead, input.scope);
+        const after = this.#after('t.', input.after, params);
+        params.push(input.limit);
+        const { rows } = await db.query(`SELECT t.sort_key, t.item_id, CASE WHEN ${checks.join(' AND ')} THEN 1 ELSE 0 END AS hit FROM ${TERMS_TABLE} t WHERE t.index_name = ? AND t.field = ? AND t.term = ? AND t.scope = ?${after} ORDER BY t.sort_key DESC, t.item_id DESC LIMIT ?`, params);
+        return rows.map((row) => ({
+            id: String(row.item_id),
+            sortKey: num(row.sort_key),
+            hit: num(row.hit) === 1,
+        }));
+    }
+}

package/dist/terms.d.ts

@@ -0,0 +1,31 @@
+/** The longest term, in code points (the column is varchar(64)). */
+export declare const MAX_TERM = 64;
+/** The longest prefix a field may declare. */
+export declare const MAX_PREFIX = 32;
+/** The most words one query may have. */
+export declare const MAX_QUERY_WORDS = 8;
+/**
+ * The version of these rules, part of every index fingerprint: a change of the normalisation
+ * marks every index stale, so the application indexes its rows again.
+ */
+export declare const TERMS_VERSION = 1;
+export interface TermRules {
+    /** The longest word prefix indexed; 0 indexes whole words only. */
+    readonly prefix: number;
+    /** The shortest prefix indexed (whole words are always indexed). */
+    readonly minLength: number;
+}
+/** The normalised words of a text, in order, repeats kept. */
+export declare function words(text: string): string[];
+/** The terms of a text under `rules`: every word (cut to MAX_TERM) and its prefixes. */
+export declare function terms(text: string, rules: TermRules): Set<string>;
+/**
+ * The terms a query looks up: its distinct words, each a term the index holds for every text
+ * that has the word or a word starting with it (up to `prefix`); a longer word matches whole
+ * words only, so a search never matches more than it says. Words shorter than `minLength` are
+ * returned in `short` (the index has them only as whole words: the caller refuses the query).
+ */
+export declare function queryTerms(text: string, rules: TermRules): {
+    readonly terms: string[];
+    readonly short: string[];
+};

package/dist/terms.js

@@ -0,0 +1,58 @@
+/*
+ * The terms of a text (D-0170, @dokebi/db AI.md 6.10): NFKC, lower case, words split on anything
+ * that is not a letter, mark or digit, and each word with its prefixes from `minLength` to
+ * `prefix` code points (a Hangul syllable is one), so a search for a stem finds every form the
+ * language attaches endings to. The number of words is never cut (6.1). Pure functions: the
+ * browser may use them to show what will match.
+ */
+/** The longest term, in code points (the column is varchar(64)). */
+export const MAX_TERM = 64;
+/** The longest prefix a field may declare. */
+export const MAX_PREFIX = 32;
+/** The most words one query may have. */
+export const MAX_QUERY_WORDS = 8;
+/**
+ * The version of these rules, part of every index fingerprint: a change of the normalisation
+ * marks every index stale, so the application indexes its rows again.
+ */
+export const TERMS_VERSION = 1;
+const SEPARATOR = /[^\p{L}\p{M}\p{N}]+/u;
+/** The normalised words of a text, in order, repeats kept. */
+export function words(text) {
+    const out = [];
+    for (const word of text.normalize('NFKC').toLowerCase().split(SEPARATOR))
+        if (word)
+            out.push(word);
+    return out;
+}
+/** The terms of a text under `rules`: every word (cut to MAX_TERM) and its prefixes. */
+export function terms(text, rules) {
+    const out = new Set();
+    const longest = Math.min(rules.prefix, MAX_TERM);
+    for (const word of words(text)) {
+        const points = Array.from(word);
+        out.add(points.length > MAX_TERM ? points.slice(0, MAX_TERM).join('') : word);
+        const end = Math.min(longest, points.length - 1);
+        for (let length = rules.minLength; length <= end; length++)
+            out.add(points.slice(0, length).join(''));
+    }
+    return out;
+}
+/**
+ * The terms a query looks up: its distinct words, each a term the index holds for every text
+ * that has the word or a word starting with it (up to `prefix`); a longer word matches whole
+ * words only, so a search never matches more than it says. Words shorter than `minLength` are
+ * returned in `short` (the index has them only as whole words: the caller refuses the query).
+ */
+export function queryTerms(text, rules) {
+    const seen = new Set();
+    const short = [];
+    for (const word of words(text)) {
+        const points = Array.from(word);
+        const term = points.length > MAX_TERM ? points.slice(0, MAX_TERM).join('') : word;
+        if (points.length < rules.minLength && rules.prefix > 0)
+            short.push(term);
+        seen.add(term);
+    }
+    return { terms: [...seen], short };
+}

package/options.schema.json

@@ -0,0 +1,95 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "connection": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$",
+      "default": "main",
+      "description": "The dokebi-db connection of the database that holds the application's rows (the terms share their transaction); dokebi add writes the table migration into its migrations folder."
+    },
+    "pool": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "max": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 64,
+          "default": 4,
+          "description": "Connections of the pool derived from the connection for find, so searches never take the request pool. 0 uses the connection pool."
+        }
+      },
+      "default": {}
+    },
+    "examineLimit": {
+      "type": "integer",
+      "minimum": 100,
+      "maximum": 100000,
+      "default": 2000,
+      "description": "Most rows of the leading word one find call examines when a search has several words; reached before the page is full, it answers the matches found with next and partial: true."
+    },
+    "searchLimit": {
+      "type": "integer",
+      "minimum": 100,
+      "maximum": 10000000,
+      "default": 50000,
+      "description": "Most rows one search of several words examines over all its pages (kept in the signed cursor); reached, it ends with stopped: SEARCH_TOO_BROAD. At least examineLimit."
+    },
+    "list": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "maxLimit": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 1000,
+          "default": 100,
+          "description": "Most items one find call returns."
+        }
+      },
+      "default": {}
+    },
+    "counts": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "slots": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 64,
+          "default": 4,
+          "description": "Rows a word's item count is split into (a flush adds to one at random, a read sums them), so the workers' flushes of common words do not wait on one row."
+        },
+        "flushMs": {
+          "type": "integer",
+          "minimum": 100,
+          "maximum": 60000,
+          "default": 1000,
+          "description": "How often each worker adds its buffered word counts to the table, outside every transaction (the counts only choose a search's leading word); also at drain and when 2000 words are buffered."
+        }
+      },
+      "default": {}
+    },
+    "secrets": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 32,
+        "maxLength": 512,
+        "writeOnly": true
+      },
+      "minItems": 1,
+      "maxItems": 8,
+      "uniqueItems": true,
+      "description": "Cursor signing secrets (32+ characters); the first signs, all verify. dokebi add writes a generated one (npx dokebi config secret dokebi-search.secrets makes one later); keep dokebi.yaml out of version control"
+    },
+    "secretsEnv": {
+      "type": "string",
+      "pattern": "^[A-Za-z_][A-Za-z0-9_]{0,127}$",
+      "x-dokebi-secret": false,
+      "description": "Environment variable that, when set and not empty, replaces secrets (comma-separated, the first signs): an optional production override (default DOKEBI_SEARCH_SECRETS)"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,88 @@
 {
   "name": "@dokebi/search",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Search in an application's lists for Dokebi by @dokebi/db AI.md 6.10: a term table in display order written in the text's transaction, Korean word prefixes, the rarest word leads, bounded requests and searches with a signed cursor.",
+  "keywords": [
+    "dokebi",
+    "dokebi-plugin",
+    "search",
+    "full-text",
+    "database"
+  ],
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./dependency": {
+      "types": "./dist/dependency.d.ts",
+      "import": "./dist/dependency.js"
+    }
+  },
+  "files": [
+    "dist",
+    "templates",
+    "options.schema.json",
+    "README.md",
+    "AI.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"import('./dist/options.js').then(async (m) => { const { renderOptionsSchema } = await import('@dokebi/core'); process.stdout.write(renderOptionsSchema(m.options)); })\" > options.schema.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "node -e \"require('node:fs').rmSync('.tmp/tests',{recursive:true,force:true})\" && tsc -p tsconfig.test.json && node --test --test-concurrency=1 \".tmp/tests/tests/*.test.js\""
+  },
+  "peerDependencies": {
+    "@dokebi/core": "^0.4.2",
+    "@dokebi/db": "^0.4.1"
+  },
+  "devDependencies": {
+    "@dokebi/db": "0.4.1"
+  },
+  "dokebi": {
+    "schemaVersion": 2,
+    "id": "dokebi-search",
+    "core": "^0.4.2",
+    "dependencies": [
+      {
+        "name": "dokebi-db",
+        "version": "^0.4.1",
+        "package": "@dokebi/db"
+      }
+    ],
+    "contributes": [
+      "core:describe"
+    ],
+    "installModule": "dist/install.js",
+    "optionsSchema": "options.schema.json",
+    "documentation": "AI.md"
+  },
+  "dokebiCatalog": {
+    "kind": "plugin",
+    "summary": "Search in your lists that stays bounded on a growing table: a term table in display order written in the text's transaction, Korean word prefixes, the rarest word leads, capped requests and searches with a signed cursor; answers item ids",
+    "maturity": "experimental",
+    "provides": [
+      "search"
+    ],
+    "doesNot": [
+      "No MongoDB (PostgreSQL, MySQL 8, MariaDB 10.6+)",
+      "No relevance ranking: results come in the index's display order",
+      "Does not read or authorize your rows: it answers item ids, and hidden items are removed from the index by your code",
+      "No typo tolerance, synonyms or stemming beyond word prefixes",
+      "Does not create tables at start (the migration dokebi add writes)"
+    ],
+    "recipes": []
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/templates/indexes.ts

@@ -0,0 +1,10 @@
+// The search indexes of this application (@dokebi/search, D-0170): each index has the fields a
+// list searches, and each field its term rules. `prefix` is the longest word prefix indexed
+// (default 10, so a search for a stem finds the words that start with it, Korean particles
+// included); 0 indexes whole words only. Replace the example with your own lists. After changing
+// a field's rules, index its rows again and call search.markCurrent(<index>).
+import { defineSearchIndexes } from '@dokebi/search';
+
+export default defineSearchIndexes({
+  posts: { fields: { title: {}, body: {}, author: { prefix: 0 } } },
+});