@jarenjs/db 0.49.2 → 0.56.0

package/dist/types/jobs.d.ts

@@ -1,140 +0,0 @@
-/**
- * @file The durable job queue (JOBS-FORMAT): enqueue, the
- * single-statement guarded claim (§3 — one statement is one
- * transaction, so no double-claim without any distributed lock),
- * retry with exponential backoff and jitter (§4), recovery as
- * re-claim of expired leases (§5), polling workers with same-process
- * wake-on-enqueue (§6), and the per-job flow checkpoint store the DAG
- * composition binds (§7) — completion marks the job done and records
- * the result in ONE guarded transaction.
- *
- * Every worker transition is guarded by `state='leased' AND
- * lease_owner=?`: execution is at-least-once, completion is
- * exactly-once. `now` and `random` are injectable — the runtime
- * defaults are the clock and `Math.random`; every test injects.
- *
- * The worker LIFECYCLE holds two invariants that a long-running process
- * depends on, and neither is a detail:
- *
- *  - **No handler value can break the loop.** A handler is host code and
- *    may resolve with something JSON cannot express, or reject with a
- *    value whose own `message` throws when read. Both are normalized
- *    totally, and `runOne` is isolated inside the loop, so the worst a
- *    single job can do is fail its own attempt. A rejected claim-execute
- *    loop would stop draining the queue silently.
- *  - **Shutdown is bounded.** Handlers receive an `AbortSignal` and
- *    `stop()` takes a deadline, so a handler that never settles cannot
- *    hold `stop()` — and therefore `store.close()`, and therefore the
- *    database file — open forever. A loop the deadline could not drain
- *    is CANCELLED, not merely left behind: when its handler finally
- *    settles it exits without another claim, store write or poll
- *    timer, and its abandoned job recovers by lease expiry (§5).
- */
-export declare const JOBS_TABLE = "_jaren_jobs";
-export declare const JOB_CHECKPOINTS_TABLE = "_jaren_job_checkpoints";
-/** §4 defaults, all overridable per worker. */
-export declare const JOB_DEFAULTS: Readonly<{
-    maxAttempts: 5;
-    leaseMs: 30000;
-    pollInterval: 500;
-    backoffBase: 1000;
-    backoffCap: 60000;
-    /** How long `stop()` waits for in-flight handlers after signalling
-     * abort, before it stops waiting and reports what is still running.
-     * Bounded on purpose: an unbounded wait makes one stuck handler
-     * indistinguishable from a hung process. */
-    stopGraceMs: 5000;
-}>;
-/**
- * A diagnostic string for ANY value, including ones that fight back — a
- * getter that throws, a null-prototype object, a revoked proxy, a
- * symbol. Total by construction: an error report is never the thing that
- * fails.
- * @param {any} value
- * @returns {string}
- */
-export declare function describeValue(value: any): string;
-/**
- * JSON text for a job result, or `null` when the value cannot be
- * expressed — a BigInt, a cycle, a `toJSON` that throws. The caller
- * treats that as a failed attempt, never as a broken worker.
- * @param {any} value
- * @returns {{ text: string | null } | { reason: string }}
- */
-export declare function serializeResult(value: any): {
-    text: string | null;
-} | {
-    reason: string;
-};
-/**
- * The queue engine over one open connection.
- * @param {{ connection: any, now?: () => number,
- *   random?: () => number,
- *   defaults?: Partial<typeof JOB_DEFAULTS> }} options
- */
-export declare function createJobEngine(options: {
-    connection: any;
-    now?: () => number;
-    random?: () => number;
-    defaults?: Partial<typeof JOB_DEFAULTS>;
-}): {
-    ready: any;
-    enqueue: (kind: any, payload: any, enqueueOptions: any) => any;
-    get: (id: any) => any;
-    counts: () => any;
-    claim: (claimOptions: {
-        kinds: string[];
-        owner: string;
-        leaseMs?: number;
-    }) => any;
-    complete: (id: any, owner: any, result: any) => any;
-    fail: (id: any, owner: any, error: any, workerDefaults: any) => any;
-    checkpointsFor: (job: {
-        id: string;
-        leaseOwner: string | null;
-    }) => {
-        load: (runId: any) => any;
-        save: (runId: any, nodeId: any, value: any) => any;
-        complete: (runId: any, result: any) => any;
-    };
-    createWorker: (workerOptions: {
-        handlers: Record<string, Function>;
-        concurrency?: number;
-        pollInterval?: number;
-        leaseMs?: number;
-        owner?: string;
-        backoffBase?: number;
-        backoffCap?: number;
-    }) => {
-        stats: () => {
-            claims: number;
-            completions: number;
-            failures: number;
-            polls: number;
-            wakes: number;
-            inFlight: number;
-        };
-        start(): /*elided*/ any;
-        /**
-         * Stop claiming, signal in-flight handlers to abort, and wait for
-         * the loops — but only up to `graceMs`. A handler that ignores its
-         * signal cannot hold the process open; the resolved record says so
-         * instead, and the lease expiry (§5) lets another worker re-claim.
-         * A loop the grace period could not drain is cancelled outright:
-         * when its handler finally settles it exits without another
-         * claim, store write or poll timer.
-         * @param {{ graceMs?: number }} [stopOptions]
-         * @returns {Promise<{ drained: boolean, inFlight: number }>}
-         */
-        stop(stopOptions?: {
-            graceMs?: number;
-        }): Promise<{
-            drained: boolean;
-            inFlight: number;
-        }>;
-    };
-    /** Stop every worker, bounded. Resolves to the per-worker outcome so
-     * `close()` can report a handler it could not wait out rather than
-     * hanging on it. */
-    stopAll: (stopOptions: any) => Promise<any[]>;
-};

