@jarenjs/db 0.49.2 → 0.66.1

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;

package/dist/types/plan.d.ts

@@ -1,142 +0,0 @@
-/**
- * @file AST → Plan. The planner walks the engine's PUBLISHED normalized
- * AST (never the raw document), dispatches EXHAUSTIVELY on node kind —
- * an unrecognised kind is an internal error naming the kind and the
- * `AST_VERSION`, never a silent residual — and promotes constructs to
- * native form strictly residual-by-default: everything starts as a
- * residual and earns native status only where the equivalence proof
- * exists (the truth table in ARCHITECTURE.md, pinned by the
- * differential tests).
- *
- * The outcome of planning one document:
- *
- *   { plan, mode: 'native' | 'row' | 'set' | 'knn', reasons, rowReturn,
- *     prefilters }
- *
- * - `native` — everything translated; the plan alone answers.
- * - `row`    — predicates, ordering and window pushed; only the
- *   projection runs in the engine, per fetched row (streams).
- *   `rowReturn` is the COMPLETE one-row document to run, binding
- *   included — the collection binding is named by the document, so a
- *   wrapper built anywhere else would have to guess it.
- * - `set`    — the pushed conjuncts narrow candidates; the WHOLE
- *   compiled document runs over the materialized candidates.
- * - `knn`    — the pushed conjuncts narrow, the vector column CUTS the
- *   candidates of a k-nearest window (`plan.rank`), and the whole
- *   compiled document runs over the cut — a set residual whose
- *   candidate set an ordering, not a predicate, chose (see "The
- *   k-nearest promotion" below).
- *
- * `reasons` names every construct that forced work off the database,
- * with reason text drawn from the deliberate-residual table.
- * `prefilters` names the IMPLIED conjuncts — predicates the planner
- * ADDED because a spatial one provably implies them (see "Spatial
- * promotions" below) — with the columns each reads and whether it
- * decided or merely narrowed.
- */
-/**
- * Assert a node kind is one this planner has decided. Called on every
- * dispatch; the throw names the kind and the AST version so a language
- * change breaks the build instead of becoming an accidental residual.
- * Exported so the throw itself is pinned by a test.
- * @param {any} node
- */
-export declare function assertDecidedKind(node: any): void;
-/**
- * Plan a whole document against one collection. The store's registered
- * operators (Ring 2) ride in `shape.operators` — the planner recognises
- * them as vocabulary but keeps them in the residual, and names them in
- * the reasons when it does.
- * @param {any} document - The raw query document (kept beside the AST
- *   for residual construction — the AST has no unparser)
- * @param {any} shape - { collection, schema, columnByCanonical, operators? }
- * @param {{ udf?: (fragment: any) => { name: string, key: string } | null }} [options]
- * @returns {{
- *   analysis: any,
- *   plan: import('./algebra.js').Plan | null,
- *   mode: 'native' | 'row' | 'set' | 'knn',
- *   reasons: { construct: string, reason: string }[],
- *   rowReturn: any,
- *   udfs: string[],
- *   prefilters: { construct: string, via: 'columns' | 'rtree',
- *     columns: string[], exact: boolean }[],
- *   series: any,
- * }}
- */
-export declare function planQuery(document: any, shape: any, options?: {
-    udf?: (fragment: any) => {
-        name: string;
-        key: string;
-    } | null;
-}): {
-    analysis: any;
-    plan: import('./algebra.js').Plan | null;
-    mode: 'native' | 'row' | 'set' | 'knn';
-    reasons: {
-        construct: string;
-        reason: string;
-    }[];
-    rowReturn: any;
-    udfs: string[];
-    prefilters: {
-        construct: string;
-        via: 'columns' | 'rtree';
-        columns: string[];
-        exact: boolean;
-    }[];
-    series: any;
-};
-/**
- * Build the planner shape for one entity: canonical top-level paths
- * map to REAL columns (flavor `entity-column`), epoch date columns to
- * their derived integer twins (flavor `entity-epoch`), and everything
- * else stays a document path over the entity's JSONB column (the
- * phase-A guarded forms).
- * @param {any} entity - normalized entity (model.js)
- * @param {any} entityMapping - explainMapping(...).entities[name]
- * @returns {any}
- */
-export declare function entityShape(entity: any, entityMapping: any): any;
-/**
- * Resolve a singular member path on an entity binding to a flavored
- * PlanRef.
- * @param {any} node - a path AST node
- * @param {number} slot
- * @param {any} shape - from {@link entityShape}
- * @returns {any | null}
- */
-export declare function entityPathRef(node: any, slot: number, shape: any): any | null;
-/**
- * Plan one predicate over an entity binding: the same operator
- * grammar as phase A, with entity-flavored refs. Reuses
- * {@link planPredicate} for the recognition, then re-resolves refs
- * through the flavor table.
- * @param {any} node
- * @param {number} slot
- * @param {any} shape
- * @returns {{ pred: any } | { refusal: { construct: string, reason: string } }}
- */
-export declare function planEntityPredicate(node: any, slot: number, shape: any): {
-    pred: any;
-} | {
-    refusal: {
-        construct: string;
-        reason: string;
-    };
-};
-/**
- * Plan an ENTITY query document (one planner, two document kinds). The
- * store's registered operators (Ring 2) are recognised as vocabulary and
- * kept in the set residual over the fetched root, named in the reasons.
- * @param {any} document
- * @param {Map<string, any>} entities - normalized entities
- * @param {any} mapping - explainMapping result
- * @param {{ functions?: any, extensions?: any } | null} [operators]
- * @returns {any}
- */
-export declare function planEntityQuery(document: any, entities: Map<string, any>, mapping: any, operators?: {
-    functions?: any;
-    extensions?: any;
-} | null): any;
-/** The entity names a document's root paths reference (`$.Name[*]`). */
-export declare function collectEntityRoots(document: any, entities: any): Set<any>;

