@noy-db/hub 0.2.0-pre.30 → 0.2.0-pre.31

package/dist/periods/index.d.cts

@@ -1,24 +0,0 @@
-import { ab as PeriodsStrategy } from '../types-CdVfiQgt.cjs';
-export { ac as CarryForwardContext, ad as ClosePeriodOptions, ae as OpenPeriodOptions, af as PERIODS_COLLECTION, ag as PeriodRecord, ah as ReadOnlyCollection, ai as appendPeriodLedgerEntry, aj as assertTsWritable, ak as chainAnchor, al as loadPeriods, am as validatePeriodName } from '../types-CdVfiQgt.cjs';
-import '../lazy-builder-eYZzLEL1.cjs';
-import '../predicate-BmhBSPCH.cjs';
-import '../strategy-mJExw4LQ.cjs';
-import '../errors-BAWO5Z5a.cjs';
-import '../strategy-BSxFXGzb.cjs';
-import '../index-BMmajblo.cjs';
-import '../index-C1SC1EPe.cjs';
-import '@noy-db/attestation';
-
-/**
- * Active periods strategy factory. Only reachable through the
- * `@noy-db/hub/periods` subpath.
- */
-
-/**
- * Build the default periods strategy. Pass into
- * `createNoydb({ periodsStrategy: withPeriods() })` to enable
- * `vault.closePeriod()` / `vault.openPeriod()` / write-guards.
- */
-declare function withPeriods(): PeriodsStrategy;
-
-export { PeriodsStrategy, withPeriods };

package/dist/predicate-BmhBSPCH.d.cts