package/dist/types/knn.d.ts

@@ -1,69 +0,0 @@
-/**
- * @file The candidate cut of a k-nearest plan: the arithmetic between
- * the scores a statement fetched and the row identities the engine
- * will decide over. No vector arithmetic lives here — a score is
- * `derive.js`'s, through `@jarenjs/core/vector` — and no SQL: the
- * fetch of the winners is the dialect's. This is the one place the
- * margin is applied and the one place candidate identities are
- * batched for it.
- */
-/**
- * The inclusive score margin of the cut. The column's score is a dot
- * product over binary32-normalized forms; the engine's key is the
- * cosine of the raw doubles; measured, the two differ by at most
- * ~1e-8. Any margin of at least twice that makes the engine's top
- * `offset + limit` a SUBSET of the candidates: were a row the engine
- * ranks inside the window cut, some candidate the engine ranks outside
- * it would have to score higher by the column and lower by the engine,
- * which two scores within half the margin of each other cannot do.
- * This is a hundred times that bound — it admits, in practice, only
- * true ties, and those the engine breaks by the document's own keys.
- */
-export declare const KNN_MARGIN = 0.000001;
-/**
- * The most identities one fetch statement binds: under the parameter
- * cap of every SQLite build the store runs on. A guard, not a design —
- * a k-nearest window is a handful of rows, and this only matters for a
- * collection of many exact duplicates.
- */
-export declare const IDENTITY_CHUNK = 512;
-/**
- * The rows a k-nearest window can contain, from the scored fetch.
- *
- * `m = offset + limit` rows are needed. When at least `m` rows scored,
- * the candidates are every scored row within `margin` of the m-th best
- * score — ties at the boundary included by construction. When fewer
- * did, the window reaches the unrankable tail (NULL columns, or a
- * collection smaller than the window), which only the documents can
- * order: every row is then a candidate, and the collection is no
- * larger than the window.
- * @param {{ identity: any, score: number | null }[]} rows - one per
- *   fetched row; `score` is `null` where the column held no vector
- * @param {number} m - `offset + limit`
- * @param {number} margin
- * @returns {{ identities: any[], scored: number, full: boolean }} the
- *   candidate identities in ascending identity order — the
- *   collection's own order, which a stable sort over the candidates
- *   must see — with how many rows scored and whether every row was
- *   taken
- */
-export declare function cutCandidates(rows: {
-    identity: any;
-    score: number | null;
-}[], m: number, margin: number): {
-    identities: any[];
-    scored: number;
-    full: boolean;
-};
-/**
- * The identities sliced into fetch batches: at most `IDENTITY_CHUNK`
- * each, and each padded with `null` to the next power of two — a NULL
- * in an IN list matches no row — so a handful of prepared statements
- * serve every candidate count instead of one per count seen.
- * @param {any[]} identities - in the order they should be fetched
- * @returns {{ size: number, params: any[] }[]}
- */
-export declare function identityBatches(identities: any[]): {
-    size: number;
-    params: any[];
-}[];