package/dist/types/profile.d.ts

@@ -1,80 +0,0 @@
-/**
- * @file The safe execution profile (D15): a query document that arrives
- * from a tenant, a remote client or a language model can reach a
- * database, and injection being structurally impossible (parameter
- * binding) says nothing about resource exhaustion or cross-tenant
- * reads. A profile composes four INDEPENDENT bounds:
- *
- *  1. engine limits — `{sequenceItems, resultItems, steps, depth}`
- *     wired into every residual compilation, so the JavaScript
- *     portion of a query is bounded by the engine's own enforcement;
- *  2. the mandatory row bound — every non-aggregate fetch carries a
- *     LIMIT of `maxRows + 1`, and fetching more than `maxRows` rows is
- *     the coded `JD2007`, never a silent truncation (D14);
- *  3. reference containment — undeclared externals, host functions,
- *     collations or collections are the compile error `JD0011`; no UDF
- *     registration happens under a profile; optionally, a plan whose
- *     database narrative shows a full-table SCAN is refused;
- *  4. mandatory predicates — a per-collection predicate conjoined into
- *     EVERY plan at its root, after translation, so no document shape
- *     can produce a fetch without it.
- *
- * The non-claims are part of the contract and live in
- * MODEL-FORMAT.md §8: no statement timeout exists on the SQLite
- * drivers (the capability slot is empty), so a long-running native
- * aggregate is bounded by nothing here; the row bound covers fetched
- * rows, not database-internal work.
- */
-/** The `'safe'` profile: the documented defaults. */
-export declare const SAFE_PROFILE: Readonly<{
-    limits: Readonly<{
-        sequenceItems: 100000;
-        resultItems: 10000;
-        steps: 1000000;
-        depth: 32;
-    }>;
-    maxRows: 1000;
-    externals: readonly never[];
-    functions: readonly never[];
-    collations: readonly never[];
-    collections: null;
-    predicates: Readonly<{}>;
-    refuseFullScan: false;
-}>;
-/**
- * Normalize a profile option: the string `'safe'` is the default
- * table; an object overrides individual members over those defaults
- * (limits merge member-wise). The result is plain JSON — cacheable by
- * content key — and frozen.
- * @param {any} profile - `'safe'` or a partial profile object
- * @returns {any}
- */
-export declare function normalizeProfile(profile: any): any;
-/**
- * Translate a profile's mandatory predicate for one collection into a
- * plan predicate. The predicate is HOST-authored configuration, so a
- * predicate that does not translate natively is a host programming
- * error (TypeError), not a coded document failure — there is no
- * residual to hide it in: the whole point is that it binds the
- * database-side fetch.
- * @param {any} expression - A query expression over `$it`
- * @param {any} shape - The collection's plan shape
- * @returns {import('./algebra.js').PlanPredicate}
- */
-export declare function translateProfilePredicate(expression: any, shape: any): import('./algebra.js').PlanPredicate;
-/**
- * Conjoin a mandatory predicate into a plan's root filter.
- * @param {import('./algebra.js').Plan} plan
- * @param {import('./algebra.js').PlanPredicate | null} predicate
- * @returns {import('./algebra.js').Plan}
- */
-export declare function applyMandatoryPredicate(plan: import('./algebra.js').Plan, predicate: import('./algebra.js').PlanPredicate | null): import('./algebra.js').Plan;
-/**
- * Cap a plan's window at the profile's detection bound
- * (`maxRows + 1`): a result crossing `maxRows` is detected and
- * refused, never silently truncated. Aggregates are exempt (one row).
- * @param {import('./algebra.js').Plan} plan
- * @param {number} maxRows
- * @returns {import('./algebra.js').Plan}
- */
-export declare function applyRowBound(plan: import('./algebra.js').Plan, maxRows: number): import('./algebra.js').Plan;

