@jarenjs/db 0.49.2 → 0.56.0

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;

package/dist/types/series.d.ts

@@ -1,227 +0,0 @@
-/**
- * @file The temporal recognizer: which documents ask a §8.16 question,
- * which of those a declared `(series, at)` index can answer, and what
- * the honest reason is when it cannot.
- *
- * No SQL and no storage kind live here. The physical feature is the
- * composite JSONPath index a model already declares
- * (`{ "name": "by_series_at", "path": ["$.series", "$.at"] }`); this
- * module only decides which of the three CLOSED shapes a planned
- * selection is in:
- *
- *  1. **range** — an equality on every leading column of an instant
- *     index plus a half-open range on the instant column, ordered by
- *     the instant. The index seeks; nothing is left over.
- *  2. **as-of** — the same prefix with ONE instant bound, ordered by
- *     the instant and cut to a finite window. One index seek per probe.
- *  3. **bucket** — a fixed-width ladder over the instant column with
- *     the exact `sum|mean|min|max|count` aggregates, which is a
- *     `GROUP BY` over integer arithmetic.
- *
- * Everything else — a calendar ladder, a fill policy, a rolling window,
- * an as-of JOIN, `first`/`last` — is a named core refinement: the
- * database narrows through the index and `@jarenjs/core/series` (via
- * the residual, which is the ENGINE running the caller's own document)
- * decides. The narrowing is the contribution; the answer is always the
- * engine's, which is what makes a refinement idempotent.
- *
- * Every refusal here has a CODE, and the code is the first word of the
- * sentence the plan carries, so `explain().series.reasons[].code` and
- * `explain().residual.reasons[].reason` cannot drift apart.
- */
-/** The three §8.16 operators a whole document can BE. */
-export declare const SERIES_ROOT_OPS: readonly string[];
-/** Every §8.16 operator: naming one makes a document temporal. */
-export declare const SERIES_OPS: readonly string[];
-/**
- * The D5 aggregates a `GROUP BY` reproduces exactly, and the plan's
- * name for each. `count` is `rows` because it counts SOURCE ROWS —
- * duplicates and measured gaps included — which is `COUNT(*)` and not
- * `COUNT(value)`; the six value aggregates skip a `null` reading,
- * which is what SQL's aggregates already do with SQL `NULL`.
- *
- * `first` and `last` are deliberately absent: they name a row by its
- * position in the series, and a group's order is not the series' order.
- */
-export declare const NATIVE_AGGREGATES: Readonly<{
-    mean: "avg";
-    sum: "sum";
-    min: "min";
-    max: "max";
-    count: "rows";
-}>;
-/**
- * The closed reason table. A reason is a CODE and a sentence; the plan
- * carries `"<code>: <sentence>"` so one string serves strict mode's
- * refusal, `explain().residual.reasons` and the machine-readable
- * `explain().series.reasons[].code` at once.
- */
-export declare const SERIES_REASONS: Readonly<{
-    'missing-series-prefix': string;
-    'calendar-width': string;
-    'named-zone': string;
-    'fill-policy': string;
-    'rolling-refinement': string;
-    'asof-refinement': "an as-of join walks both sides once, so the index bounds the fetch and the kernel joins";
-    'nonliteral-spec': string;
-    'unsupported-aggregate': string;
-    'row-selector': string;
-    'instant-not-integer': string;
-    'value-not-numeric': string;
-    'nonnative-grouping': "the grouping key or the projection is not the closed bucket shape";
-    'invalid-spec': string;
-}>;
-/**
- * One reason, in both spellings at once.
- * @param {keyof SERIES_REASONS | string} code
- * @param {string} construct - the operator or clause that forced it
- * @returns {{ code: string, construct: string, reason: string }}
- */
-export declare function seriesReason(code: keyof SERIES_REASONS | string, construct: string): {
-    code: string;
-    construct: string;
-    reason: string;
-};
-/**
- * Every declared index whose LAST covered column is `column`, with the
- * columns before it as the prefix that must be pinned.
- *
- * `minColumns` is what keeps an ordinary query ordinary. A collection
- * that declares `(age)` and is asked for `age > 21` is not asking a
- * temporal question, and nothing in a column can say otherwise — so
- * the shape D9 actually names, a COMPOSITE index whose last column is
- * the instant, is what makes a plain selection temporal. A document
- * that named a §8.16 operator has already said so itself, and reads
- * the singular index too.
- * @param {any} shape - { indexes?: { name, columns }[] }
- * @param {string} column
- * @param {number} [minColumns]
- * @returns {{ name: string, prefix: string[], column: string }[]}
- */
-export declare function instantIndexesOver(shape: any, column: string, minColumns?: number): {
-    name: string;
-    prefix: string[];
-    column: string;
-}[];
-/**
- * The index a fetch actually SEEKS through, or `null` when none does.
- *
- * A B-tree is seekable exactly as far as its leading columns are
- * decided: a run of equalities, and then at most one range. So the
- * index that wins is the one with the longest leading run of PINNED
- * columns whose next column is the instant the query ranges over —
- * which is `(series, at)` under an equality on the series, and is
- * nothing at all under a bare instant bound, because a range on a
- * trailing column reads every row of the index.
- *
- * With no instant column of its own (an as-of join reading an instant
- * the model does not index) a pinned prefix alone still seeks, and is
- * reported as what it is.
- * @param {any} shape
- * @param {string | null} column - the instant column, or `null`
- * @param {{ pinned: Set<string>, bounds: Map<string, any> }} facts
- * @param {number} [minColumns] - see {@link instantIndexesOver}
- * @returns {{ name: string, prefix: string[], column: string | null } | null}
- */
-export declare function seekingIndexFor(shape: any, column: string | null, facts: {
-    pinned: Set<string>;
-    bounds: Map<string, any>;
-}, minColumns?: number): {
-    name: string;
-    prefix: string[];
-    column: string | null;
-} | null;
-/**
- * Walk a pushed filter and report, per column, what it decided: which
- * columns an equality pinned and what instant bounds a range put on
- * one. Only a top-level conjunction counts — a disjunction or a
- * negation decides nothing about a seek.
- * @param {import('./algebra.js').PlanPredicate | null} filter
- * @returns {{ pinned: Set<string>,
- *   bounds: Map<string, { from: any, fromOp: string | null,
- *     to: any, toOp: string | null }> }}
- */
-export declare function filterFacts(filter: import('./algebra.js').PlanPredicate | null): {
-    pinned: Set<string>;
-    bounds: Map<string, {
-        from: any;
-        fromOp: string | null;
-        to: any;
-        toOp: string | null;
-    }>;
-};
-/**
- * The fixed ladder a `$time-bucket`/`$resample` spec asks for, or the
- * reason it is not one. `origin` is folded to an epoch here — a
- * `{ offset }` context moves the ladder's default anchor off UTC's
- * midnight, which is arithmetic, while a named zone is not.
- *
- * The width is read through the temporal kernel's OWN compiler, so
- * `'PT1H'`, `3600000` and `'PT60M'` are the same ladder, the default
- * anchor is the kernel's rather than a second guess at it, and a width
- * mixing the two families was already refused when the query compiled.
- * @param {{ every: any, origin?: any, zone?: any, offset?: any }} spec
- * @param {(spec: any, options: any) => any} compileBuckets - the kernel's
- * @returns {{ every: number, origin: number } | { code: string }}
- */
-export declare function fixedLadder(spec: {
-    every: any;
-    origin?: any;
-    zone?: any;
-    offset?: any;
-}, compileBuckets: (spec: any, options: any) => any): {
-    every: number;
-    origin: number;
-} | {
-    code: string;
-};
-/**
- * Whether a `PlanRef` can carry a native bucket ladder: the instant
- * must be a declared whole epoch, because the boundary arithmetic in
- * SQL is integer arithmetic and a truncating division over a real
- * would put an instant before 1970 in the bucket after its own.
- * @param {import('./algebra.js').PlanRef | null} ref
- * @returns {string | null} the reason code, or `null` when it can
- */
-export declare function instantRefusal(ref: import('./algebra.js').PlanRef | null): string | null;
-/**
- * Whether a `PlanRef` can carry a native VALUE aggregate.
- * @param {import('./algebra.js').PlanRef | null} ref
- * @returns {string | null}
- */
-export declare function valueRefusal(ref: import('./algebra.js').PlanRef | null): string | null;
-/**
- * The one member name a `'$.on'`-style row selector reads, or `null`
- * for anything a declared column cannot stand in for. The language's
- * own reader (`compileSelector`) folds a single-segment path to a bare
- * name; this reads the same two spellings out of the FROZEN literal a
- * planner sees, and refuses everything else rather than guessing.
- * @param {any} text
- * @returns {string | null}
- */
-export declare function singularSelector(text: any): string | null;
-/**
- * The explain record for one temporal document. Counts are the LAST
- * ACTUAL execution's — never an estimate — and are `null` until the
- * document has run once.
- * @param {{ mode: 'native' | 'hybrid' | 'engine', operation: string,
- *   index?: string | null, prefix?: string[], range?: any,
- *   ladder?: any, aggregates?: string[], refinement?: string | null,
- *   reasons?: { code: string, construct: string, reason: string }[] }} facts
- * @returns {any}
- */
-export declare function seriesRecord(facts: {
-    mode: 'native' | 'hybrid' | 'engine';
-    operation: string;
-    index?: string | null;
-    prefix?: string[];
-    range?: any;
-    ladder?: any;
-    aggregates?: string[];
-    refinement?: string | null;
-    reasons?: {
-        code: string;
-        construct: string;
-        reason: string;
-    }[];
-}): any;