package/dist/types/live-time.d.ts

@@ -1,141 +0,0 @@
-/**
- * @file Event-time live views (LIVE-FORMAT §13): a `$resample` or
- * `$rolling` document over a collection, maintained against an
- * explicit watermark.
- *
- * There is no clock in this file, and there is none anywhere under it.
- * A live view over time needs to know what "now" is — which bucket is
- * still open, which reading counts as late — and the only honest
- * source of that is the host, because the machine's clock is a
- * different quantity from the instant a reading carries. So the
- * watermark ARRIVES: it is a finite epoch supplied at registration and
- * moved forward by `advance()`, it never goes backwards, and a test can
- * put it wherever the story needs it without waiting for a timer.
- *
- * What the maintenance actually does:
- *
- *  - **A bucket view keeps its rows by bucket.** A write touches one
- *   bucket (two, when it moves a reading across a boundary), and only
- *   those are folded again — through `resampleSeries` itself, over that
- *   bucket's own rows, so the aggregate is the kernel's and cannot
- *   drift from what a fresh query would answer.
- *  - **A rolling view keeps its rows in instant order.** A write at `t`
- *   can only change the windows ending in `[t, t + width)`, so exactly
- *   that stretch is recomputed — again by the kernel, over the slice
- *   that stretch can see.
- *
- * And what it refuses. A calendar ladder walks a wall clock, a named
- * zone needs host code, `locf`/`linear` couple every bucket to its
- * neighbours, and `first`/`last` name a row by a position a maintained
- * map does not preserve. Each of those re-runs with its own reason
- * rather than being approximated. So does a reading older than the
- * declared lateness: the view re-runs, the emission carries a
- * `lateData` record naming the instant and the boundary, and the row is
- * never quietly folded into a bucket its reader already believed
- * closed.
- *
- * `retention` is the horizon this view claims to work over. It is
- * checked, not assumed: it must cover a whole window plus the lateness
- * the caller allows, which is the span a single repair can read. It is
- * NOT a compaction policy — the maintained state is bounded by
- * `live.maxMaintained` exactly as every other strategy's is, and this
- * file drops nothing that an answer still depends on.
- */
-/**
- * Validate the `eventTime` option into the record the classifier and
- * the strategies read, or `null` when the caller declared none.
- * @param {any} options - the live options
- * @param {string} collection - for the error's `collection` property
- * @returns {null | { member: string, watermark: number,
- *   allowedLateness: number, retention: number }}
- * @throws {DbCompileError} `JD0053` for any member this does not admit
- */
-export declare function normalizeEventTime(options: any, collection: string): null | {
-    member: string;
-    watermark: number;
-    allowedLateness: number;
-    retention: number;
-};
-/**
- * Classify a document as an event-time view, or say why it is not one.
- *
- * Returns `null` when the document does not name `$resample` or
- * `$rolling` over this collection at all — the caller then goes on to
- * §7's ordinary table. Every other outcome is a decision: a maintained
- * description, or `{ strategy: 'rerun', reason }`.
- * @param {any} inner - the unwrapped document
- * @param {boolean} windowed - whether a `$subsequence` wrapped it
- * @param {boolean} keyed
- * @param {null | { member: string, watermark: number,
- *   allowedLateness: number, retention: number }} eventTime
- * @returns {any}
- */
-export declare function classifyEventTime(inner: any, windowed: boolean, keyed: boolean, eventTime: null | {
-    member: string;
-    watermark: number;
-    allowedLateness: number;
-    retention: number;
-}): any;
-/**
- * `$resample` over a fixed ladder: one maintained fold per bucket.
- * @param {any} description
- * @param {any} context
- */
-export declare function bucketStrategy(description: any, context: any): {
-    advance: (next: any) => void;
-    stats: () => {
-        lateData: number;
-        reruns: number;
-        recomputes: number;
-        watermark: any;
-    };
-    entries: () => number;
-    init: () => any;
-    apply(record: any): {
-        rebuild: boolean;
-        late: any;
-        rows?: undefined;
-    } | {
-        rebuild?: undefined;
-        late?: undefined;
-        rows: {
-            at: any;
-            value: number | null;
-            count: number;
-        }[] | ({
-            at: number;
-            value: number | null;
-            count: number;
-        } | undefined)[];
-    } | null;
-    /** A re-run rebuilds the whole state from the store — the only
-     * answer to a reading the maintained state cannot place. */
-    rebuild(): any;
-};
-/**
- * `$rolling` over a fixed width: one output per input instant, with
- * only the stretch a write can reach recomputed.
- * @param {any} description
- * @param {any} context
- */
-export declare function rollingStrategy(description: any, context: any): {
-    advance: (next: any) => void;
-    stats: () => {
-        lateData: number;
-        reruns: number;
-        recomputes: number;
-        watermark: any;
-    };
-    entries: () => number;
-    init: () => any;
-    apply(record: any): {
-        rows?: undefined;
-        rebuild: boolean;
-        late: any;
-    } | {
-        rebuild?: undefined;
-        late?: undefined;
-        rows: any[];
-    } | null;
-    rebuild(): any;
-};

