@jarenjs/db 0.49.2 → 0.66.1

package/dist/types/errors.d.ts

@@ -1,170 +0,0 @@
-/**
- * @file Error types for @jarenjs/db, built on `@jarenjs/core`'s coded
- * contract: every failure carries a stable `code` (JD0xxx compile-time,
- * JD2xxx runtime), a bare `reason`, a composed `message`, and — where a
- * position in the model document exists — a `docPath`. Runtime errors
- * additionally carry the `collection` and, where one exists, the `key`
- * as own properties. Database errors are wrapped, never leaked raw: the
- * reason keeps the original text, `cause` keeps the original error. The
- * normative table lives in docs/MODEL-FORMAT.md §7, proven in sync with
- * `DB_CODES` below by a test.
- */
-import { CodedError } from '@jarenjs/core/errors';
-/**
- * The runtime code table (the `CSV_CODES` shape): one entry per code
- * this package can raise, proven in sync with MODEL-FORMAT.md §7's
- * normative table by a test.
- */
-export declare const DB_CODES: Readonly<{
-    JD0001: "the SQLite library is below the supported floor";
-    JD0002: "the declared model disagrees with the existing database";
-    JD0003: "the driver binding is unavailable on this runtime";
-    JD0004: "a declared index cannot be mapped to a column";
-    JD0005: "the model document is invalid";
-    JD0010: "strict mode refused a residual";
-    JD0011: "the profile refused the document";
-    JD0012: "work waited too long for the open transaction to settle";
-    JD0030: "an unknown x-entity member was declared";
-    JD0031: "relation declarations contradict each other";
-    JD0032: "the include specification is invalid";
-    JD0040: "the save spans a relation cycle";
-    JD0050: "live queries require change capture";
-    JD0051: "the demanded live mode is unavailable";
-    JD0052: "the live-query bound was reached";
-    JD0053: "the live event-time declaration is invalid";
-    JD0020: "the migration's from-shape does not match the database";
-    JD0021: "the migration is missing a required data transform";
-    JD0022: "an applied migration disagrees with the history record";
-    JD0023: "a migration step failed";
-    JD2001: "insert found the key already present";
-    JD2002: "a usable key could not be resolved for the write";
-    JD2003: "the write failed schema validation";
-    JD2004: "an undeclared collection was requested";
-    JD2005: "a database operation failed";
-    JD2006: "patch found no document at the key";
-    JD2007: "the result exceeded the profile row bound";
-    JD2040: "the row changed under an optimistic update";
-    JD2050: "a changeset could not be decoded";
-    JD2051: "the change log is not enabled";
-    JD2060: "the maintained live state exceeded its bound";
-    JD2061: "another context owns the database";
-    JD2062: "the store closed with job handlers still in flight";
-}>;
-/**
- * A defect found while opening a store — in the model document, the
- * declared indexes, the driver binding, or the database's agreement
- * with the declaration. Codes:
- *
- *  - `JD0001` — the SQLite library reported a version below the
- *    supported floor; the reason names the version found
- *  - `JD0002` — a declared collection already exists in the database
- *    with a different shape; nothing was altered — changing shape is
- *    the migration story, a later capability
- *  - `JD0003` — the runtime builtin behind a driver could not be
- *    loaded here (Node cannot resolve `bun:`; Bun ships no
- *    `node:sqlite`), or an injected handle is missing
- *  - `JD0004` — a declared index cannot be mapped to a column: its
- *    path does not select exactly one member (wildcards, slices,
- *    filters and descendants are not indexable), or its `derive`
- *    declaration is not one the storage vocabulary carries; the reason
- *    names the expression or the member and `docPath` points at it
- *  - `JD0005` — the model document is invalid; `docPath` points at
- *    the offending member
- *  - `JD0010` — `strict: true` and part of the query would have run
- *    outside the database; the reason names the forcing construct
- *  - `JD0011` — the active profile refused the document before any
- *    execution: an undeclared external, host function, collation or
- *    collection, or a refused full-table scan; the reason names it
- *  - `JD0030` — an unknown member inside an `x-entity` block; a
- *    silently ignored mapping directive is a data-loss bug waiting
- *  - `JD0031` — two relation declarations whose inverses contradict
- *    (different `via`, impossible `many` pairings)
- *  - `JD0032` — a graph-load include specification is invalid: an
- *    unknown relation, a cycle, an untranslatable filter, or the
- *    depth bound exceeded (the bound is printed, never silent)
- *  - `JD0040` — `saveChanges()` cannot order its statements: the
- *    entities being inserted or deleted form a foreign-key cycle
- *    (self-references included); break the save in two
- *  - `JD0050` — a live query was registered on a store opened without
- *    `capture`; the patch stream is the invalidation source
- *  - `JD0051` — `mode: 'incremental'` was demanded but the document
- *    classifies as re-run; the reason names the forcing construct
- *  - `JD0052` — registering would exceed the store's `live.maxQueries`
- *    bound; the bound is printed, never silent
- *  - `JD0053` — a live query's `eventTime` names a member it does not
- *    admit, or a watermark/retention that is not a finite span
- *  - `JD0020` — a migration's `from` hash does not match the
- *    database's recorded shape; running it would corrupt
- *  - `JD0021` — a draft transform was not filled in, or a document no
- *    longer validates after the migration (a narrowing without an
- *    adequate transform)
- *  - `JD0022` — the migration list disagrees with the applied history
- *    (an edited file, a missing file, a reordered sequence)
- *  - `JD0023` — a step failed: an assertion returned rows, DDL was
- *    rejected, or a transform produced an unstorable value
- */
-export declare class DbCompileError extends CodedError {
-    /**
-     * @param {string} code
-     * @param {string} reason - The bare reason; `message` is composed per
-     *   the coded contract.
-     * @param {string} [docPath] - JSON Pointer into the model document,
-     *   where one exists.
-     * @param {Error} [cause]
-     */
-    constructor(code: string, reason: string, docPath?: string, cause?: Error);
-}
-/**
- * A failure while reading or writing an open store. Codes:
- *
- *  - `JD2001` — `insert` hit a document already stored under the key
- *  - `JD2002` — the declared key pointer resolved to nothing or to a
- *    non-scalar, or an explicit key argument is not a string or number
- *  - `JD2003` — the injected validation hook rejected the document
- *    that a write would have stored; `errors` carries the hook's
- *    findings when it produced any
- *  - `JD2004` — `collection()` named a collection the model does not
- *    declare
- *  - `JD2005` — the database rejected an operation for a reason that
- *    is not a duplicate key; the original error is the `cause`
- *  - `JD2006` — `patch` addressed a key with no stored document
- *  - `JD2007` — a fetch crossed the profile's `maxRows` bound; the
- *    result is refused whole, never silently truncated
- *  - `JD2040` — an optimistic update or delete matched no row: the
- *    declared version changed under the save (or the row is gone);
- *    the error names the entity and key, and the whole save rolled
- *    back
- *  - `JD2050` — a session changeset carried bytes this decoder does
- *    not recognise (a future SQLite format change would land here)
- *  - `JD2051` — `changesSince` was called on a store whose capture
- *    has no persisted log
- *  - `JD2060` — maintenance crossed the live query's `maxMaintained`
- *    bound; the query delivered this error and closed rather than
- *    degrade
- *  - `JD2061` — a second context tried to open a database whose
- *    storage grants one context exclusive access (the owner topology
- *    of LIVE-FORMAT §11); connect to the owner instead
- */
-export declare class DbRuntimeError extends CodedError {
-    collection: string | undefined;
-    key: string | number | undefined;
-    errors: unknown[] | undefined;
-    /**
-     * @param {string} code
-     * @param {string} reason - The bare reason; `message` is composed per
-     *   the coded contract.
-     * @param {{ docPath?: string, collection?: string,
-     *   key?: string | number, errors?: unknown[], cause?: unknown }} [details]
-     *   - `docPath` points into the model document (the collection the
-     *   failure belongs to); `collection`/`key` are installed as own
-     *   properties; `errors` carries validation findings; `cause` follows
-     *   the coded contract's `hasOwn` form.
-     */
-    constructor(code: string, reason: string, details?: {
-        docPath?: string;
-        collection?: string;
-        key?: string | number;
-        errors?: unknown[];
-        cause?: unknown;
-    });
-}

