litedbmodel 2.0.2 → 2.2.0

package/dist/scp/middleware.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the **middleware layer** (Phase D / #92).
+ *
+ * This module is the **API REFERENCE** for Phase D — the 4 native ports (rust #93 / go #94 / py #95
+ * / php #96) mirror THIS contract exactly: the registration surface (`use` / `createMiddleware`), the
+ * SQL-level `execute(next, sql, params)` chain contract + APPLIED ORDER, the method-level hook shape
+ * + op-kind dispatch, the standard {@link Logger} middleware, and the raw {@link rawExecute} /
+ * {@link rawQuery} API that goes THROUGH the exec-context seam (so middleware + connection routing +
+ * transaction all still apply). It builds ON the Phase A {@link import('./exec-context').ExecutionContext}
+ * seam (the empty {@link import('./exec-context').MiddlewareChain} hook Phase A reserved) — it does
+ * NOT restructure the seam; it makes the reserved hook real.
+ *
+ * ## The two hook levels (design §4)
+ *
+ *   1. **SQL-level `execute` hook** — `(sql, params, next) => T`. Wraps EVERY statement that funnels
+ *      through the central seam ({@link import('./exec-context').execute} / `run` / their async +
+ *      safeIntegers twins), so read, write, tx-control (BEGIN/COMMIT/ROLLBACK), and relation-batch
+ *      SQL are ALL intercepted. A middleware can observe / rewrite (`next(sql', params')`) / time /
+ *      short-circuit (return without calling `next`). This is the seam's `MiddlewareChain` folded
+ *      around the connection-resolve terminal.
+ *   2. **method-level hook** — at the ORM operation boundary, keyed by the operation KIND
+ *      (`find`/`findOne`/`findById`/`count`/`create`/`createMany`/`update`/`updateMany`/`delete`/
+ *      `query`). In v2 the "methods" map onto the read (`executeBundle`) / write (`executeTransactionBundle`)
+ *      operations tagged with their {@link MethodKind}; {@link runMethod} folds the matching method
+ *      hooks around the operation. A method hook runs before/after (around) the whole operation and
+ *      can rewrite its args / short-circuit its result.
+ *
+ * ## Registration + APPLIED ORDER (the 5-language contract — v1 `DBModel.use` parity)
+ *
+ * `use(mw)` appends to an ordered stack and returns an un-register fn (`DBModel.use` :414). The stack
+ * is folded so the FIRST-registered middleware is the OUTERMOST wrapper: given `use(A); use(B)`, a
+ * statement runs `A.before → B.before → «execute» → B.after → A.after`. This holds identically for the
+ * SQL-level chain ({@link MiddlewareChain.wrap}) and the method-level chain ({@link runMethod}) — the
+ * fold walks the stack from LAST to FIRST building `next`, so index 0 ends up outermost. This ORDER is
+ * the normative contract the ports reproduce.
+ *
+ * ## Per-execution-scope isolation (NOT a serializing process global) — design §4 last line
+ *
+ * A middleware binds to the EXECUTION SCOPE, so concurrent requests/contexts never see each other's
+ * middleware or per-request state. TS uses `AsyncLocalStorage` (as v1 does): {@link withMiddlewareScope}
+ * runs a callback with an ISOLATED registry copy; every middleware STATE object is likewise ALS-scoped
+ * (a fresh per-scope instance via {@link MiddlewareHandle.state}). Two concurrent `withMiddlewareScope`
+ * bodies each mutate their OWN registry + state, never a shared global slot — so N concurrent requests
+ * do not serialize on one registry (the bug a process-global stack would cause). Absent an explicit
+ * scope, `use` mutates a process-global default stack (the app-startup registration path). The native
+ * ports translate the ALS: rust = `task_local!`, go = a value on `context.Context`, py = `contextvars`,
+ * php = an explicit registry arg (1 request = 1 process ⇒ no concurrency to isolate).
+ *
+ * NB: native registration (design §4 "native 側でも登録可"): each runtime exposes its own
+ * `register_middleware(mw)` appending to its ctx chain; the CHAIN CONTRACT + ORDER above is shared, the
+ * middleware BODY is that language's closure/impl. TS is the reference for the shape.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registry = void 0;
+exports.currentRegistry = currentRegistry;
+exports.withMiddlewareScope = withMiddlewareScope;
+exports.activeSqlMiddlewares = activeSqlMiddlewares;
+exports.register = register;
+exports.use = use;
+exports.createMiddleware = createMiddleware;
+exports.runMethod = runMethod;
+exports.Logger = Logger;
+exports.rawExecute = rawExecute;
+exports.rawExecuteAsync = rawExecuteAsync;
+exports.rawQuery = rawQuery;
+exports.rawQueryAsync = rawQueryAsync;
+exports.clearMiddlewares = clearMiddlewares;
+const node_async_hooks_1 = require("node:async_hooks");
+// ── The middleware registry (the ordered stack + ambient isolation) ────────────
+/**
+ * The ordered middleware stack. `use` appends (first-registered = outermost, §order), returning an
+ * un-register fn. `sqlHooks()` / `methodHooks(kind)` return the folded-order slices the seam +
+ * {@link runMethod} consume. A {@link Registry} is EITHER the process-global default (app-startup
+ * registration) OR a per-execution-scope copy pushed by {@link withMiddlewareScope} (concurrent
+ * isolation) — the two share this class; only their lifetime differs.
+ */
+class Registry {
+    stack = [];
+    /**
+     * Per-scope STATE instances, keyed by the state-owning token a {@link createMiddleware} descriptor
+     * carries. Because the Registry is itself per-execution-scope ({@link withMiddlewareScope} pushes a
+     * COPY), the state map is scope-local too — so a middleware's per-request state is isolated across
+     * concurrent scopes WITHOUT leaking (the `enterWith`-leak trap). A fresh scope's copy starts with an
+     * EMPTY state map (states are NOT copied), so each scope lazily builds its own fresh state instances.
+     */
+    states = new Map();
+    /** The current scope's state for `token`, lazily created via `fresh` on first access (v1 getCurrentContext). */
+    stateFor(token, fresh) {
+        let s = this.states.get(token);
+        if (s === undefined) {
+            s = fresh();
+            this.states.set(token, s);
+        }
+        return s;
+    }
+    /** Reset `token`'s state in this scope to a fresh instance (testing convenience). */
+    resetStateFor(token, fresh) {
+        this.states.set(token, fresh());
+    }
+    /** Register `mw` (appended ⇒ outermost). Returns an idempotent un-register fn. */
+    use(mw) {
+        this.stack.push(mw);
+        return () => {
+            const i = this.stack.indexOf(mw);
+            if (i !== -1)
+                this.stack.splice(i, 1);
+        };
+    }
+    /** Remove `mw` (v1 `removeMiddleware`). Returns whether it was present. */
+    remove(mw) {
+        const i = this.stack.indexOf(mw);
+        if (i === -1)
+            return false;
+        this.stack.splice(i, 1);
+        return true;
+    }
+    /** Drop every registration (v1 `clearMiddlewares` — testing). */
+    clear() {
+        this.stack = [];
+    }
+    /** The registered descriptors, registration order (index 0 = first = outermost). */
+    all() {
+        return this.stack;
+    }
+    /** The SQL-level hooks (registration order), for the {@link MiddlewareChain} fold. */
+    sqlHooks() {
+        const out = [];
+        for (const mw of this.stack)
+            if (mw.sql !== undefined)
+                out.push(mw.sql);
+        return out;
+    }
+    /** The method hooks for `kind` (registration order), for the {@link runMethod} fold. */
+    methodHooks(kind) {
+        const out = [];
+        for (const mw of this.stack) {
+            const h = mw.methods?.[kind];
+            if (h !== undefined)
+                out.push(h);
+        }
+        return out;
+    }
+    /** A shallow COPY (used to seed an isolated per-scope registry that starts from the global set). */
+    copy() {
+        const r = new Registry();
+        r.stack = [...this.stack];
+        return r;
+    }
+}
+exports.Registry = Registry;
+/** The process-global default registry (app-startup `use` with no explicit scope). */
+const globalRegistry = new Registry();
+/** The per-execution-scope registry override (ALS): present ⇒ `use`/reads target THIS scope's copy. */
+const registryScope = new node_async_hooks_1.AsyncLocalStorage();
+/** The registry the current execution scope resolves to: the ALS override, else the global default. */
+function currentRegistry() {
+    return registryScope.getStore() ?? globalRegistry;
+}
+/**
+ * Run `fn` with an ISOLATED middleware registry (concurrent-request isolation, design §4). The scope
+ * seeds a COPY of the currently-visible registry (so app-wide registrations remain in effect), and any
+ * `use` / per-request state inside `fn` mutates ONLY this scope — two concurrent `withMiddlewareScope`
+ * bodies never see each other's middleware. `seed` lets a caller start from an EMPTY registry instead
+ * (`inherit: false`). The native ports run their task-local / contextvar / `context.Context` /
+ * explicit-arg equivalent.
+ */
+function withMiddlewareScope(fn, opts = {}) {
+    const seed = opts.inherit === false ? new Registry() : currentRegistry().copy();
+    return registryScope.run(seed, fn);
+}
+/**
+ * The LIVE SQL-level middleware stack of the current execution scope — the
+ * {@link import('./exec-context').MiddlewareStackSource} the ctx factories give their
+ * {@link import('./exec-context').MiddlewareChain}. Resolved at EACH `wrap`, so registration after ctx
+ * construction, and per-scope registries, are both honored. Empty ⇒ the seam is a byte-identical
+ * passthrough.
+ */
+function activeSqlMiddlewares() {
+    return currentRegistry().sqlHooks();
+}
+// ── Registration surface (v1 `DBModel.use` / `createMiddleware` parity) ────────
+/**
+ * Register a middleware descriptor on the CURRENT scope's registry (the ambient per-scope one inside
+ * {@link withMiddlewareScope}, else the process-global default). Returns an un-register fn (v1
+ * `DBModel.use` :414). This is the low-level surface; app code usually registers a
+ * {@link createMiddleware} handle via {@link use}.
+ */
+function register(mw) {
+    return currentRegistry().use(mw);
+}
+/** Register a {@link createMiddleware} handle (or a raw descriptor) — v1 `DBModel.use`. */
+function use(mw) {
+    const descriptor = 'descriptor' in mw ? mw.descriptor : mw;
+    return register(descriptor);
+}
+/** The op-kind method-hook config keys (in registration-independent order). */
+const METHOD_KINDS = [
+    'find', 'findOne', 'findById', 'count', 'create', 'createMany', 'update', 'updateMany', 'delete', 'query',
+];
+/**
+ * Build a {@link MiddlewareHandle} from a v1-shaped {@link MiddlewareConfig} (v1 `createMiddleware`
+ * parity). Each hook body's `this` is the CURRENT execution scope's state instance (a fresh
+ * `structuredClone` of `config.state` per scope, ALS-isolated). The `execute` hook is adapted from the
+ * v1 `(next, sql, params)` order to the seam's `(sql, params, next)` order, so a v1 hook body ports
+ * unchanged. Method hooks pass through in the v1 `(model, next, ...args)` shape.
+ */
+function createMiddleware(config) {
+    // Per-scope state: keyed on THIS unique token in the CURRENT scope's registry. Because the registry
+    // is itself per-execution-scope ({@link withMiddlewareScope} pushes a fresh copy with an empty state
+    // map), each scope lazily builds its OWN state instance — isolated across concurrent scopes with no
+    // `enterWith` leak (v1's per-subclass AsyncLocalStorage, but scope-tied to the registry). First
+    // access in a scope deep-copies the initial state (v1 `structuredClone`).
+    const token = {};
+    const freshState = () => (config.state !== undefined ? structuredClone(config.state) : {});
+    const state = () => currentRegistry().stateFor(token, freshState);
+    // SQL-level hook: adapt v1 (next, sql, params) → seam (sql, params, next); bind `this` to the state.
+    const sql = config.execute
+        ? (s, p, next) => config.execute
+            .call(state(), (ns, np) => next(ns, np ?? []), s, p)
+        : undefined;
+    const methods = {};
+    for (const kind of METHOD_KINDS) {
+        const fn = config[kind];
+        if (fn !== undefined) {
+            methods[kind] = (model, next, ...args) => fn.call(state(), model, next, ...args);
+        }
+    }
+    const descriptor = {
+        ...(sql !== undefined ? { sql } : {}),
+        ...(Object.keys(methods).length > 0 ? { methods } : {}),
+    };
+    return {
+        descriptor,
+        state,
+        resetState: () => currentRegistry().resetStateFor(token, freshState),
+    };
+}
+// ── Method-level dispatch (design §4 level 2) — the operation boundary fold ─────
+/**
+ * Run an ORM operation of KIND `kind` through the current scope's method hooks, then execute `core`.
+ * The hooks fold first-registered-outermost (§order), each getting `(model, next, ...args)`; a hook may
+ * rewrite `args`, time `next`, or short-circuit. Empty hooks for this kind ⇒ `core(...args)` verbatim
+ * (byte-identical — no method registered = the operation runs untouched). This is the v2 equivalent of
+ * v1 `DBModel._applyMiddleware`: the runtime calls it at the read (`executeBundle`) / write
+ * (`executeTransactionBundle`) boundary with the op tagged by its {@link MethodKind}.
+ *
+ * @param kind the operation kind (how a method hook distinguishes read vs. write vs. find/create/…).
+ * @param model the operation's model/target descriptor (opaque; passed to each hook).
+ * @param core  the actual operation, taking the (possibly hook-rewritten) args.
+ * @param args  the operation's arguments.
+ */
+function runMethod(kind, model, core, args) {
+    const hooks = currentRegistry().methodHooks(kind);
+    if (hooks.length === 0)
+        return core(...args); // fast path: no method hook for this kind
+    let next = (...a) => core(...a);
+    for (let i = hooks.length - 1; i >= 0; i--) {
+        const hook = hooks[i];
+        const inner = next;
+        next = (...a) => hook(model, inner, ...a);
+    }
+    return next(...args);
+}
+/**
+ * The standard **Logger middleware** (design §4, v1 `StatisticsMiddleware`/`Logger` parity): a
+ * SQL-level {@link SqlHook} that records the SQL, its params, and the wall-clock ms each statement
+ * takes. Every statement through the seam — read, write, tx-control, relation-batch — is logged (it is
+ * an `execute`-level hook). Register it with {@link use}: `use(Logger({ sink }))`. Timing brackets the
+ * `next` call, so it measures the connection execute (chain remainder included), NOT just the log call.
+ *
+ * The per-scope log history lives on the handle's `state().entries` (v1 `getCurrentContext().getLogs()`),
+ * so concurrent requests each collect their OWN entries (ALS-isolated). The port agents build the same
+ * shape: a scope-local list + an `execute` hook timing `next`.
+ */
+function Logger(options = {}) {
+    const now = options.now ?? Date.now;
+    return createMiddleware({
+        state: { entries: [] },
+        // Works on BOTH the sync (`Rows`/`RunInfo`) and async (`Promise<…>`) seams: `next` may return a
+        // value or a thenable, so timing/recording is done in a completion callback that handles either —
+        // NOT an `async`/`await` (which would coerce the sync seam's value into a Promise, breaking the
+        // synchronous conformance path). `this` is the per-scope state (isolated log history).
+        execute: function (next, sql, params) {
+            const entries = this.entries;
+            const started = now();
+            const record = () => {
+                const entry = { sql, params, durationMs: now() - started };
+                entries.push(entry);
+                if (options.sink !== undefined)
+                    options.sink(entry);
+                if (options.console === true) {
+                    console.log(`[scp] ${sql} (${entry.durationMs}ms) params=${JSON.stringify(params)}`);
+                }
+            };
+            const result = next(sql, params);
+            if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
+                return result.then((v) => { record(); return v; }, (e) => { record(); throw e; });
+            }
+            record();
+            return result;
+        },
+    });
+}
+// ── D3: raw execute / query THROUGH the seam ───────────────────────────────────
+//
+// A public raw statement API that goes through the exec-context seam, so a registered SQL-level
+// middleware sees it AND connection routing / an ambient transaction still apply (design §4 D3). It is
+// a thin front over the seam's `execute`/`run` (sync) or `executeAsync`/`runAsync` (async) — the SAME
+// central point every ORM-generated statement uses. `rawQuery` is `rawExecute` tagged as a `query`
+// operation kind (so a `query` method hook fires), matching v1 `DBModel.query` → `execute`.
+const exec_context_1 = require("./exec-context");
+/** Does `sql` return rows (SELECT / …RETURNING / WITH…SELECT / SHOW / PRAGMA / VALUES)? */
+function returnsRows(sql) {
+    return /^\s*(select|with|show|pragma|values|explain|table)\b/i.test(sql) || /\breturning\b/i.test(sql);
+}
+/**
+ * Raw **synchronous** `execute(sql, params)` THROUGH the seam (design §4 D3): a registered SQL-level
+ * middleware intercepts it, connection routing resolves the connection, and an ambient transaction (if
+ * the ctx is tx-scoped) applies — because it is the SAME `execute`/`run` seam the ORM uses, not a
+ * direct driver call. A row-returning statement runs `execute`; a non-returning one runs `run`.
+ * `write` forces the write intent (writer routing / tx connection) for a row-returning write.
+ */
+function rawExecute(ctx, sql, params = [], opts = {}) {
+    if (returnsRows(sql)) {
+        const rows = (0, exec_context_1.execute)(ctx, sql, params, { write: opts.write ?? false });
+        return { rows, rowCount: rows.length };
+    }
+    const info = (0, exec_context_1.run)(ctx, sql, params);
+    return { rows: [], rowCount: info.changes };
+}
+/** Raw **async** `execute(sql, params)` THROUGH the async seam — the live PG / MySQL twin of {@link rawExecute}. */
+async function rawExecuteAsync(ctx, sql, params = [], opts = {}) {
+    if (returnsRows(sql)) {
+        const rows = await (0, exec_context_1.executeAsync)(ctx, sql, params, { write: opts.write ?? false });
+        return { rows, rowCount: rows.length };
+    }
+    const info = await (0, exec_context_1.runAsync)(ctx, sql, params);
+    return { rows: [], rowCount: info.changes };
+}
+/**
+ * Raw **synchronous** `query(sql, params)` — {@link rawExecute} tagged as a `query` operation, so a
+ * `query` method hook fires (then its SQL flows through the same seam + `execute` hooks, exactly as v1
+ * `DBModel.query` calls `DBModel.execute`). Returns the row list.
+ */
+function rawQuery(ctx, sql, params = []) {
+    return runMethod('query', undefined, async () => rawExecute(ctx, sql, params).rows, [sql, params]);
+}
+/** Raw **async** `query(sql, params)` — the live PG / MySQL twin of {@link rawQuery}. */
+function rawQueryAsync(ctx, sql, params = []) {
+    return runMethod('query', undefined, async () => (await rawExecuteAsync(ctx, sql, params)).rows, [sql, params]);
+}
+// ── Reset / testing helpers ────────────────────────────────────────────────────
+/** Clear the process-global registry (testing; a per-scope registry is dropped when its scope exits). */
+function clearMiddlewares() {
+    globalRegistry.clear();
+}
+//# sourceMappingURL=middleware.js.map

package/dist/scp/middleware.js.map

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

package/dist/scp/relation.d.ts

@@ -26,6 +26,9 @@
  *   - **Lazy** (`await post.author`): a prototype getter fires the SAME op over the sibling set.
  */
 import { type Dialect } from './makesql/handler';
+import { type ExecutionContext } from './exec-context';
+import { type MaterializeClass, type ColumnTypeResolver } from './coltype';
+import { type RelationGuard } from './limit-config';
 /** A read relation cardinality (v1 parity). `belongsTo`/`hasOne` are single; `hasMany` many. */
 export type RelationKind = 'belongsTo' | 'hasMany' | 'hasOne';
 /**
@@ -57,8 +60,26 @@ export interface RelationDecl {
     readonly order?: string;
     /** Optional per-parent row limit (`hasMany` only). */
     readonly limit?: number;
+    /**
+     * Per-relation hard-limit override (Phase E-2, epic #74; v1 `@hasMany({ hardLimit })`): the
+     * batch-total cap for THIS relation, winning over the global `hasManyHardLimit`. `null` DISABLES
+     * the check for this relation even when the global is set; `undefined` ⇒ use the global. `hasMany`
+     * only (a single-cardinality relation fetches at most one child per parent). A relation with an
+     * intrinsic per-parent {@link limit} window skips the batch-total check regardless (its fanout is
+     * already bounded). See {@link import('./limit-config').resolveHasManyHardLimit}.
+     */
+    readonly hardLimit?: number | null;
     /** The target SQL dialect the batch SELECT is compiled for (default `'sqlite'`). */
     readonly dialect?: Dialect;
+    /**
+     * CHAINED relations (nested `with`, e.g. users→posts→comments): the relations declared ON THIS
+     * relation's CHILD rows — a grandchild batch keyed by this relation's own result rows (level ≥ 3).
+     * Each is a normal {@link RelationDecl} whose parent is THIS relation's target table. The batch stays
+     * N+1-free per level (one query per depth): a per-language codegen lowers the chain as a batched map
+     * off the parent relation's node; the runtime resolves the flattened child keys once per level. Absent
+     * for a leaf (2-level) relation — additive, so existing single-level relations are byte-unchanged.
+     */
+    readonly childRelations?: readonly RelationDecl[];
     /**
      * CROSS-DB relations (V0 R1): the NAME of the connection the batch SELECT must execute against —
      * the TARGET model's DB, which may differ from the parent's (v1 `LazyRelation.ts:236` runs a
@@ -97,12 +118,46 @@ export interface RelationOp {
      */
     readonly connection?: string;
     /**
-     * The batched child SELECT as STATIC makeSQL text. Single-key: ONE `?` binds the deduped
-     * parent-key set (PG `= ANY(?::t[])` / MySQL·SQLite single-JSON). Composite: PG binds ONE array
-     * param PER key column (`unnest(?::t1[], ?::t2[])`); MySQL·SQLite bind ONE JSON array-of-tuples
-     * param. Value-length-independent either way, so `sql` is fixed.
+     * The batched child SELECT as STATIC makeSQL text. ONE `?` binds the deduped parent-key set on
+     * every dialect and arity: single-key as the scalar set (PG `= ANY(?::t[])` / MySQL·SQLite
+     * single-JSON), composite as the ONE array-of-tuples JSON param every dialect expands server-side
+     * (PG `json_array_elements`, MySQL `JSON_TABLE`, SQLite `json_each`). Value-length-independent, so
+     * `sql` is fixed — and the key set is exactly the ONE array the `pluck` leaf yields.
      */
     readonly sql: string;
+    /**
+     * The child (target) table + projected columns (issue #59) — carried for diagnostics + as the
+     * basis of the baked `materializers` map. Additive/optional.
+     */
+    readonly targetTable?: string;
+    readonly select?: readonly string[];
+    /**
+     * CHAINED relations (nested `with`): the COMPILED grandchild relation ops keyed off THIS relation's
+     * child rows (level ≥ 3). Present iff the decl carried {@link RelationDecl.childRelations}. A codegen
+     * lowering injects each as a batched map off this relation's node (N+1-free per level); the mode-2
+     * flat-batch runtime does not recurse into it (single-level). Additive — absent for leaf relations.
+     */
+    readonly childRelations?: readonly RelationOp[];
+    /**
+     * The child columns' STATIC materialize classes (issue #59): `column → MaterializeClass`, baked
+     * at compile from the model's DDL resolver (only non-passthrough entries). The relation batch runs
+     * these over its child rows so a BIGINT/DATE/BOOLEAN child de-boxes identically to the primary
+     * read — with ZERO per-read DB introspection. Absent ⇒ the child rows stay raw (no schema).
+     */
+    readonly materializers?: Readonly<Record<string, MaterializeClass>>;
+    /**
+     * Hard-limit runaway cap (Phase E-2, epic #74; v1 `_selectForRelation` `hasManyHardLimit`): the
+     * effective per-batch row cap RESOLVED at compile (per-relation override → global). When the batch
+     * fetches MORE than this TOTAL, {@link import('./errors').LimitExceededError} is raised
+     * (`context: 'relation'`, EXACT count) — by {@link runRelationOp} on the typed-object / lazy
+     * surface, and by the `executeSQL` leaf on the CODEGEN surface, where the emitter bakes this cap
+     * into the child fetch's `guard` port (the raw child rows are only visible there, before `group`).
+     * BOTH read it through {@link relationGuard} + `assertRelationHardLimit`, so neither the cap nor the
+     * error identity can drift between surfaces or languages. Absent ⇒ no check (disabled, or a relation
+     * with an intrinsic per-parent `limit` window whose fanout is already bounded).
+     * See {@link import('./limit-config').resolveHasManyHardLimit}.
+     */
+    readonly hardLimit?: number;
 }
 /** The reserved input head the relation batch query binds its deduped key array to. */
 export declare const RELATION_KEYS_HEAD = "__keys";