package/dist/types/live.d.ts

@@ -1,64 +0,0 @@
-/**
- * @file Live queries (LIVE-FORMAT §§7–12): a registered query document
- * whose result is maintained as capture records arrive, emitting
- * RFC 6902 patches against its own `{ rows }` result document.
- *
- * The CLASSIFIER implements §7's normative table and nothing more —
- * it unwraps the one-element array pack and literal `$subsequence`
- * windows the same way the planner does, then reads the compiled
- * plan: translated filters, order terms and aggregates are exactly
- * the planner's, never a re-implementation. Everything outside the
- * table re-runs on invalidation with the reason named (`live.mode`).
- *
- * Maintenance is synchronous inside capture delivery (§8): inserts
- * carry their document in the patch, updates point-read the touched
- * row, deletes are answered from maintained state. Per-row semantics
- * reuse the ENGINE via packed one-row compilation (the residual
- * discipline) — a live row evaluates exactly as the query would.
- */
-/** The store-level live bounds and their defaults (§12: printed,
- * never silent). */
-export declare const LIVE_DEFAULTS: Readonly<{
-    maxQueries: 64;
-    maxMaintained: 10000;
-}>;
-/**
- * Classify a collection query document against §7's table. Pure —
- * given the document and the collection's planner shape, returns the
- * strategy description, or a re-run description with the reason.
- * @param {any} document
- * @param {any} queryShape - the planner shape (collection, schema,
- *   columnByCanonical)
- * @param {boolean} keyed - whether documents carry their key (a
- *   declared key pointer); unkeyed rows cannot be tracked by key
- * @param {any} [eventTime] - the normalized `eventTime` option
- *   (`live-time.js`), or null when the caller declared none
- * @returns {any}
- */
-export declare function classifyLiveQuery(document: any, queryShape: any, keyed: boolean, eventTime?: any): any;
-/**
- * Diff two row arrays into sequential add/remove/replace ops under
- * `/rows`, relying on REFERENCE identity for unchanged rows (the §9
- * sharing contract makes identity the equality that matters). A
- * working copy is replayed op by op, so the emitted patch transforms
- * the old array into the new one BY CONSTRUCTION; a remove re-filled
- * at the same index merges into a replace.
- * @param {any[]} oldRows
- * @param {any[]} newRows
- * @returns {any[]} ops
- */
-export declare function diffRows(oldRows: any[], newRows: any[]): any[];
-/**
- * The store-level live-query registry: registration against the §12
- * bounds, capture-record delivery in commit order, lifecycle.
- * @param {{ maxQueries: number, maxMaintained: number }} bounds
- */
-export declare function createLiveRegistry(bounds: {
-    maxQueries: number;
-    maxMaintained: number;
-}): {
-    register: (definition: any) => any;
-    count: () => number;
-    deliver(record: any): void;
-    closeAll(): void;
-};