package/dist/types/graph.d.ts

@@ -1,28 +0,0 @@
-/**
- * @file Row → entity-graph reconstruction. One place owns the merge
- * discipline (§9.3): mapped scalar columns fold back into the JSONB
- * document's parse (booleans un-integer, SQL NULL reads back ABSENT,
- * derived epoch columns are skipped because the string never left the
- * document), foreign-key columns fold in the same way, and — for the
- * one-statement graph loads — projected relation JSON parses
- * recursively into child arrays or single children.
- */
-/**
- * Merge one database row back into its entity document.
- * @param {any} entityMapping - `explainMapping(...).entities[name]`
- * @param {any} row - a row carrying the entity's columns plus the
- *   rendered document text
- * @param {string} [docField] - the column the document text rides in
- * @returns {any}
- */
-export declare function mergeEntityRow(entityMapping: any, row: any, docField?: string): any;
-/**
- * Parse one graph-load row: the root entity's merge plus every
- * included relation's projected JSON, recursively.
- * @param {any} node - the include-plan node
- *   `{ entityMapping, includes: { name, field, many, count, child }[] }`
- * @param {any} row
- * @param {string} docField
- * @returns {any}
- */
-export declare function parseGraphRow(node: any, row: any, docField?: string): any;

package/dist/types/index.d.ts