package/dist/types/store.d.ts

@@ -1,60 +0,0 @@
-/**
- * @file The store: `openStore(model, options)` normalizes the model
- * document, opens a database through the injected driver, applies (or
- * verifies) the physical shape, and gives transactional,
- * schema-validated reads and writes.
- *
- * The public surface is ASYNCHRONOUS — every method returns a promise
- * — because the browser's OPFS story forces it regardless of any other
- * backend. Where the driver is synchronous the same operations exist
- * without the promise under `store.sync`, present only there — never a
- * throwing stub — so portable code pays one declared microsecond and
- * code that wants it back opts in knowingly. Internally everything
- * composes through the sync-capable {@link chain}, so the async
- * surface allocates exactly one promise per call, not one per step.
- *
- * Writes validate through an injected `compileSchema` hook with the
- * `compileTypeTest` signature; absent, writes are unvalidated and
- * `store.capabilities.validated === false` — a declared downgrade,
- * never a silent one. `@jarenjs/validate` is never imported here.
- */
-/** The model format version this store implements. */
-export declare const MODEL_VERSION = "0.1";
-/**
- * Normalize and check a model document. Every failure is `JD0005` with
- * a `docPath` into the model.
- * @param {any} model
- * @returns {Map<string, any>} collection name -> normalized collection
- */
-export declare function normalizeModel(model: any): Map<string, any>;
-/**
- * Open (or create) a store described by a model document.
- * @param {any} model - A `jaren-model` document (the 0.1 subset)
- * @param {{ driver: any, path?: string, compileSchema?: Function,
- *   busyTimeout?: number, queueTimeout?: number, journalMode?: string,
- *   statementCacheBound?: number, profile?: any, operators?: any,
- *   functions?: any, extensions?: any, zoneProvider?: any,
- *   readOnly?: boolean }} options
- *   `zoneProvider` is D7's injected clock: a named zone in a temporal
- *   spec (`{ "every": "P1M", "zone": "Europe/Amsterdam" }`) is host code
- *   the database cannot have, so a store that never received one refuses
- *   such a document (`JQ0003`) rather than answering it in UTC. It
- *   reaches every residual compilation, which is where the calendar
- *   ladder actually walks.
- * @returns {Promise<any>}
- */
-export declare function openStore(model: any, options: {
-    driver: any;
-    path?: string;
-    compileSchema?: Function;
-    busyTimeout?: number;
-    queueTimeout?: number;
-    journalMode?: string;
-    statementCacheBound?: number;
-    profile?: any;
-    operators?: any;
-    functions?: any;
-    extensions?: any;
-    zoneProvider?: any;
-    readOnly?: boolean;
-}): Promise<any>;