package/dist/types/migrate.d.ts

@@ -1,170 +0,0 @@
-/**
- * @file Document migrations (D12): two model documents diff into a
- * migration document whose steps are rendered DDL, JSLT data
- * transforms and query assertions; the migration replays on a shadow
- * database first; a history table records what ran with a
- * signature-grade checksum. This is the phase-A payoff for storing
- * documents rather than rows: a shape change is a transformation of
- * VALUES, not a table rebuild.
- *
- * Identity is a hash, not a version number: `from`/`to` are
- * `hashContent(canonicalizeJson(model))` — the identity of a SHAPE,
- * which nobody has to remember to bump. The checksum discipline is
- * D12's: `canonicalizeJson` + `hashContent` (signature-grade — throws
- * on the unserializable), never the memo-grade `contentKey`.
- *
- * Like the query emitter, this module is part of the emitter layer:
- * the structural SQL it composes (the history table's statements, the
- * batched row walk) is built from dialect primitives, and every
- * planner-produced statement is rendered by the dialect into the
- * migration DOCUMENT — shown before it is ever executed.
- */
-/** The migration format version. */
-export declare const MIGRATION_VERSION = "0.1";
-/** The history table name (outside the model's identifier namespace
- * conventions on purpose — a collection cannot collide with it). */
-export declare const HISTORY_TABLE = "_jaren_migrations";
-/**
- * The signature-grade identity of a model SHAPE.
- * @param {any} model - A jaren-model document
- * @returns {string}
- */
-export declare function shapeHash(model: any): string;
-/**
- * The signature-grade checksum of a migration document.
- * @param {any} migration
- * @returns {string}
- */
-export declare function migrationChecksum(migration: any): string;
-/**
- * Plan a migration between two model documents. The planner diffs the
- * PHYSICAL plans (columns, indexes) and renders DDL through the
- * dialect; a changed schema gets a DRAFT identity transform that
- * refuses to run until the author fills it in — the planner cannot
- * infer a data transform and does not pretend to. Renames are declared
- * (`x-rename` on the target collection), never guessed.
- * The physical mapping of a DERIVED index column depends on the driver
- * that will run the migration (`derived`), because the two mappings
- * really are different columns; a migration document planned for one is
- * not the document the other needs.
- * @param {any} fromModel
- * @param {any} toModel
- * @param {{ id?: string, dialect?: any,
- *   derived?: 'virtual' | 'stored', rtree?: boolean }} [options]
- * @returns {{ migration: any, report: {
- *   renamed: { from: string, to: string }[],
- *   added: string[], removed: string[],
- *   schemaChanged: string[], drafts: string[],
- *   destructive: boolean } }}
- */
-export declare function planMigration(fromModel: any, toModel: any, options?: {
-    id?: string;
-    dialect?: any;
-    derived?: 'virtual' | 'stored';
-    rtree?: boolean;
-}): {
-    migration: any;
-    report: {
-        renamed: {
-            from: string;
-            to: string;
-        }[];
-        added: string[];
-        removed: string[];
-        schemaChanged: string[];
-        drafts: string[];
-        destructive: boolean;
-    };
-};
-/** `planMigration` handles the whole model — collections AND entities
- * — since the relational order; this name says so. */
-export declare const planModelMigration: typeof planMigration;
-/**
- * Create a model's WHOLE physical shape on a connection: collections,
- * entity tables and join tables, exactly as `openStore` would. Used
- * by the shadow baseline, the fresh reference database that shape
- * equality compares against, and the tests.
- * @param {any} connection
- * @param {any} model
- * @returns {any} value-or-promise
- */
-export declare function createModelShape(connection: any, model: any): any;
-/**
- * The declared schema of a database, normalized for comparison: every
- * object carrying SQL text (tables, indexes), whitespace-collapsed,
- * history table excluded, sorted. Shape equality after a migration —
- * this dump versus a fresh {@link createModelShape} — is the
- * acceptance criterion for every rebuild.
- * @param {any} connection
- * @returns {any} value-or-promise of `{ type, name, owner, sql }[]`
- */
-export declare function schemaShapeOf(connection: any): any;
-/**
- * Compare a migrated database's schema against the shape a fresh
- * `createModelShape(model)` produces, via a throwaway reference
- * database. Returns `null` when equal, or a one-line difference.
- * @param {any} driver
- * @param {any} connection - the migrated database
- * @param {any} model - the target model
- * @param {((connection: any) => any) | undefined} registerFunctions
- * @returns {any} value-or-promise of `string | null`
- */
-export declare function compareShapeToModel(driver: any, connection: any, model: any, registerFunctions: ((connection: any) => any) | undefined): any;
-/**
- * Report a database's migration state without touching it: what is
- * applied, what is pending, whether an applied migration was edited,
- * and — once the chain is fully applied — whether the physical shape
- * DRIFTED from the model (someone changed the database by hand, §12).
- * @param {{ driver: any, path?: string }} target
- * @param {any[]} migrations - the full ordered list
- * @param {{ baseline: any, model?: any,
- *   registerFunctions?: (connection: any) => any }} options
- * @returns {Promise<{ applied: string[], pending: string[],
- *   drift: string | null, upToDate: boolean }>}
- */
-export declare function migrationStatus(target: {
-    driver: any;
-    path?: string;
-}, migrations: any[], options: {
-    baseline: any;
-    model?: any;
-    registerFunctions?: (connection: any) => any;
-}): Promise<{
-    applied: string[];
-    pending: string[];
-    drift: string | null;
-    upToDate: boolean;
-}>;
-/**
- * Apply pending migrations to a database.
- *
- * The contract: `migrations` is the FULL ordered list (applied and
- * pending — the migrations directory); `baseline` is the model the
- * store was first created with (the chain's anchor and the shadow's
- * starting shape); `model` is the target model the code now carries.
- * Each pending migration runs in ONE exclusive transaction with a
- * savepoint per step; a failing step rolls the whole migration back.
- * The whole chain replays on a `:memory:` shadow before the real
- * store is touched.
- *
- * @param {{ driver: any, path?: string, busyTimeout?: number }} target
- * @param {any[]} migrations
- * @param {{ baseline: any, model?: any, compileSchema?: Function,
- *   dryRun?: boolean, batchSize?: number, onProgress?: Function,
- *   shadow?: boolean, shadowPath?: string }} options
- * @returns {Promise<any>}
- */
-export declare function migrate(target: {
-    driver: any;
-    path?: string;
-    busyTimeout?: number;
-}, migrations: any[], options: {
-    baseline: any;
-    model?: any;
-    compileSchema?: Function;
-    dryRun?: boolean;
-    batchSize?: number;
-    onProgress?: Function;
-    shadow?: boolean;
-    shadowPath?: string;
-}): Promise<any>;