@@ -114,15 +169,30 @@ export declare const RELATION_KEYS_HEAD = "__keys";
  * LATERAL (PG) / ROW_NUMBER (MySQL·SQLite) form. The SQL text is FIXED (the array binds as one
  * param regardless of length), so it needs no per-input recompile.
  */
-export declare function compileRelationOp(decl: RelationDecl): RelationOp;
+export declare function compileRelationOp(decl: RelationDecl, resolveColumnType?: ColumnTypeResolver): RelationOp;
 /** A minimal read-only driver surface (`prepare(sql).all(...params)`), the SQLite `Database`. */
 export interface RelationDriver {
     prepare(sql: string): {
         all(...params: unknown[]): unknown[];
+        safeIntegers?(v: boolean): unknown;
     };
 }
+/** A relation batch runs against either a raw {@link RelationDriver} or a full {@link ExecutionContext}. */
+export type RelationTarget = RelationDriver | ExecutionContext;
 /** The child rows grouped for a batch: parent-key value (stringified) → child rows. */
 export type RelationBatch = Map<string, Record<string, unknown>[]>;
+/** The ordered PARENT key columns of an op (single-key → 1-element list; composite → the tuple). */
+export declare function parentKeyCols(op: RelationOp): readonly string[];
+/** The ordered CHILD key columns of an op (single-key → 1-element list; composite → the tuple). */
+export declare function targetKeyCols(op: RelationOp): readonly string[];
+/**
+ * The op's RELATION RUNAWAY GUARD, or `null` when it baked none (disabled, or an intrinsic per-parent
+ * `limit` window whose fanout is already bounded). The ONE projection of a compiled op onto the
+ * {@link RelationGuard} record — read by BOTH consumers of the cap: {@link runRelationOp} (the
+ * typed-object / lazy batch) and the emitter, which bakes this record into the generated child fetch's
+ * `guard` port so the leaf enforces the SAME resolved cap. Nothing downstream re-derives it.
+ */
+export declare function relationGuard(op: RelationOp): RelationGuard | null;
 /**
  * Run ONE {@link RelationOp} for a set of parent rows: dedup the parent-key tuples, render the
  * STATIC batch SELECT once (dialect placeholder form) resolving the deferred PG array cast(s) from
@@ -133,16 +203,17 @@ export type RelationBatch = Map<string, Record<string, unknown>[]>;
  * Returns `{ sql, keys, batch }` (`keys` = the deduped parent-key tuples). An empty key set issues
  * NO query (the correct empty-set behavior — the membership over no keys selects nothing).
  */
-export declare function runRelationOp(op: RelationOp, parents: readonly Record<string, unknown>[], db: RelationDriver): {
+export declare function runRelationOp(op: RelationOp, parents: readonly Record<string, unknown>[], db: RelationTarget): {
     sql: string;
     keys: unknown[][];
     batch: RelationBatch;
 };
 /**
  * Distribute a resolved {@link RelationBatch} onto ONE parent per the relation cardinality:
- * `hasMany` → the child list (`[]` when none); `belongsTo`/`hasOne` → the single child (or
- * `null`). Keyed by the parent's key-tuple identity. `null`/`[]` is the declared cardinality's
- * empty representation, not an ad-hoc default.
+ * `hasMany` → the child list (`[]` when none); `belongsTo`/`hasOne` → the single child (or `null`).
+ * A thin consumer over the shared grouping SSoT ({@link attachToParent}) — the SAME core the eager
+ * `group` leaf uses (no duplicated grouping). `null`/`[]` is the declared cardinality's empty
+ * representation, not an ad-hoc default.
  */
 export declare function distributeToParent(op: RelationOp, parent: Record<string, unknown>, batch: RelationBatch): Record<string, unknown>[] | Record<string, unknown> | null;
 //# sourceMappingURL=relation.d.ts.map

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

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