litedbmodel 1.2.10 → 2.0.1

package/dist/scp/dialect.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — dialect strategy table (WS6, #26; spec §4/§5/§8/§10).
+ *
+ * The SINGLE SOURCE OF TRUTH for every SQL-dialect difference the Backend Compile + render
+ * pipeline needs. The dialect axis is compiled ONCE, TS-side (spec §10: "方言軸はコンパイル時
+ * に TS 側で1回検証"). This module encodes the differences as a closed strategy record — NO
+ * scattered `?:` in the engine code (the hard rule). A backend compile / renderer asks the
+ * {@link Dialect} for the dialect-specific text and never branches on the dialect name inline.
+ *
+ * ## What actually differs (verified against the v1 SqlBuilders — the golden bar)
+ *
+ * For the CRUD + write-tx + relation SQL the SCP Backend Compile emits (single-row VALUES,
+ * `?` placeholders, `col = ?` WHERE, `col IN (?, …)`), the dialect surface is small and
+ * closed:
+ *
+ *   - **INSERT conflict clause**: SQLite `INSERT OR IGNORE … ` / `… ON CONFLICT (cols) DO
+ *     UPDATE SET c = excluded.c`; Postgres `… ON CONFLICT (cols) DO NOTHING` / `… DO UPDATE
+ *     SET c = EXCLUDED.c`; MySQL `INSERT IGNORE …` / `… ON DUPLICATE KEY UPDATE c = VALUES(c)`.
+ *     These are byte-identical to `SqliteSqlBuilder` / `PostgresSqlBuilder` / `MysqlSqlBuilder`
+ *     `buildInsert` for the single-record case (see the WS6 dialect-golden test).
+ *   - **Bare `ON CONFLICT DO NOTHING`** (no column list — the gate-first idempotency/unique
+ *     guard INSERTs of the write-tx plan, spec §6): SQLite/Postgres emit `ON CONFLICT DO
+ *     NOTHING`; MySQL emits `INSERT IGNORE`.
+ *   - **Placeholder style**: all dialects author with `?`; Postgres converts `?`→`$1,$2,…` in a
+ *     final left-to-right one-pass AFTER the SQL text is fully assembled (spec §8 — the
+ *     number-reassignment problem is designed out because the pass runs once over the final
+ *     flat text). SQLite/MySQL keep `?`.
+ *
+ * Everything else (SELECT/UPDATE/DELETE skeletons, `col = ?`, `col IN (?, …)` expansion, the
+ * fragment tree, RETURNING for SQLite/Postgres) is identical text across dialects, so it is
+ * NOT part of the strategy — only the genuine divergences live here.
+ *
+ * ## DB behavior differences beyond SQL text (spec §13) — closeable-by-convention line
+ *
+ * SQL-text identity does not guarantee identical DB behavior (NULL ordering, collation,
+ * timezone). Per spec §13, those are closed "by dialect-compile-time convention" only within
+ * the closeable line. WS6 encodes the ONE convention that is mechanically closeable in the
+ * compiled SQL text: deterministic NULL ordering for an `ORDER BY … NULLS` requirement
+ * ({@link Dialect.orderByNulls}). Collation / timezone / float semantics are OUT OF SCOPE
+ * (documented, not silently defaulted).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MYSQL = exports.POSTGRES = exports.SQLITE = void 0;
+exports.toDollarPlaceholders = toDollarPlaceholders;
+exports.dialectFor = dialectFor;
+// ── `?`→`$N` final one-pass (Postgres only) ───────────────────────────────────
+/**
+ * Replace each `?` placeholder in a fully-assembled SQL string with `$1, $2, …` left-to-right
+ * (Postgres). This is the spec §8 "最終1パス" conversion: it runs ONCE over the final flat SQL
+ * text, so placeholder numbering is a plain running counter — the number-reassignment problem
+ * cannot reappear (there is no per-fragment renumbering). Every `?` is a bound param position
+ * (the render pipeline never emits a literal `?` inside a string literal — values are always
+ * parameterized), so a naive scan is correct for the compiled surface.
+ */
+function toDollarPlaceholders(sql) {
+    let n = 0;
+    let out = '';
+    for (const ch of sql) {
+        if (ch === '?') {
+            n += 1;
+            out += `$${n}`;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+// ── Shared conflict-clause rendering (parameterized by the SET-assignment form) ─
+/**
+ * Render the trailing conflict clause for the "has a column target" upsert/ignore forms shared
+ * by SQLite and Postgres (`ON CONFLICT (cols) DO NOTHING | DO UPDATE SET …`). MySQL overrides
+ * with its `ON DUPLICATE KEY UPDATE` form. `excludedRef` produces the per-column right-hand side
+ * (`excluded.c` for SQLite, `EXCLUDED.c` for Postgres).
+ */
+function onConflictClause(conflictColumns, action, excludedRef) {
+    const target = conflictColumns.length > 0 ? ` (${conflictColumns.join(', ')})` : '';
+    if (action === 'ignore') {
+        return ` ON CONFLICT${target} DO NOTHING`;
+    }
+    const sets = action.updateColumns.map((c) => `${c} = ${excludedRef(c)}`);
+    return ` ON CONFLICT${target} DO UPDATE SET ${sets.join(', ')}`;
+}
+/**
+ * Render a bare do-nothing guard INSERT. `trailingDoNothing` dialects (SQLite/Postgres) emit
+ * `INSERT INTO … VALUES (…) ON CONFLICT DO NOTHING`; MySQL emits `INSERT IGNORE INTO … VALUES (…)`.
+ */
+function guardInsertText(table, columns, placeholders, form) {
+    const head = form === 'insertIgnore' ? 'INSERT IGNORE INTO' : 'INSERT INTO';
+    const tail = form === 'trailingDoNothing' ? ' ON CONFLICT DO NOTHING' : '';
+    return `${head} ${table} (${columns.join(', ')}) VALUES (${placeholders})${tail}`;
+}
+// ── The three frozen dialect strategies (SSoT) ─────────────────────────────────
+/**
+ * SQLite. `ignore` is an INSERT-verb modifier (`INSERT OR IGNORE INTO`); upsert uses
+ * `ON CONFLICT (cols) DO UPDATE SET c = excluded.c`. Placeholders stay `?`. NULL ordering uses
+ * the native `NULLS FIRST/LAST` (SQLite 3.30+).
+ */
+exports.SQLITE = Object.freeze({
+    name: 'sqlite',
+    ignoreIsTrailingClause: false,
+    insertVerb(action) {
+        return action === 'ignore' ? 'INSERT OR IGNORE INTO' : 'INSERT INTO';
+    },
+    insertConflictClause(conflictColumns, action) {
+        // `ignore` is handled by the verb (`INSERT OR IGNORE`), so no trailing clause for it.
+        if (action === 'ignore')
+            return '';
+        return onConflictClause(conflictColumns, action, (c) => `excluded.${c}`);
+    },
+    guardInsert(table, columns, placeholders) {
+        return guardInsertText(table, columns, placeholders, 'trailingDoNothing');
+    },
+    finalizePlaceholders(sql) {
+        return sql;
+    },
+    orderByNulls(expr, dir, nulls) {
+        return `${expr} ${dir} NULLS ${nulls}`;
+    },
+});
+/**
+ * Postgres. `ignore` is a TRAILING clause (`… ON CONFLICT (cols) DO NOTHING`); upsert uses
+ * `ON CONFLICT (cols) DO UPDATE SET c = EXCLUDED.c`. Placeholders are converted `?`→`$N` in the
+ * final one-pass. NULL ordering uses native `NULLS FIRST/LAST`.
+ */
+exports.POSTGRES = Object.freeze({
+    name: 'postgres',
+    ignoreIsTrailingClause: true,
+    insertVerb(_action) {
+        return 'INSERT INTO';
+    },
+    insertConflictClause(conflictColumns, action) {
+        return onConflictClause(conflictColumns, action, (c) => `EXCLUDED.${c}`);
+    },
+    guardInsert(table, columns, placeholders) {
+        return guardInsertText(table, columns, placeholders, 'trailingDoNothing');
+    },
+    finalizePlaceholders(sql) {
+        return toDollarPlaceholders(sql);
+    },
+    orderByNulls(expr, dir, nulls) {
+        return `${expr} ${dir} NULLS ${nulls}`;
+    },
+});
+/**
+ * MySQL. `ignore` is an INSERT-verb modifier (`INSERT IGNORE INTO`); upsert uses
+ * `… ON DUPLICATE KEY UPDATE c = VALUES(c)` (no conflict-column target — MySQL keys off any
+ * unique index). Placeholders stay `?`. NULL ordering is emulated with a leading
+ * `<expr> IS NULL` sort key (MySQL has no `NULLS FIRST/LAST`).
+ */
+exports.MYSQL = Object.freeze({
+    name: 'mysql',
+    ignoreIsTrailingClause: false,
+    insertVerb(action) {
+        return action === 'ignore' ? 'INSERT IGNORE INTO' : 'INSERT INTO';
+    },
+    insertConflictClause(_conflictColumns, action) {
+        if (action === 'ignore')
+            return ''; // handled by the `INSERT IGNORE` verb
+        const sets = action.updateColumns.map((c) => `${c} = VALUES(${c})`);
+        return ` ON DUPLICATE KEY UPDATE ${sets.join(', ')}`;
+    },
+    guardInsert(table, columns, placeholders) {
+        return guardInsertText(table, columns, placeholders, 'insertIgnore');
+    },
+    finalizePlaceholders(sql) {
+        return sql;
+    },
+    orderByNulls(expr, dir, nulls) {
+        // MySQL: emulate NULLS FIRST/LAST with a leading `IS NULL` key.
+        //   NULLS FIRST → `expr IS NULL DESC, expr <dir>` (nulls sort as 1, before 0... wait)
+        // In MySQL, NULL sorts LOWEST by default. `expr IS NULL` is 1 for null, 0 otherwise.
+        //   NULLS FIRST: nulls must come first → order the IS-NULL flag DESC (1 before 0).
+        //   NULLS LAST:  nulls must come last  → order the IS-NULL flag ASC  (0 before 1).
+        const flagDir = nulls === 'FIRST' ? 'DESC' : 'ASC';
+        return `${expr} IS NULL ${flagDir}, ${expr} ${dir}`;
+    },
+});
+/** Resolve a {@link DialectName} to its frozen {@link Dialect} strategy (fail-closed). */
+const DIALECTS = Object.freeze({
+    sqlite: exports.SQLITE,
+    postgres: exports.POSTGRES,
+    mysql: exports.MYSQL,
+});
+/** Look up a dialect strategy by name (throws on an unknown dialect — no silent default). */
+function dialectFor(name) {
+    const d = DIALECTS[name];
+    if (d === undefined) {
+        throw new Error(`scp dialect: unknown dialect '${String(name)}' (known: ${Object.keys(DIALECTS).join(', ')})`);
+    }
+    return d;
+}
+//# sourceMappingURL=dialect.js.map

package/dist/scp/dialect.js.map

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

package/dist/scp/errors.d.ts

@@ -0,0 +1,36 @@
+/**
+ * litedbmodel v2 SCP — Error Mapping (WS3, #23; spec §11 item 5).
+ *
+ * Maps a SQLite driver error (better-sqlite3 `SqliteError`, carrying a `SQLITE_*` `code`)
+ * to an SCP {@link SqlFailure}: a structured Failure with a stable `kind` and the bc
+ * Execution-Plan {@link PolicyKind} the runtime honors (fail / retry / continue). The
+ * handler returns `{ error }` to bc's `runBehavior`; a `fail`-policy node re-throws through
+ * `runPlan` (`OP_FAILED`), so the driver surfaces this structured failure at the boundary.
+ *
+ * The mapping is closed and explicit (no silent catch-all that hides a driver error): an
+ * unrecognized SQLite code maps to `kind: 'driver_error'` with `policy: 'fail'` — loud, and
+ * carrying the original code + message for diagnosis.
+ */
+import type { PolicyKind } from 'behavior-contracts';
+/** The SCP failure kinds litedbmodel maps SQL driver errors to (spec §11 item 5). */
+export type SqlFailureKind = 'constraint_violation' | 'foreign_key_violation' | 'retryable' | 'driver_error';
+/**
+ * A mapped SCP failure: the SCP `kind`, the honored bc `PolicyKind`, the original SQLite
+ * `code`, and a human message. Thrown at the runtime boundary (or carried as `{error}`
+ * into `runBehavior` for Policy-Kind interpretation by `runPlan`).
+ */
+export declare class SqlFailure extends Error {
+    readonly kind: SqlFailureKind;
+    readonly policy: PolicyKind;
+    readonly sqliteCode: string | undefined;
+    constructor(kind: SqlFailureKind, policy: PolicyKind, sqliteCode: string | undefined, message: string);
+}
+/**
+ * Map a caught driver error to an {@link SqlFailure}. The `SQLITE_CONSTRAINT_*` family maps
+ * to constraint / FK kinds (Policy `fail` — a data conflict is not retryable); the
+ * `SQLITE_BUSY` / `SQLITE_LOCKED` family maps to `retryable` (Policy `retry`). Anything else
+ * (including a non-SQLite error) maps to `driver_error` (Policy `fail`), preserving the
+ * original message.
+ */
+export declare function mapSqliteError(e: unknown): SqlFailure;
+//# sourceMappingURL=errors.d.ts.map

package/dist/scp/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/scp/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,qFAAqF;AACrF,MAAM,MAAM,cAAc,GACtB,sBAAsB,GACtB,uBAAuB,GACvB,WAAW,GACX,cAAc,CAAC;AAEnB;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,KAAK;IAEjC,QAAQ,CAAC,IAAI,EAAE,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,UAAU;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;gBAF9B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,MAAM,GAAG,SAAS,EACvC,OAAO,EAAE,MAAM;CAKlB;AAYD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,UAAU,CAqBrD"}

package/dist/scp/errors.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — Error Mapping (WS3, #23; spec §11 item 5).
+ *
+ * Maps a SQLite driver error (better-sqlite3 `SqliteError`, carrying a `SQLITE_*` `code`)
+ * to an SCP {@link SqlFailure}: a structured Failure with a stable `kind` and the bc
+ * Execution-Plan {@link PolicyKind} the runtime honors (fail / retry / continue). The
+ * handler returns `{ error }` to bc's `runBehavior`; a `fail`-policy node re-throws through
+ * `runPlan` (`OP_FAILED`), so the driver surfaces this structured failure at the boundary.
+ *
+ * The mapping is closed and explicit (no silent catch-all that hides a driver error): an
+ * unrecognized SQLite code maps to `kind: 'driver_error'` with `policy: 'fail'` — loud, and
+ * carrying the original code + message for diagnosis.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlFailure = void 0;
+exports.mapSqliteError = mapSqliteError;
+/**
+ * A mapped SCP failure: the SCP `kind`, the honored bc `PolicyKind`, the original SQLite
+ * `code`, and a human message. Thrown at the runtime boundary (or carried as `{error}`
+ * into `runBehavior` for Policy-Kind interpretation by `runPlan`).
+ */
+class SqlFailure extends Error {
+    kind;
+    policy;
+    sqliteCode;
+    constructor(kind, policy, sqliteCode, message) {
+        super(message);
+        this.kind = kind;
+        this.policy = policy;
+        this.sqliteCode = sqliteCode;
+        this.name = 'SqlFailure';
+    }
+}
+exports.SqlFailure = SqlFailure;
+/** True if `e` looks like a better-sqlite3 `SqliteError` (has a `SQLITE_*` string `code`). */
+function isSqliteError(e) {
+    return (typeof e === 'object' &&
+        e !== null &&
+        typeof e.code === 'string' &&
+        e.code.startsWith('SQLITE_'));
+}
+/**
+ * Map a caught driver error to an {@link SqlFailure}. The `SQLITE_CONSTRAINT_*` family maps
+ * to constraint / FK kinds (Policy `fail` — a data conflict is not retryable); the
+ * `SQLITE_BUSY` / `SQLITE_LOCKED` family maps to `retryable` (Policy `retry`). Anything else
+ * (including a non-SQLite error) maps to `driver_error` (Policy `fail`), preserving the
+ * original message.
+ */
+function mapSqliteError(e) {
+    if (!isSqliteError(e)) {
+        const message = e instanceof Error ? e.message : String(e);
+        return new SqlFailure('driver_error', 'fail', undefined, `non-SQLite driver error: ${message}`);
+    }
+    const { code, message } = e;
+    // The message embeds the `SQLITE_*` code so it survives being wrapped by bc's `runPlan`
+    // (`OP_FAILED: <handler message>`); the runtime re-maps from it to re-surface the
+    // structured SqlFailure (kind / policy / code) at the boundary.
+    const tagged = `[${code}] ${message}`;
+    if (code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
+        return new SqlFailure('foreign_key_violation', 'fail', code, tagged);
+    }
+    if (code.startsWith('SQLITE_CONSTRAINT')) {
+        // UNIQUE / PRIMARYKEY / CHECK / NOTNULL / … — a durable constraint conflict.
+        return new SqlFailure('constraint_violation', 'fail', code, tagged);
+    }
+    if (code === 'SQLITE_BUSY' || code === 'SQLITE_LOCKED') {
+        return new SqlFailure('retryable', 'retry', code, tagged);
+    }
+    return new SqlFailure('driver_error', 'fail', code, tagged);
+}
+//# sourceMappingURL=errors.js.map

package/dist/scp/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/scp/errors.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AA6CH,wCAqBC;AAvDD;;;;GAIG;AACH,MAAa,UAAW,SAAQ,KAAK;IAExB;IACA;IACA;IAHX,YACW,IAAoB,EACpB,MAAkB,EAClB,UAA8B,EACvC,OAAe;QAEf,KAAK,CAAC,OAAO,CAAC,CAAC;QALN,SAAI,GAAJ,IAAI,CAAgB;QACpB,WAAM,GAAN,MAAM,CAAY;QAClB,eAAU,GAAV,UAAU,CAAoB;QAIvC,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAVD,gCAUC;AAED,8FAA8F;AAC9F,SAAS,aAAa,CAAC,CAAU;IAC/B,OAAO,CACL,OAAO,CAAC,KAAK,QAAQ;QACrB,CAAC,KAAK,IAAI;QACV,OAAQ,CAAwB,CAAC,IAAI,KAAK,QAAQ;QACjD,CAAsB,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CACnD,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,cAAc,CAAC,CAAU;IACvC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;QACtB,MAAM,OAAO,GAAG,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3D,OAAO,IAAI,UAAU,CAAC,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,4BAA4B,OAAO,EAAE,CAAC,CAAC;IAClG,CAAC;IACD,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAC5B,wFAAwF;IACxF,kFAAkF;IAClF,gEAAgE;IAChE,MAAM,MAAM,GAAG,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;IACtC,IAAI,IAAI,KAAK,8BAA8B,EAAE,CAAC;QAC5C,OAAO,IAAI,UAAU,CAAC,uBAAuB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE,CAAC;QACzC,6EAA6E;QAC7E,OAAO,IAAI,UAAU,CAAC,sBAAsB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACtE,CAAC;IACD,IAAI,IAAI,KAAK,aAAa,IAAI,IAAI,KAAK,eAAe,EAAE,CAAC;QACvD,OAAO,IAAI,UAAU,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,IAAI,UAAU,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;AAC9D,CAAC"}

package/dist/scp/find-filter-guard.d.ts

@@ -0,0 +1,68 @@
+/**
+ * litedbmodel v2 SCP — FIND_FILTER fail-closed authoring guard (#47 Finding B / plan R8).
+ *
+ * `FIND_FILTER` is a v1 PER-MODEL implicit predicate (a soft-delete / tenant scope) that
+ * v1 MERGES into the WHERE of every internal `find()`/`count()` before compiling
+ * (`DBModel._buildSelectSQL` / `_count`: `normalizedCond.add(condsToRecord(FIND_FILTER))`).
+ * It is not a distinct SQL construct — it manifests purely as extra WHERE fragments.
+ *
+ * The SCP compile path (`L.Select({ where })` → `compileReadGraph` → `renderReadPrimary`)
+ * is AUTHORED from an explicit `where`; it has NO `DBModel` class context, so it CANNOT
+ * auto-apply a model's `FIND_FILTER` (there is no model reference at compile time, and no
+ * production seam routes a `DBModel` into the SCP compile — grep: `FIND_FILTER` appears only
+ * in `DBModel`/`decorators`/`types`, never under `src/scp/`). Auto-apply is therefore
+ * impossible without model context the SCP compile does not have.
+ *
+ * Resolution = the plan's variant chosen fail-closed: a model that DECLARES a `FIND_FILTER`
+ * MUST have its scope predicates folded into the authored `L.Select({ where })`; if the
+ * author routes such a model through SCP WITHOUT the scope keys, this guard throws loudly
+ * ({@link FindFilterLeakError}) rather than silently dropping the filter (which would leak
+ * soft-deleted / cross-tenant rows — a correctness bug, not a cosmetic one). When the scope
+ * keys ARE present the guard is a no-op (byte-identical to v1's merged WHERE — proven in
+ * `test/scp/find-filter-noop.test.ts`).
+ */
+import { type Conds } from '../Column';
+/** A `DBModel`-shaped source: the only field this guard reads is the optional `FIND_FILTER`. */
+export interface FindFilterSource {
+    /** The per-model implicit scope predicate (v1 `DBModel.FIND_FILTER`), or null/undefined. */
+    readonly FIND_FILTER?: Conds | null;
+    /** Class name for diagnostics (present on every `DBModel` subclass). */
+    readonly name?: string;
+}
+/**
+ * A model declaring a `FIND_FILTER` was compiled via the SCP path without its scope
+ * predicates present in the authored WHERE — the filter would silently leak. Thrown
+ * fail-closed at compile time; never swallowed.
+ */
+export declare class FindFilterLeakError extends Error {
+    /** The declaring model's class name (diagnostics). */
+    readonly modelName: string;
+    /** The FIND_FILTER scope keys that are MISSING from the authored WHERE. */
+    readonly missingKeys: readonly string[];
+    constructor(
+    /** The declaring model's class name (diagnostics). */
+    modelName: string, 
+    /** The FIND_FILTER scope keys that are MISSING from the authored WHERE. */
+    missingKeys: readonly string[]);
+}
+/**
+ * Extract the top-level predicate KEYS a `FIND_FILTER` folds into a WHERE. Uses the SAME
+ * `condsToRecord` v1 runs when merging (`DBModel._buildSelectSQL`:597) so the key set is
+ * exactly what v1 would add to `normalizedCond`. `__or__` (grouped OR) is kept as a key so a
+ * scoped OR-group also demands explicit authoring (fail-closed; never silently satisfied).
+ */
+export declare function findFilterKeys(filter: Conds | null | undefined): string[];
+/**
+ * Fail-closed guard: assert a model's `FIND_FILTER` scope keys are all present in the
+ * authored WHERE key set BEFORE an SCP compile of that model. No FIND_FILTER → no-op. When
+ * present, EVERY scope key must appear in `authoredWhereKeys`; any missing key throws
+ * {@link FindFilterLeakError}. The caller passes the top-level keys of the object it hands to
+ * `L.Select({ where })` (the same shape `condsToRecord` yields), so the check compares
+ * like-for-like against v1's merged predicate.
+ *
+ * @param model  a `DBModel`-shaped source that MAY declare `FIND_FILTER`.
+ * @param authoredWhereKeys  the top-level WHERE keys the SCP author expressed for this model.
+ * @throws FindFilterLeakError when a declared scope key is absent from the authored WHERE.
+ */
+export declare function assertFindFilterFolded(model: FindFilterSource, authoredWhereKeys: Iterable<string>): void;
+//# sourceMappingURL=find-filter-guard.d.ts.map

package/dist/scp/find-filter-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-filter-guard.d.ts","sourceRoot":"","sources":["../../src/scp/find-filter-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAEtD,gGAAgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,4FAA4F;IAC5F,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAE1C,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE;;IAHvC,sDAAsD;IAC7C,SAAS,EAAE,MAAM;IAC1B,2EAA2E;IAClE,WAAW,EAAE,SAAS,MAAM,EAAE;CAY1C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAGzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,gBAAgB,EACvB,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAClC,IAAI,CAQN"}

package/dist/scp/find-filter-guard.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — FIND_FILTER fail-closed authoring guard (#47 Finding B / plan R8).
+ *
+ * `FIND_FILTER` is a v1 PER-MODEL implicit predicate (a soft-delete / tenant scope) that
+ * v1 MERGES into the WHERE of every internal `find()`/`count()` before compiling
+ * (`DBModel._buildSelectSQL` / `_count`: `normalizedCond.add(condsToRecord(FIND_FILTER))`).
+ * It is not a distinct SQL construct — it manifests purely as extra WHERE fragments.
+ *
+ * The SCP compile path (`L.Select({ where })` → `compileReadGraph` → `renderReadPrimary`)
+ * is AUTHORED from an explicit `where`; it has NO `DBModel` class context, so it CANNOT
+ * auto-apply a model's `FIND_FILTER` (there is no model reference at compile time, and no
+ * production seam routes a `DBModel` into the SCP compile — grep: `FIND_FILTER` appears only
+ * in `DBModel`/`decorators`/`types`, never under `src/scp/`). Auto-apply is therefore
+ * impossible without model context the SCP compile does not have.
+ *
+ * Resolution = the plan's variant chosen fail-closed: a model that DECLARES a `FIND_FILTER`
+ * MUST have its scope predicates folded into the authored `L.Select({ where })`; if the
+ * author routes such a model through SCP WITHOUT the scope keys, this guard throws loudly
+ * ({@link FindFilterLeakError}) rather than silently dropping the filter (which would leak
+ * soft-deleted / cross-tenant rows — a correctness bug, not a cosmetic one). When the scope
+ * keys ARE present the guard is a no-op (byte-identical to v1's merged WHERE — proven in
+ * `test/scp/find-filter-noop.test.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindFilterLeakError = void 0;
+exports.findFilterKeys = findFilterKeys;
+exports.assertFindFilterFolded = assertFindFilterFolded;
+const Column_1 = require("../Column");
+/**
+ * A model declaring a `FIND_FILTER` was compiled via the SCP path without its scope
+ * predicates present in the authored WHERE — the filter would silently leak. Thrown
+ * fail-closed at compile time; never swallowed.
+ */
+class FindFilterLeakError extends Error {
+    modelName;
+    missingKeys;
+    constructor(
+    /** The declaring model's class name (diagnostics). */
+    modelName, 
+    /** The FIND_FILTER scope keys that are MISSING from the authored WHERE. */
+    missingKeys) {
+        super(`FIND_FILTER leak: model '${modelName}' declares an implicit scope predicate on ` +
+            `[${missingKeys.join(', ')}] that is NOT present in the SCP-authored WHERE. The SCP ` +
+            `compile cannot auto-apply FIND_FILTER (no model context at compile time), so the ` +
+            `scope predicate would be silently dropped (soft-delete / tenant scope leak). Fold ` +
+            `the FIND_FILTER predicates into the authored L.Select({ where }) explicitly ` +
+            `(e.g. whereEq/whereIsNull on ${missingKeys.join(', ')}).`);
+        this.modelName = modelName;
+        this.missingKeys = missingKeys;
+        this.name = 'FindFilterLeakError';
+    }
+}
+exports.FindFilterLeakError = FindFilterLeakError;
+/**
+ * Extract the top-level predicate KEYS a `FIND_FILTER` folds into a WHERE. Uses the SAME
+ * `condsToRecord` v1 runs when merging (`DBModel._buildSelectSQL`:597) so the key set is
+ * exactly what v1 would add to `normalizedCond`. `__or__` (grouped OR) is kept as a key so a
+ * scoped OR-group also demands explicit authoring (fail-closed; never silently satisfied).
+ */
+function findFilterKeys(filter) {
+    if (!filter || filter.length === 0)
+        return [];
+    return Object.keys((0, Column_1.condsToRecord)(filter));
+}
+/**
+ * Fail-closed guard: assert a model's `FIND_FILTER` scope keys are all present in the
+ * authored WHERE key set BEFORE an SCP compile of that model. No FIND_FILTER → no-op. When
+ * present, EVERY scope key must appear in `authoredWhereKeys`; any missing key throws
+ * {@link FindFilterLeakError}. The caller passes the top-level keys of the object it hands to
+ * `L.Select({ where })` (the same shape `condsToRecord` yields), so the check compares
+ * like-for-like against v1's merged predicate.
+ *
+ * @param model  a `DBModel`-shaped source that MAY declare `FIND_FILTER`.
+ * @param authoredWhereKeys  the top-level WHERE keys the SCP author expressed for this model.
+ * @throws FindFilterLeakError when a declared scope key is absent from the authored WHERE.
+ */
+function assertFindFilterFolded(model, authoredWhereKeys) {
+    const required = findFilterKeys(model.FIND_FILTER);
+    if (required.length === 0)
+        return; // No implicit scope → nothing to fold → no-op.
+    const present = new Set(authoredWhereKeys);
+    const missing = required.filter((k) => !present.has(k));
+    if (missing.length > 0) {
+        throw new FindFilterLeakError(model.name ?? '<anonymous model>', missing);
+    }
+}
+//# sourceMappingURL=find-filter-guard.js.map

package/dist/scp/find-filter-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-filter-guard.js","sourceRoot":"","sources":["../../src/scp/find-filter-guard.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;AA0CH,wCAGC;AAcD,wDAWC;AApED,sCAAsD;AAUtD;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,KAAK;IAGjC;IAEA;IAJX;IACE,sDAAsD;IAC7C,SAAiB;IAC1B,2EAA2E;IAClE,WAA8B;QAEvC,KAAK,CACH,4BAA4B,SAAS,4CAA4C;YAC/E,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,2DAA2D;YACrF,mFAAmF;YACnF,oFAAoF;YACpF,8EAA8E;YAC9E,gCAAgC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAC7D,CAAC;QAXO,cAAS,GAAT,SAAS,CAAQ;QAEjB,gBAAW,GAAX,WAAW,CAAmB;QAUvC,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AAjBD,kDAiBC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,MAAgC;IAC7D,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC9C,OAAO,MAAM,CAAC,IAAI,CAAC,IAAA,sBAAa,EAAC,MAAM,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,sBAAsB,CACpC,KAAuB,EACvB,iBAAmC;IAEnC,MAAM,QAAQ,GAAG,cAAc,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IACnD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,+CAA+C;IAClF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,mBAAmB,CAAC,KAAK,CAAC,IAAI,IAAI,mBAAmB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC"}

package/dist/scp/fragment/assemble.d.ts

@@ -0,0 +1,61 @@
+/**
+ * litedbmodel v2 SCP — fragment RUNTIME (assemble + bind).
+ *
+ * This is the thin runtime a bundle drives. It does exactly three things:
+ *
+ *   1. ASSEMBLE — walk the ordered fragment list; drop any fragment whose `skip`
+ *      is satisfied; concatenate the present fragments' `sql`, and their `params`
+ *      in order. Nested-fragment params splice their own `sql` at the `?` and
+ *      contribute their own params in order.
+ *   2. EVALUATE — turn each value-spec param into a concrete bound value using the
+ *      runtime `input` (and upstream `wire` results).
+ *   3. RENDER — the produced `{ sql, params }` uses `?`; a dialect step turns `?`
+ *      into `$N` for PostgreSQL (identical to the original driver's naive replace).
+ *
+ * NO SQL structure is generated here. The `sql` text is already complete; the
+ * runtime only splices nested-fragment text and fills `?`.
+ */
+import { type Fragment, type Node, type WhereGroup, type ValueSpec, type PresenceCondition } from './model';
+/** Runtime binding scope: FLAT — input keys and wire results are top-level roots. */
+export interface Scope {
+    input: Record<string, unknown>;
+    wire?: Record<string, Record<string, unknown>>;
+}
+/** Is a fragment's `skip` satisfied (⇒ omit the fragment)? */
+export declare function isSkipped(cond: PresenceCondition | undefined, scope: Scope): boolean;
+/** Evaluate a value-spec to its bound value against the runtime scope. */
+export declare function evalValueSpec(spec: ValueSpec, scope: Scope): unknown;
+/**
+ * Assemble a single fragment: interleave its literal `sql` (split on `?`) with the
+ * rendered text of each param, concatenating params in order.
+ */
+export declare function assembleFragment(frag: Fragment, scope: Scope): {
+    sql: string;
+    params: unknown[];
+};
+/**
+ * Assemble a WHERE group: join present members with `" AND "`, prefix `" WHERE "`.
+ * If no member is present, produce the empty string (identical to the ORIGINAL
+ * `DBConditions.compile` → `parts.length === 0 ? '' : parts.join(' AND ')`, with the
+ * `" WHERE "` prefix owned by the caller/select in the original — here folded in).
+ */
+export declare function assembleWhereGroup(group: WhereGroup, scope: Scope): {
+    sql: string;
+    params: unknown[];
+};
+/**
+ * Assemble an ordered fragment/WHERE-group list into a single `{ sql, params }`
+ * (with `?`). Fragments whose `skip` is satisfied are omitted entirely (sql AND
+ * params). A WHERE group joins its present members with the original's text glue.
+ */
+export declare function assemble(nodes: Node[], scope: Scope): {
+    sql: string;
+    params: unknown[];
+};
+/**
+ * PostgreSQL dialect render: `?` → `$1, $2, …`. Byte-identical to the original
+ * driver's `convertPlaceholders` (naive left-to-right replace; see
+ * `src/drivers/postgres.ts`).
+ */
+export declare function toPostgres(sql: string): string;
+//# sourceMappingURL=assemble.d.ts.map

package/dist/scp/fragment/assemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/assemble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,IAAI,EACT,KAAK,UAAU,EAEf,KAAK,SAAS,EACd,KAAK,iBAAiB,EAOvB,MAAM,SAAS,CAAC;AAEjB,qFAAqF;AACrF,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAChD;AAWD,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAIpF;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAqBpE;AAYD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAejG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAWtG;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAgBxF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C"}