package/dist/types/model.d.ts

@@ -1,36 +0,0 @@
-/**
- * @file The entity model walk: `x-entity` normalization with a CLOSED
- * vocabulary, relation resolution with inverse agreement, and
- * `explainMapping` — the derived physical shape as plain data, so the
- * hybrid mapping rule is golden-testable rather than folklore.
- *
- * THE DESCENT DECISION (recorded here because TODO's D22 demands it
- * be explicit): six copies of the `properties`/`prefixItems`/`items`/
- * `allOf` descent spine exist in this repository, and this walk was
- * the candidate seventh. It is NOT one. The entity walk is
- * deliberately ONE level deep — it enumerates the TOP-LEVEL
- * properties of an entity schema, resolves `$ref` and shallow-merges
- * `allOf` at each property through the resolvers
- * `@jarenjs/validate/normalize` exports for exactly this purpose, and
- * never recurses further, because the mapping rule sends every nested
- * shape to the JSONB document wholesale. A consumer with no recursion
- * has no descent spine to share, so the shared-enumerator question
- * (three different termination strategies across the six copies)
- * stays open for the first consumer that actually recurses. No
- * seventh copy was added.
- */
-/**
- * Normalize the `entities` member of a model document.
- * @param {any} model
- * @returns {Map<string, any>} entity name -> normalized entity
- */
-export declare function normalizeEntities(model: any): Map<string, any>;
-/**
- * The hybrid mapping, derived mechanically from §9.3's table and
- * returned as DATA: per entity, the columns (name, type, source),
- * the checks, the foreign keys, the indexes, and which properties
- * live in the JSONB document.
- * @param {any} model - a model document with `entities`
- * @returns {any}
- */
-export declare function explainMapping(model: any): any;