package/dist/types/query.d.ts

@@ -1,112 +0,0 @@
-/**
- * @file The query surface over one collection: the D2 provider
- * (`execute(document, options)` — how a linq chain runs here with no
- * import edge), the streaming cursor (`query`), and `explain()`.
- *
- * The statement cache is a CALLER of the core primitives:
- * `createSemanticCache` keyed by the whole discriminating tuple —
- * document plus collection, dialect, strictness, pushdown and profile.
- * The identity is the tuple's COMPLETE serialization, never a
- * fingerprint of it: a 32-bit content hash collides after tens of
- * thousands of documents, and a collision here answers one query with
- * another query's plan and rows. `store.stats()` exposes hits, misses
- * and evictions so the cache is proven rather than assumed.
- *
- * Bind-time diversion: if any referenced external is missing or not a
- * string or finite number, the call runs the always-compilable set
- * residual over the full collection instead of the native statement —
- * SQLite cannot bind a boolean, a `null` needs Jaren's semantics, and
- * a missing external must raise the ENGINE's error, not a driver's.
- * Two externals never bind at all and divert by their own rule: a
- * region reaching the statement through derived slots diverts when it
- * has no box, and a k-nearest probe — which the plan scores in the
- * engine, never in SQL — diverts when it is not a vector of the
- * column's width, so the engine answers what it answers everywhere.
- *
- * The k-nearest mode (`plan.rank`) is a set residual whose candidates
- * an ordering chose: the statement fetches (identity, column) under
- * the pushed WHERE, the engine scores and cuts (`knn.js`), the
- * winners' documents are fetched by identity through the dialect, and
- * the whole document runs over them.
- */
-/**
- * The store-wide query state shared by every collection's engine: one
- * bounded statement cache, its counters, the UDF registration set, and
- * the store's resolved registered operators (Ring 2 — `{ functions,
- * extensions }` or `null`), threaded to every engine that builds a
- * residual.
- * @param {number} [bound]
- * @param {{ functions?: any, extensions?: any } | null} [operators]
- * @param {any} [zoneProvider] - D7's injected clock, or absent
- * @returns {any}
- */
-export declare function createQueryState(bound?: number, operators?: {
-    functions?: any;
-    extensions?: any;
-} | null, zoneProvider?: any): any;
-/**
- * The query engine for one collection.
- * @param {{ connection: any, state: any, collection: any,
- *   physicalPlan: any, profile?: any }} context - `collection` is the
- *   normalized collection; `physicalPlan` is the DDL plan
- *   (columns, indexes); `profile` is the store-level normalized
- *   profile, if one was opened with
- * @returns {{ execute: Function, query: Function, explain: Function }}
- */
-export declare function createQueryEngine(context: {
-    connection: any;
-    state: any;
-    collection: any;
-    physicalPlan: any;
-    profile?: any;
-}): {
-    execute: Function;
-    query: Function;
-    explain: Function;
-};
-/** The default include depth bound (D14: printed, never silent). */
-export declare const INCLUDE_DEPTH_DEFAULT = 3;
-/**
- * The store-level entity query engine: documents over the
- * multi-entity root (`$.<Entity>[*]` bindings), planned to guarded
- * selections and INNER equijoins, with the set residual running the
- * whole document over the fetched root — the same honesty contract as
- * phase A.
- * @param {{ connection: any, entities: Map<string, any>, mapping: any,
- *   state: any }} context
- * @returns {any}
- */
-export declare function createEntityQueryEngine(context: {
-    connection: any;
-    entities: Map<string, any>;
-    mapping: any;
-    state: any;
-}): any;
-/**
- * The one-statement graph loader: `entity.load(spec)` compiles an
- * include tree to correlated subqueries projected as JSON — one
- * statement regardless of depth (asserted by a counting driver in the
- * tests, because N+1 is a test, not a promise). Per-relation `where`,
- * `orderBy` and `take` are applied INSIDE the subquery; depth is
- * bounded with the default printed in the refusal; cycles in the
- * specification are rejected; and keyset pagination is chosen over a
- * growing OFFSET whenever the top-level ordering is a single unique
- * column, with the choice reported by `explainLoad`.
- * @param {{ connection: any, entities: Map<string, any>, mapping: any,
- *   state: any }} context
- * @param {string} entityName
- * @returns {any}
- */
-export declare function createLoadEngine(context: {
-    connection: any;
-    entities: Map<string, any>;
-    mapping: any;
-    state: any;
-}, entityName: string): any;
-export type ParamCollector = {
-    literal?: any;
-    external?: string;
-}[];
-/**
- * @typedef {{ literal?: any, external?: string }[]} ParamCollector
- */

