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

package/dist/periods/index.d.cts

@@ -1,22 +0,0 @@
-import { a5 as PeriodsStrategy } from '../types-CSLcfytP.cjs';
-export { a6 as CarryForwardContext, a7 as ClosePeriodOptions, a8 as OpenPeriodOptions, a9 as PERIODS_COLLECTION, aa as PeriodRecord, ab as ReadOnlyCollection, ac as appendPeriodLedgerEntry, ad as assertTsWritable, ae as chainAnchor, af as loadPeriods, ag as validatePeriodName } from '../types-CSLcfytP.cjs';
-import '../lazy-builder-C-rPfWG0.cjs';
-import '../predicate-Dnu81tsS.cjs';
-import '../strategy-DSTrsZ8t.cjs';
-import '../strategy-BSxFXGzb.cjs';
-import '../index-DVkvrgpm.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-Dnu81tsS.d.ts

@@ -1,185 +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 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;
-}
-
-/**
- * Operator implementations for the query DSL.
- *
- * All predicates run client-side, AFTER decryption — they never see ciphertext.
- * This file is dependency-free and tree-shakeable.
- */
-/** 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;
-}
-/**
- * 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 (#153). 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[];
-}
-type Clause = FieldClause | FilterClause | WherePredicateClause | GroupClause;
-/**
- * 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.
- */
-declare function evaluateClause(record: unknown, clause: Clause): 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, evaluateClause as e, readPath as r };