package/dist/types/patch-sql.d.ts

@@ -1,37 +0,0 @@
-/**
- * @file RFC 6902 → dialect JSON-set primitives, so a one-field update
- * does not rewrite a large document. The translation is decided
- * AGAINST THE LIVE DOCUMENT: an RFC 6901 pointer cannot say whether
- * `/a/0` names an array position or an object member called `"0"`, so
- * each segment is discriminated by walking the document the patch was
- * validated against, and the walked state is advanced op by op so a
- * later operation sees what the earlier ones produced.
- *
- * Translatable in 0.1: `replace` anywhere, `add` of an object member,
- * `add` at an array's end (`/-` or the index equal to its length), and
- * `remove`. Everything else — `test`, `move`, `copy`, a mid-array
- * insert (the shift has no single JSON-function spelling) — returns
- * `null` and the store falls back to a whole-document write. The
- * fallback is counted and exposed by the store, measured rather than
- * assumed.
- */
-export type JsonPathSegment = import('./dialect.js').JsonPathSegment;
-/**
- * Translate a whole patch into a dialect expression builder, or `null`
- * when any operation needs the whole-document fallback. The caller has
- * already applied the patch in memory (the copy-on-write engine
- * validates the RESULT); this translation only decides how the same
- * outcome reaches the database.
- * @param {any[]} ops - RFC 6902 operations, already known applicable
- * @param {any} doc - The stored document the patch applies to
- * @param {any} dialect
- * @returns {{ build: (docColumnSql: string,
- *   parameterIndexBase: number) => { expression: string,
- *   params: string[] } } | null}
- */
-export declare function translatePatch(ops: any[], doc: any, dialect: any): {
-    build: (docColumnSql: string, parameterIndexBase: number) => {
-        expression: string;
-        params: string[];
-    };
-} | null;