@@ -1,37 +0,0 @@
-/**
- * @file @jarenjs/db — document storage over SQLite through two seams:
- * a driver (how a connection is made: `@jarenjs/db/node`, `/bun`, or
- * `/wasm` with an injected handle) and a dialect (how SQL is spelled).
- * This root subpath never touches a runtime builtin — a browser
- * bundler resolves it clean; the bindings live behind their own
- * subpaths and load their builtin lazily inside `open()`.
- */
-export { openStore, normalizeModel, MODEL_VERSION } from './store.js';
-export { createDialect } from './dialect.js';
-export { sqliteDialect } from './dialects/sqlite.js';
-export { SQLITE_FLOOR, chain, toPromise, isThenable, compareVersions, openConnection, wrapStatement, lazyOpen, } from './driver.js';
-export { planCollection, compileIndexPath, schemaTypeAt, KEY_COLUMN, DOC_COLUMN, normalizeDeclaredSql, comparableDeclaredSql, } from './ddl.js';
-export { planQuery, assertDecidedKind, entityShape, entityPathRef, planEntityPredicate, planEntityQuery, } from './plan.js';
-export { emitPlan, createEntityPredicateEmitters, emitEntityPlan } from './emit.js';
-export { mergeEntityRow, parseGraphRow } from './graph.js';
-export { selectPlan, conjoin, assertNoSqlText, PLAN_VERSION } from './algebra.js';
-export { typeOfPath, isNumericType } from './types.js';
-export { compileSetResidual, compileRowResidual, sequenceResult } from './residual.js';
-export { deterministicFragment, registerFragment } from './udf.js';
-export { DERIVE_KINDS, DERIVE_MAPPING, PHYSICAL_KINDS, BBOX_COMPONENTS, BBOX_INDEX_ORDER, PRECISION_MIN, PRECISION_MAX, DIMS_MIN, DIMS_MAX, deriveGeohash, deriveBboxEdge, deriveVector, derivedValue, derivedMappingFor, memberAt, storedMemberForm, registerDeriveFunctions, probeVector, columnScore, } from './derive.js';
-export { KNN_MARGIN, IDENTITY_CHUNK, cutCandidates, identityBatches } from './knn.js';
-export { createQueryEngine, createQueryState, createEntityQueryEngine, createLoadEngine, INCLUDE_DEPTH_DEFAULT, } from './query.js';
-export { normalizeProfile, SAFE_PROFILE, translateProfilePredicate, applyMandatoryPredicate, applyRowBound, } from './profile.js';
-export { translatePatch } from './patch-sql.js';
-export { normalizeEntities, explainMapping } from './model.js';
-export { planEntity, planJoinTable } from './ddl.js';
-export { entityCore } from './entity.js';
-export { entityEmitModel } from './emit-model.js';
-export { parseChangeset, translateOperations, keyToken, createCaptureEngine, CHANGES_TABLE, DEFAULT_RETENTION, } from './capture.js';
-export { createTracker, deepFreeze, BATCH_PARAM_BUDGET, BATCH_ROW_BOUND, } from './tracker.js';
-export { planMigration, planModelMigration, migrate, migrationStatus, shapeHash, migrationChecksum, createModelShape, schemaShapeOf, compareShapeToModel, MIGRATION_VERSION, HISTORY_TABLE, } from './migrate.js';
-export { DbCompileError, DbRuntimeError, DB_CODES } from './errors.js';
-export { classifyLiveQuery, createLiveRegistry, diffRows, LIVE_DEFAULTS } from './live.js';
-export { createSortedWindow, compareCodepoint } from './window.js';
-export { createJobEngine, JOBS_TABLE, JOB_CHECKPOINTS_TABLE, JOB_DEFAULTS, describeValue, serializeResult, } from './jobs.js';
-export { createDagJobRunner } from './dag-job.js';

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;
-};