package/dist/types/residual.d.ts

@@ -1,64 +0,0 @@
-/**
- * @file Residual compilation: the part of a query that stays in
- * JavaScript is a REAL compiled Jaren query — the same engine, the
- * same semantics — never a reimplementation.
- *
- * Two modes (ARCHITECTURE.md):
- *
- * - `set` — the whole original document compiled once, run over the
- *   materialized candidate array. Re-applying pushed conjuncts is
- *   idempotent, so SQL-side narrowing never changes the answer.
- * - `row` — only the projection stayed behind: each fetched row runs
- *   the planner's one-row document over the one-row array; the array
- *   wrapper packs the item sequence so an array-VALUED item stays
- *   unambiguous, and the per-row results concatenate in row order
- *   (streamable).
- *
- * Neither mode builds a query document here. The collection binding is
- * named by the caller's document — `it`, `user`, anything — so a wrapper
- * synthesized in this file could only guess it, and a guess that
- * disagreed with the projection's references would surface as an
- * unbound-external error at request time rather than at compile time.
- * The planner knows the name and hands both modes something complete.
- */
-/**
- * Compile the whole document for set-mode evaluation. A profile's
- * engine limits ride into the compilation so the JavaScript portion is
- * bounded by the engine's own enforcement.
- * @param {any} document
- * @param {any} [limits]
- * @param {{ functions?: any, extensions?: any } | null} [operators] -
- *   the store's registered operators, so the residual can evaluate them
- * @param {any} [zoneProvider] - D7's injected clock, so a calendar
- *   ladder on a named zone compiles rather than being refused
- * @returns {(candidates: any[], externals: any) => any}
- */
-export declare function compileSetResidual(document: any, limits?: any, operators?: {
-    functions?: any;
-    extensions?: any;
-} | null, zoneProvider?: any): (candidates: any[], externals: any) => any;
-/**
- * Compile the per-row projection for row-mode evaluation.
- * @param {any} rowDocument - The planner's complete one-row document
- *   (`{ $for: { <the document's own binding>: '$[*]' },
- *   $return: [ <its $return> ] }`). It arrives whole because the binding
- *   and the projection that references it must agree, and the planner is
- *   the only place that knows the name.
- * @param {any} [limits]
- * @param {{ functions?: any, extensions?: any } | null} [operators]
- * @param {any} [zoneProvider] - D7's injected clock
- * @returns {(row: any, externals: any) => any[]} the row's items
- */
-export declare function compileRowResidual(rowDocument: any, limits?: any, operators?: {
-    functions?: any;
-    extensions?: any;
-} | null, zoneProvider?: any): (row: any, externals: any) => any[];
-/**
- * Map a flat item array onto the engine's result shape: an empty
- * sequence is `undefined`, a singleton is the item, anything longer is
- * the array (probed engine behaviour, pinned by the differential
- * tests).
- * @param {any[]} items
- * @returns {any}
- */
-export declare function sequenceResult(items: any[]): any;