@feltdb/core 0.11.5 → 0.11.6

package/dist/runtime-snapshot.d.ts

@@ -0,0 +1,337 @@
+/**
+ * Native materialized runtime snapshots.
+ *
+ * A hot path — an authorization decision, an agent loop, a rendered view —
+ * reads the same durable state hundreds of times per second. Asking the
+ * durable authority every time is slow, so applications build their own cache,
+ * and that cache becomes an unofficial second database: mutable, unversioned,
+ * invalidated by hand, and eventually disagreeing with FeltDB.
+ *
+ * A runtime snapshot is FeltDB's answer. It is a *derived representation* of
+ * authoritative FeltDB state, not a second source of truth:
+ *
+ *   - it says which durable state it represents, through the same revision
+ *     semantics `freshness.ts` defines, or says honestly that it cannot;
+ *   - it is immutable once published, so a consumer mid-decision cannot be
+ *     overtaken by a partial rebuild;
+ *   - it is replaced atomically, so consumers observe one complete snapshot or
+ *     another, never a mixture;
+ *   - it holds no reference to the database, so reading it cannot perform
+ *     durable I/O — that is a structural property, not a promise;
+ *   - it answers bounded queries through the same executor the embedded
+ *     storage boundary uses, so filtering, ordering, cursors, and index
+ *     selection mean what they already mean in FeltDB.
+ *
+ * Writes never go here. A snapshot has no `set` and no `delete`, because
+ * mutation belongs to the authoritative state APIs and nothing else.
+ *
+ * See docs/reference/runtime-snapshots.md for the contract, the consistency
+ * and staleness rules, and the memory and lifecycle semantics.
+ */
+import { type FreshnessCapability, type Revision } from './freshness.js';
+import { type EmbeddedQueryExplanation } from './embedded-query.js';
+import type { AuthorityQueryPage, AuthorityQueryRequest } from './http-db.js';
+import type { IndexConfig } from './index-types.js';
+/** A snapshot query is the bounded authority query, executed against materialized state. */
+export type SnapshotQueryRequest = AuthorityQueryRequest;
+/** A snapshot query page is the bounded authority query page. */
+export type SnapshotQueryPage<T = Record<string, unknown>> = AuthorityQueryPage<T>;
+/** One condition of a bounded query, reused for materialization filters. */
+export type SnapshotCondition = NonNullable<AuthorityQueryRequest['where']>[number];
+/** One collection this snapshot materializes, and the runtime indexes built over it. */
+export interface SnapshotSourceDefinition {
+    collection: string;
+    /**
+     * Restrict what is materialized. Conditions are ANDed and carry exactly one
+     * operator each, as in a bounded query. A snapshot that holds a subset of a
+     * collection is still derived from authoritative state; it simply derives
+     * less of it.
+     */
+    where?: SnapshotCondition[];
+    /**
+     * Runtime indexes over the materialized records. They use the same
+     * `IndexConfig` shape as collection indexes and are consumed by the same
+     * planner, so an indexed snapshot query is bounded for the same reasons a
+     * durable one is.
+     */
+    indexes?: IndexConfig[];
+}
+/** Read access to what a build materialized, handed to `derive`. */
+export interface SnapshotMaterializationView {
+    readonly collections: readonly string[];
+    all<T = Record<string, unknown>>(collection: string): readonly T[];
+}
+export interface SnapshotDefinition<D = undefined> {
+    /** Stable name. `db.snapshot(name)` resolves the handle by it. */
+    name: string;
+    /** The durable collections this snapshot is derived from. At least one. */
+    sources: SnapshotSourceDefinition[];
+    /**
+     * Derive additional read-optimized state from the materialized records.
+     *
+     * Called once per build, before publication, and must be pure: it may read
+     * the materialization and return a value, and must not mutate records or
+     * reach for the database. The returned value is frozen and published with
+     * the snapshot.
+     */
+    derive?: (view: SnapshotMaterializationView) => D;
+    /**
+     * Reject a candidate snapshot before it is published, by throwing.
+     *
+     * A rejected build leaves the active snapshot in place. This is where an
+     * application states what "complete enough to serve" means for its own
+     * derived state.
+     */
+    validate?: (candidate: RuntimeSnapshot<D>) => void;
+    /**
+     * How many times a build may be retried when durable state moves underneath
+     * it. Applies only to runtimes that can prove coherence with a revision.
+     * Defaults to 3.
+     */
+    coherenceAttempts?: number;
+    /**
+     * Freeze every materialized record (default). Freezing costs one pass over
+     * the records at build time and makes "published snapshots are immutable" a
+     * property of the objects rather than a convention. Turning it off is a
+     * deliberate trade of that guarantee for build throughput.
+     */
+    freezeRecords?: boolean;
+}
+/**
+ * What durable state a snapshot represents.
+ *
+ * Deliberately shaped like `FreshnessCapability`: a snapshot can only be as
+ * honest about its version as the runtime it was derived from. A runtime that
+ * cannot produce an authoritative revision does not get one invented for it.
+ */
+export interface SnapshotBasis {
+    /** `revision` when the snapshot carries an authoritative revision; `refresh` when it cannot. */
+    validation: 'revision' | 'refresh';
+    /** The FeltDB revision this snapshot represents. Present exactly when validation is `revision`. */
+    revision?: Revision;
+    /** Why no revision identifies this snapshot. Present exactly when validation is `refresh`. */
+    reason?: string;
+    /**
+     * `proven` when the revision was unchanged across the whole materialization,
+     * so the snapshot is a point-in-time view of one durable state. `unproven`
+     * when the runtime offers no revision to compare, and the materialization
+     * may therefore span concurrent writes.
+     */
+    coherence: 'proven' | 'unproven';
+    /** When materialization completed. Reporting only; never a freshness signal. */
+    materializedAt: number;
+}
+/** Whether a published snapshot still represents current durable state. */
+export interface SnapshotStaleness {
+    /** `unknown` means the runtime cannot prove currency — not that the snapshot is current. */
+    state: 'current' | 'stale' | 'unknown';
+    /** The revision the snapshot was built from, when it has one. */
+    snapshot?: Revision;
+    /** The runtime's current revision, when it has one. */
+    current?: Revision;
+    /** Why currency could not be decided. */
+    reason?: string;
+}
+export interface SnapshotIndexDescription {
+    collection: string;
+    name: string;
+    fields: string[];
+    /** Index entries held, which is one per materialized record of the collection. */
+    entries: number;
+}
+export interface SnapshotSourceDescription {
+    collection: string;
+    records: number;
+    /** Whether a materialization filter was applied to this source. */
+    filtered: boolean;
+    indexes: string[];
+}
+/** What a snapshot is, in enough detail to reason about its runtime behavior. */
+export interface SnapshotExplanation {
+    name: string;
+    /** Publication counter. Increments once per published snapshot, never reused. */
+    generation: number;
+    records: number;
+    basis: SnapshotBasis;
+    buildMs: number;
+    sources: SnapshotSourceDescription[];
+    indexes: SnapshotIndexDescription[];
+}
+/** What a handle has done, including what it failed to do. */
+export interface SnapshotHandleExplanation extends SnapshotExplanation {
+    /** Builds that reached publication. */
+    builds: number;
+    /** Builds that failed. A failed build never replaces the active snapshot. */
+    failures: number;
+    lastFailure?: {
+        at: number;
+        message: string;
+    };
+    /**
+     * Durable collection reads this handle has performed, across every build.
+     *
+     * Reading a published snapshot never increments it: that is what "the hot
+     * path performs no durable I/O" means, stated as a number rather than a
+     * claim.
+     */
+    durableReads: number;
+}
+export declare class SnapshotDefinitionError extends Error {
+    constructor(message: string);
+}
+/** A build failed. The previously published snapshot, if any, remains active. */
+export declare class SnapshotBuildError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/** A snapshot was read before anything was published. */
+export declare class SnapshotNotPublishedError extends Error {
+    constructor(message: string);
+}
+/** Proof of currency was required and the runtime cannot provide it. */
+export declare class SnapshotFreshnessError extends Error {
+    constructor(message: string);
+}
+/**
+ * A published runtime snapshot.
+ *
+ * Every method answers from materialized state. None of them touch storage,
+ * the network, or the database handle, because the implementation holds no
+ * reference to any of them.
+ */
+export interface RuntimeSnapshot<D = undefined> {
+    readonly name: string;
+    readonly generation: number;
+    readonly basis: SnapshotBasis;
+    /** The revision this snapshot represents, when the runtime has one. */
+    readonly revision?: Revision;
+    readonly materializedAt: number;
+    /** Materialized records, across every source. */
+    readonly records: number;
+    readonly collections: readonly string[];
+    get<T = Record<string, unknown>>(collection: string, id: string | number): T | undefined;
+    has(collection: string, id: string | number): boolean;
+    /** Every materialized record of one collection, in materialization order. Frozen. */
+    all<T = Record<string, unknown>>(collection: string): readonly T[];
+    /** A bounded, optionally indexed query over materialized state. Synchronous. */
+    query<T = Record<string, unknown>>(request: SnapshotQueryRequest): SnapshotQueryPage<T>;
+    /** Whatever the definition's `derive` returned for this build. */
+    derived(): D;
+    /** What this snapshot is, or which access path a query would take. */
+    explain(): SnapshotExplanation;
+    explain(request: SnapshotQueryRequest): EmbeddedQueryExplanation;
+}
+/**
+ * The durable state a snapshot is derived from.
+ *
+ * A port rather than a concrete database, so the same semantics hold for every
+ * FeltDB runtime — embedded, browser, file, server, WASM — with each supplying
+ * its own reads and its own honest freshness answer.
+ */
+export interface SnapshotSourceRuntime {
+    /** Read every authoritative record of one collection. */
+    readRecords(collection: string): Promise<Array<Record<string, unknown>>>;
+    /** What freshness validation the underlying runtime can honestly support. */
+    freshness(): Promise<FreshnessCapability>;
+    /** The runtime's current revision. Called only when freshness advertises one. */
+    revision(): Promise<Revision>;
+}
+/**
+ * The lifecycle owner: CREATE → BUILD → VALIDATE → PUBLISH → READ → REPLACE.
+ *
+ * The handle is mutable — it is what replacement means. Everything it
+ * publishes is not.
+ */
+export declare class RuntimeSnapshotHandle<D = undefined> {
+    readonly definition: SnapshotDefinition<D>;
+    private readonly source;
+    private active?;
+    private generation;
+    private building?;
+    private readonly listeners;
+    private builds;
+    private failures;
+    private durableReads;
+    private lastFailure?;
+    private closed;
+    constructor(definition: SnapshotDefinition<D>, source: SnapshotSourceRuntime);
+    get name(): string;
+    /**
+     * The active snapshot, or `undefined` before the first successful build.
+     *
+     * Never performs I/O and never blocks: this is the hot-path accessor.
+     */
+    get current(): RuntimeSnapshot<D> | undefined;
+    /** The active snapshot, or an error explaining that nothing is published yet. */
+    read(): RuntimeSnapshot<D>;
+    /**
+     * Build and publish a snapshot.
+     *
+     * When the runtime offers an authoritative revision and the active snapshot
+     * already represents it, nothing is rebuilt and the active snapshot is
+     * returned — the cheapest correct incremental step there is. `force` skips
+     * that check.
+     *
+     * A failed build throws and leaves the active snapshot untouched.
+     */
+    refresh(options?: {
+        force?: boolean;
+    }): Promise<RuntimeSnapshot<D>>;
+    /**
+     * A snapshot proven to represent current durable state.
+     *
+     * Rebuilds when stale, and refuses when currency cannot be established,
+     * rather than serving state of unknown age. Security-sensitive consumers —
+     * authorization above all — use this instead of `current`, so that their
+     * freshness requirement is explicit in the code that depends on it.
+     */
+    fresh(): Promise<RuntimeSnapshot<D>>;
+    /** Whether the active snapshot still represents current durable state. */
+    staleness(): Promise<SnapshotStaleness>;
+    /** Observe publications. The listener receives the snapshot that became active. */
+    subscribe(listener: (snapshot: RuntimeSnapshot<D>) => void): () => void;
+    /** What this handle holds, how it was built, and what it failed to build. */
+    explain(): SnapshotHandleExplanation;
+    /**
+     * Release the active snapshot.
+     *
+     * A handle retains exactly one snapshot, so this is what bounds retention
+     * when an application is done with a snapshot but keeps the database open.
+     * Consumers still holding a snapshot keep reading it; they always could.
+     */
+    close(): void;
+    private assertOpen;
+    /**
+     * Single-flight build. Two concurrent refreshes produce one materialization
+     * and one publication, not two builds racing to replace each other.
+     */
+    private build;
+    private runBuild;
+    private materialize;
+    /**
+     * VALIDATE, then PUBLISH.
+     *
+     * Publication is the single assignment below. A consumer holding the
+     * previous snapshot keeps a complete snapshot; a consumer reading after it
+     * gets a complete snapshot; there is no moment at which half of each is
+     * visible.
+     */
+    private publish;
+}
+export declare function assertSnapshotDefinition(definition: SnapshotDefinition<any>): void;
+/**
+ * Create a snapshot handle over any FeltDB runtime.
+ *
+ * `StateFirstDB.snapshot()` is the application-facing form; this is the same
+ * primitive for runtimes and tools that hold a source of their own.
+ */
+export declare function createRuntimeSnapshot<D = undefined>(definition: SnapshotDefinition<D>, source: SnapshotSourceRuntime): RuntimeSnapshotHandle<D>;
+/**
+ * Whether two definitions describe the same snapshot.
+ *
+ * Sources, filters, indexes, and options compare structurally; `derive` and
+ * `validate` compare by identity, because two functions with the same text can
+ * still compute different things and nothing here can tell.
+ */
+export declare function snapshotDefinitionsMatch(left: SnapshotDefinition<any>, right: SnapshotDefinition<any>): boolean;
+//# sourceMappingURL=runtime-snapshot.d.ts.map

package/dist/runtime-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-snapshot.d.ts","sourceRoot":"","sources":["../src/runtime-snapshot.ts"],"names":[],"mappings":"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"}