@@ -1,267 +0,0 @@
-/**
- * Secondary indexes for the query DSL.
- *
- * ships **in-memory hash indexes**:
- *   - Built during `Collection.ensureHydrated()` from the decrypted cache
- *   - Maintained incrementally on `put` and `delete`
- *   - Consulted by the query executor for `==` and `in` operators on
- *     indexed fields, falling back to a linear scan otherwise
- *   - Live entirely in memory — no adapter writes for the index itself
- *
- * Persistent encrypted index blobs (the spec's "store as a separate
- * AES-256-GCM blob" note) are deferred to a follow-up issue. The reasons
- * are documented in the PR body — short version: at the target
- * scale of 1K–50K records, building the index during hydrate is free,
- * so persistence buys nothing measurable.
- */
-/**
- * Index declaration accepted by `Collection`'s constructor.
- *
- * Accepts:
- *   - `string` — a single-field hash index (`'clientId'`)
- *   - `{ fields: [...] }` or `readonly string[]` — a composite index
- *     over an ordered field tuple. Only lazy-mode
- *     collections consume composite declarations today; eager mode
- *     silently treats a composite as equivalent to declaring each
- *     component field as its own single-field index.
- *
- * Additive variants (unique constraints, partial indexes) will land as
- * further union members without breaking existing declarations.
- */
-type IndexDef = string | {
-    readonly fields: readonly string[];
-    readonly unique?: boolean;
-} | readonly string[];
-/**
- * Internal representation of a built hash index.
- *
- * Maps stringified field values to the set of record ids whose value
- * for that field matches. Stringification keeps the index simple and
- * works uniformly for primitives (`'open'`, `'42'`, `'true'`).
- *
- * Records whose indexed field is `undefined` or `null` are NOT inserted
- * — `query().where('field', '==', undefined)` falls back to a linear
- * scan, which is the conservative behavior.
- */
-interface HashIndex {
-    readonly field: string;
-    readonly buckets: Map<string, Set<string>>;
-}
-/**
- * Container for all indexes on a single collection.
- *
- * Methods are pure with respect to the in-memory `buckets` Map — they
- * never touch the adapter or the keyring. The Collection class owns
- * lifecycle (build on hydrate, maintain on put/delete).
- */
-declare class CollectionIndexes {
-    private readonly indexes;
-    /**
-     * Declare an index. Subsequent record additions are tracked under it.
-     * Calling this twice for the same field is a no-op (idempotent).
-     */
-    declare(field: string): void;
-    /** True if the given field has a declared index. */
-    has(field: string): boolean;
-    /** All declared field names, in declaration order. */
-    fields(): string[];
-    /**
-     * Build all declared indexes from a snapshot of records.
-     * Called once per hydration. O(N × indexes.size).
-     */
-    build<T>(records: ReadonlyArray<{
-        id: string;
-        record: T;
-    }>): void;
-    /**
-     * Insert or update a single record across all indexes.
-     * Called by `Collection.put()` after the encrypted write succeeds.
-     *
-     * If `previousRecord` is provided, the record is removed from any old
-     * buckets first — this is the update path. Pass `null` for fresh adds.
-     */
-    upsert<T>(id: string, newRecord: T, previousRecord: T | null): void;
-    /**
-     * Remove a record from all indexes. Called by `Collection.delete()`
-     * (and as the first half of `upsert` for the update path).
-     */
-    remove<T>(id: string, record: T): void;
-    /** Drop all index data. Called when the collection is invalidated. */
-    clear(): void;
-    /**
-     * Equality lookup: return the set of record ids whose `field` matches
-     * the given value. Returns `null` if no index covers the field — the
-     * caller should fall back to a linear scan.
-     *
-     * The returned Set is a reference to the index's internal storage —
-     * callers must NOT mutate it.
-     */
-    lookupEqual(field: string, value: unknown): ReadonlySet<string> | null;
-    /**
-     * Set lookup: return the union of record ids whose `field` matches any
-     * of the given values. Returns `null` if no index covers the field.
-     */
-    lookupIn(field: string, values: readonly unknown[]): ReadonlySet<string> | null;
-}
-
-/**
- * Money-aware `where()` comparison (#336).
- *
- * Query clauses evaluate against RAW stored records — money decode
- * happens on output only (#322) — so a money field's stored form is a
- * scaled-integer digit string (`'1000000'`) while the caller naturally
- * writes the operand in major units (`10000`, `'10000.00'`). Without a
- * rewrite the comparison is silently wrong by the scale factor, and a
- * string-vs-number comparison is excluded by `isComparable` anyway.
- *
- * Two halves:
- *
- * - {@link moneyFieldClause} runs at QUERY BUILD time: it quantizes the
- *   caller's major-unit operand into stored scaled-int space via the
- *   same `parseToScaledInt` path as writes, so a malformed operand
- *   throws at `.where()` — not silently filters everything out.
- * - {@link evaluateMoneyClause} runs per record and compares
- *   `BigInt`-exact in scaled space (exact past 2^53, like the rest of
- *   the money subsystem).
- *
- * Currency semantics (multi mode): an operand carries one currency —
- * explicit via `{ amount, currency }`, or the descriptor's sole allowed
- * currency for a bare amount. A record in a DIFFERENT currency has no
- * defined order against the operand: it matches `!=` and nothing else.
- */
-
-/** One quantized operand value: scaled digit string + its currency. */
-interface MoneyOperandEntry {
-    readonly scaled: string;
-    readonly currency: string;
-}
-/**
- * The money payload attached to a {@link FieldClause} over a declared
- * money field. `entries` holds one element for comparison ops, two for
- * `between` (lo, hi — same currency), N for `in`.
- */
-interface MoneyWhereOperand {
-    readonly mode: 'fixed' | 'multi';
-    readonly entries: ReadonlyArray<MoneyOperandEntry>;
-}
-
-/**
- * Operator implementations for the query DSL.
- *
- * All predicates run client-side, AFTER decryption — they never see ciphertext.
- * The only dependency is the money clause evaluator (#336) — still
- * tree-shakeable through it.
- */
-
-/** Comparison operators supported by the where() builder. */
-type Operator = '==' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'contains' | 'startsWith' | 'between';
-/**
- * A single field comparison clause inside a query plan.
- * Plans are JSON-serializable, so this type uses primitives only.
- */
-interface FieldClause {
-    readonly type: 'field';
-    readonly field: string;
-    readonly op: Operator;
-    readonly value: unknown;
-    /**
-     * Present when `field` is a declared money field (#336): the operand
-     * quantized into stored scaled-int space at query BUILD time, so the
-     * per-record comparison is BigInt-exact against the raw stored value.
-     * Built by `moneyFieldClause` — `Query.where()` attaches it when the
-     * source declares the field in `moneyFields`.
-     */
-    readonly money?: MoneyWhereOperand;
-}
-/**
- * A user-supplied predicate function escape hatch. Not serializable.
- *
- * The predicate accepts `unknown` at the type level so the surrounding
- * Clause type can stay non-parametric — this keeps Collection<T> covariant
- * in T at the public API surface. Builder methods cast user predicates
- * (typed `(record: T) => boolean`) into this shape on the way in.
- */
-interface FilterClause {
-    readonly type: 'filter';
-    readonly fn: (record: unknown) => boolean;
-}
-/**
- * A declared deterministic predicate reference. The query
- * builder produces this via `.wherePredicate(name, ctx?)` when a
- * Query has been augmented with a predicates map (typically by the
- * materialized-view registry — see MV v2 spec § Function-based
- * source-row predicates).
- *
- * `predicateHash` is the consumer-supplied stable hash for the
- * function body; `ctxHash` is the canonical-JSON SHA-256 of `ctx`.
- * Both fold into the MV's `queryHash` so a function or ctx change
- * forces refresh on next visit.
- *
- * `fn` is resolved at builder time from the predicates map and
- * embedded directly — so `evaluateClause` can fire it without a
- * runtime lookup.
- */
-interface WherePredicateClause {
-    readonly type: 'wherePredicate';
-    readonly name: string;
-    readonly ctx: unknown;
-    readonly predicateHash: string;
-    readonly ctxHash: string;
-    readonly fn: (record: unknown, ctx?: unknown) => boolean;
-}
-/** A logical group of clauses combined by AND or OR. */
-interface GroupClause {
-    readonly type: 'group';
-    readonly op: 'and' | 'or';
-    readonly clauses: readonly Clause[];
-}
-/**
- * Cartesian-product expansion clause. Appended to `QueryPlan.clauses`
- * by `Query.crossJoin()`. Processed in declaration order by
- * `executeClausePipeline` — NOT by `evaluateClause` (which is a
- * per-record predicate and throws on this type).
- */
-interface CrossJoinClause {
-    readonly type: 'crossJoin';
-    /** Target collection name to cross-join against. */
-    readonly target: string;
-    /** Alias under which the right-side record is exposed on each result row. */
-    readonly as: string;
-    /**
-     * Lateral filter callback. `undefined` → full cartesian product.
-     * Two call shapes:
-     *   - Subset:    `(left) => TTarget[]`            — returns the right rows for this left row
-     *   - Predicate: `(left) => (right) => boolean`   — executor materializes then filters
-     */
-    readonly on?: (left: unknown) => unknown[] | ((right: unknown) => boolean);
-    /** When `on:` was supplied as `{ predicate: name }`, the name is stored here for queryHash. */
-    readonly onPredicateName?: string;
-    /** Per-clause row ceiling override. `undefined` → `DEFAULT_CROSS_JOIN_MAX_ROWS`. */
-    readonly maxRows?: number;
-}
-type Clause = FieldClause | FilterClause | WherePredicateClause | GroupClause | CrossJoinClause;
-/**
- * Read a possibly nested field path like "address.city" from a record.
- * Returns undefined if any segment is missing.
- */
-declare function readPath(record: unknown, path: string): unknown;
-/**
- * Evaluate a single field clause against a record.
- * Returns false on type mismatches rather than throwing — query results
- * exclude non-matching records by definition.
- */
-declare function evaluateFieldClause(record: unknown, clause: FieldClause): boolean;
-/**
- * Evaluate any clause (field / filter / group) against a record.
- * The recursion depth is bounded by the user's query expression — no risk of
- * blowing the stack on a 50K-record collection.
- *
- * `fnRecord`, when provided, is the view handed to USER CALLBACK clauses
- * (`filter` / `wherePredicate`) instead of `record` — the executor passes
- * the money-decoded view there (#335) so user code never sees the stored
- * scaled-int form, while field clauses keep evaluating against the raw
- * record (their money operands are pre-quantized to that space, #336).
- */
-declare function evaluateClause(record: unknown, clause: Clause, fnRecord?: unknown): boolean;
-
-export { CollectionIndexes as C, type FieldClause as F, type GroupClause as G, type HashIndex as H, type IndexDef as I, type Operator as O, type Clause as a, type FilterClause as b, evaluateFieldClause as c, type CrossJoinClause as d, evaluateClause as e, readPath as r };