@bjornpagen/bumbledb 0.1.0

package/dist/db.d.ts

@@ -0,0 +1,341 @@
+/**
+ * `Db` — the living half of the SDK (PRD-07): open/create a store from a
+ * `Schema`, write typed facts through delta transactions with race-free
+ * final-state point reads, receive rejections as typed violation VALUES
+ * keyed to statements, read through scoped snapshots, and run the witnessed
+ * read-compute-write loop — all typed by the schema's relations record.
+ *
+ * ZERO CLOSABLES: no value this module returns carries a close, dispose, or
+ * release spelling. `Db` values are CACHED per canonical path for the life
+ * of the process (a best-effort exit hook closes the cached environments;
+ * correctness never depends on it — the engine fsyncs every commit, so a
+ * process that dies without the hook loses nothing that was committed).
+ * Snapshots are internal: `read(fn)` opens one before `fn` and closes it
+ * after unconditionally, and the {@link ReadScope} handed to `fn` is
+ * invalidated the moment `fn` returns. Prepared plans are plain values whose
+ * engine-side half is reclaimed by a GC finalizer — reclamation only, never
+ * correctness.
+ *
+ * PROCESS MODEL: one process, one exclusive-lock handle per store. The
+ * cached `Db` value owns the LMDB environment's exclusive lock until
+ * process exit; a second engine-level open of the same store (an aliased
+ * path spelling, or another process) is refused by the engine. The
+ * run-store process model (PRD-16) depends on this being true: resume =
+ * reopen, which is either this process's cached value or a fresh process's
+ * open.
+ *
+ * REJECTION IS DATA: a rejected commit is a domain outcome (it becomes the
+ * LLM repair prompt downstream), returned as a {@link WriteResult} carrying
+ * {@link Violation} values. Genuine failures — I/O, used-after-scope,
+ * marshal shape — throw `@superbuilders/errors` wrapped errors instead.
+ */
+import { phantom } from "#brand.ts";
+import type { Exhumed } from "#exhume.ts";
+import { type KeyFact, type Minted } from "#marshal.ts";
+import type { FactValue, Staleness, StatementKindTag } from "#native.ts";
+import type { Query } from "#query/lower.ts";
+import type { ParamsRecord } from "#query/scope.ts";
+import type { AnyRelation, Fact, InsertFact } from "#relation.ts";
+import type { Schema, SchemaRelations } from "#schema.ts";
+import type { KeyStatement, Statement } from "#statements.ts";
+/**
+ * The ordinary (writable, scannable) relations of a schema's record — the
+ * only values the runtime methods accept: closed relations lack the
+ * relation shape entirely, so passing one is a type error.
+ */
+type MemberRelation<Rels extends SchemaRelations> = Extract<Rels[keyof Rels], AnyRelation>;
+/**
+ * The key object of a key-statement-selected `get`: exactly the selected
+ * `key()` statement's projection fields, each carrying the relation's own
+ * branded value type — the {@link KeyFact} rule generalized from the
+ * primary key to ANY declared key statement.
+ */
+type DeclaredKeyFact<R extends AnyRelation, Projection extends readonly string[]> = {
+    readonly [K in Projection[number] & keyof Fact<R>]: Fact<R>[K];
+};
+/**
+ * One offending fact of a violation: the cited relation's name (a member
+ * of the schema's record) and the fact decoded to a named natural-value
+ * object — partial exactly as the engine cites it.
+ */
+interface OffendingFact<Rels extends SchemaRelations> {
+    readonly relation: keyof Rels & string;
+    readonly fact: Readonly<Record<string, FactValue>>;
+}
+/**
+ * One violated statement of a rejected commit, as a typed value.
+ * `statement` is the IDENTICAL SDK statement value the schema declared —
+ * consumers `===`-match it against their own constants; it is `undefined`
+ * exactly for the engine-materialized fresh-implied and closed auto-keys,
+ * which have no declared spelling (`schema()` rejects an explicit
+ * duplicate of them). `canonical` is the ENGINE's rendering of the
+ * violated materialized statement — for a `mirrors` statement BOTH
+ * materialized slots render as the one `==` utterance in the written
+ * orientation (identical strings; the engine's `render.rs` renders each
+ * partner of a mirrored pair as the `==` spelling, never a bare `<=`
+ * direction). `direction` (`sourceUnsatisfied` | `targetRequired`) and
+ * `count` are the containment/window form payloads, passed through from
+ * the engine VERBATIM — `direction` is relative to the violated SLOT's
+ * own orientation, so for a `mirrors` statement it alone cannot say which
+ * side of the `==` was violated: the slot identity is carried by
+ * `orientation`, present exactly for `mirrors` slots — `written` is the
+ * `source <= target` slot as the statement was spelled, `mirrored` the
+ * engine-materialized `target <= source` partner.
+ */
+interface Violation<Rels extends SchemaRelations> {
+    readonly statement: Statement | undefined;
+    readonly kind: StatementKindTag;
+    readonly canonical: string;
+    readonly direction?: "sourceUnsatisfied" | "targetRequired";
+    readonly orientation?: "written" | "mirrored";
+    readonly count?: bigint;
+    readonly facts: readonly OffendingFact<Rels>[];
+}
+/**
+ * A commit's domain outcome: the committed generation, or the COMPLETE
+ * violation set (every violated statement cited once, per direction for a
+ * containment, in materialized statement order). Narrows on `.ok`.
+ */
+type WriteResult<Rels extends SchemaRelations> = {
+    readonly ok: true;
+    readonly generation: bigint;
+} | {
+    readonly ok: false;
+    readonly violations: readonly Violation<Rels>[];
+};
+/** The delta-building callback of a write: runs synchronously against the live transaction. */
+type DeltaBuild<Rels extends SchemaRelations> = (tx: Tx<Rels>) => void;
+/**
+ * The runtime discriminant of {@link Abandon} values — a property probe is
+ * how `writeWitnessed` distinguishes "abort without committing" from an
+ * ordinary callback result, never a guess about the host's own value shapes.
+ */
+declare const abandonMark: unique symbol;
+/**
+ * The abandon sentinel {@link abandon} builds: returning one from a
+ * `writeWitnessed` callback aborts the attempt WITHOUT committing (no empty
+ * commit is ever issued) and surfaces the payload as
+ * `{ ok: false, abandoned: payload }`.
+ */
+interface Abandon<P> {
+    readonly [abandonMark]: true;
+    readonly payload: P;
+}
+/**
+ * Wraps a payload in the {@link Abandon} sentinel — the one way a
+ * `writeWitnessed` callback declines to commit: `return abandon(payload)`
+ * aborts the delta (nothing is committed, not even an empty commit) and the
+ * write resolves to `{ ok: false, abandoned: payload }`.
+ */
+declare function abandon<P>(payload: P): Abandon<P>;
+/**
+ * The abandon payload type a `writeWitnessed` callback's return type
+ * implies: the payload of its `Abandon` arm, `never` when the callback can
+ * never abandon (the `abandoned` outcome is then statically unreachable).
+ */
+type AbandonedPayload<R> = R extends Abandon<infer P> ? P : never;
+/**
+ * `writeWitnessed`'s domain outcome: the committed generation, the COMPLETE
+ * engine violation set (rejection-as-data, exactly {@link WriteResult}'s
+ * false arm), or the callback's own abandon payload. Narrows on `.ok`, then
+ * on `"violations" in result`.
+ */
+type WitnessedWriteResult<Rels extends SchemaRelations, R> = {
+    readonly ok: true;
+    readonly generation: bigint;
+} | {
+    readonly ok: false;
+    readonly violations: readonly Violation<Rels>[];
+} | {
+    readonly ok: false;
+    readonly abandoned: AbandonedPayload<R>;
+};
+/**
+ * One live write transaction: the submitted delta with the engine's
+ * FINAL-STATE point-read view (base + pending delta — the exact state the
+ * commit judgment judges, so check-then-act is race-free by construction).
+ * Spent when its owning `write`/`writeWitnessed` call resolves the attempt;
+ * any later use throws.
+ */
+interface Tx<Rels extends SchemaRelations> {
+    /**
+     * Records one insert. Omitted fresh fields are MINTED through the
+     * engine's alloc lane and returned branded; supplying them instead
+     * preserves identity (the resupply idiom). Returns the relation's
+     * fresh cells, minted or resupplied.
+     */
+    insert<R extends MemberRelation<Rels>>(relation: R, fact: InsertFact<R>): Minted<R>;
+    /** Records one delete; `true` iff the final state changed. */
+    delete<R extends MemberRelation<Rels>>(relation: R, fact: Fact<R>): boolean;
+    /** Final-state membership of one complete fact. */
+    contains<R extends MemberRelation<Rels>>(relation: R, fact: Fact<R>): boolean;
+    /**
+     * Final-state point lookup through the relation's primary key (the
+     * {@link KeyFact} rule); `undefined` on a miss.
+     */
+    get<R extends MemberRelation<Rels>>(relation: R, key: KeyFact<R>): Fact<R> | undefined;
+    /**
+     * Final-state point lookup through a DECLARED `key()` statement of this
+     * schema — the key object is typed by the statement's own projection;
+     * `undefined` on a miss.
+     */
+    get<R extends MemberRelation<Rels>, const P extends readonly string[]>(relation: R, keyStatement: KeyStatement<R, P>, key: DeclaredKeyFact<R, P>): Fact<R> | undefined;
+}
+/**
+ * The read view one `db.read(fn)` call scopes: an MVCC snapshot pinned at
+ * its generation, valid EXACTLY for the synchronous extent of `fn`. The
+ * value is invalidated when `fn` returns — every later verb call throws a
+ * typed used-after-scope error; the underlying snapshot (and its LMDB
+ * reader slot) is already closed. No close spelling exists here because
+ * there is nothing the host could ever need to close.
+ */
+interface ReadScope<Rels extends SchemaRelations> {
+    /**
+     * The committed generation this scope witnessed — captured atomically
+     * with the snapshot: writes are synchronous and this process holds the
+     * store's only write handle, so nothing can commit between the snapshot
+     * open and the generation read.
+     */
+    readonly generation: bigint;
+    /** Full-relation export in row-id order, decoded to branded facts. */
+    scan<R extends MemberRelation<Rels>>(relation: R): Fact<R>[];
+    /**
+     * Committed-state point lookup through the relation's primary key
+     * (the {@link KeyFact} rule); `undefined` on a miss.
+     */
+    get<R extends MemberRelation<Rels>>(relation: R, key: KeyFact<R>): Fact<R> | undefined;
+    /**
+     * Committed-state point lookup through a DECLARED `key()` statement of
+     * this schema — the key object is typed by the statement's own
+     * projection; `undefined` on a miss.
+     */
+    get<R extends MemberRelation<Rels>, const P extends readonly string[]>(relation: R, keyStatement: KeyStatement<R, P>, key: DeclaredKeyFact<R, P>): Fact<R> | undefined;
+    /** Committed-state membership of one complete fact. */
+    contains<R extends MemberRelation<Rels>>(relation: R, fact: Fact<R>): boolean;
+    /**
+     * Executes a prepared query against this scope's snapshot with the
+     * typed params object; returns the answer SET as plain rows with
+     * branded values (no order — the host sorts). This is the ONE
+     * execution spelling ({@link Prepared} carries no `execute`).
+     */
+    execute<Row, Params extends ParamsRecord>(prepared: Prepared<Rels, Row, Params>, params: Params): Row[];
+}
+/**
+ * One prepared query as a plain VALUE: explicit visible compilation
+ * (`db.prepare(q)` lowers, pins the plan, and surfaces every engine roster
+ * refusal), no lifecycle. Execution happens ONLY through
+ * `snap.execute(prepared, params)` / `db.execute(prepared, params)` — the
+ * symmetry rule's one spelling. The engine-side plan is reclaimed by a GC
+ * finalizer when this value becomes unreachable (reclamation only, never
+ * correctness — an unreclaimed plan is idle memory, and process exit frees
+ * everything).
+ */
+interface Prepared<Rels extends SchemaRelations, Row, Params extends ParamsRecord> {
+    /**
+     * The pull-based plan-drift report against a read scope's snapshot —
+     * engine-policy-free: no threshold exists engine-side; the host owns
+     * re-prepare.
+     */
+    staleness(snap: ReadScope<Rels>): Staleness;
+    readonly [phantom]?: {
+        readonly row: Row;
+        readonly params: Params;
+    };
+}
+/**
+ * An open store, cached per canonical path for the life of the process.
+ * There is no close: read through `read`/the read sugar, write through
+ * `write`/`writeWitnessed`, and let the process own the environment's
+ * lifetime (the engine fsyncs every commit, so durability never waits on a
+ * close).
+ */
+interface Db<Rels extends SchemaRelations> {
+    /** The theory this store was opened with (fingerprint-verified by the engine). */
+    readonly schema: Schema<Rels>;
+    /**
+     * One scoped snapshot read: opens an MVCC snapshot, runs `fn`
+     * SYNCHRONOUSLY against it, and closes the snapshot unconditionally
+     * before returning `fn`'s result. The {@link ReadScope} is invalidated
+     * when `fn` returns — a used-after-scope call throws a typed error.
+     */
+    read<T>(fn: (snap: ReadScope<Rels>) => T): T;
+    /** `db.scan(r)` === `db.read(snap => snap.scan(r))` — the symmetry rule. */
+    scan<R extends MemberRelation<Rels>>(relation: R): Fact<R>[];
+    /** `db.get(r, k)` === `db.read(snap => snap.get(r, k))` — the symmetry rule. */
+    get<R extends MemberRelation<Rels>>(relation: R, key: KeyFact<R>): Fact<R> | undefined;
+    /** `db.get(r, s, k)` === `db.read(snap => snap.get(r, s, k))` — the symmetry rule, keyed form. */
+    get<R extends MemberRelation<Rels>, const P extends readonly string[]>(relation: R, keyStatement: KeyStatement<R, P>, key: DeclaredKeyFact<R, P>): Fact<R> | undefined;
+    /** `db.contains(r, f)` === `db.read(snap => snap.contains(r, f))` — the symmetry rule. */
+    contains<R extends MemberRelation<Rels>>(relation: R, fact: Fact<R>): boolean;
+    /** `db.execute(p, params)` === `db.read(snap => snap.execute(p, params))` — the symmetry rule. */
+    execute<Row, Params extends ParamsRecord>(prepared: Prepared<Rels, Row, Params>, params: Params): Row[];
+    /**
+     * One delta transaction: builds the delta synchronously through `fn`,
+     * commits, and returns the domain outcome. A throw from `fn` aborts
+     * the delta (LMDB untouched) and rethrows wrapped.
+     */
+    write(fn: DeltaBuild<Rels>): WriteResult<Rels>;
+    /**
+     * The ONE witnessed-write form: snapshot → `fn` (premise reads via
+     * `snap`, delta via `tx`) → witnessed commit, which lands only if no
+     * state-changing commit intervened since the snapshot. On a moved
+     * generation the WHOLE `fn` reruns on a fresh snapshot, unbounded: this
+     * process holds the store's only write handle, so every generation move
+     * is self-inflicted by the host's own interleaved writes — contention
+     * is bounded by the host's own progress, and any retry cap would be an
+     * invented limit (the house no-limits law). `fn` may decline to commit
+     * by returning {@link abandon}`(payload)` — the outcome is then
+     * `{ ok: false, abandoned: payload }` and NO commit (not even an empty
+     * one) is issued.
+     */
+    writeWitnessed<R>(fn: (snap: ReadScope<Rels>, tx: Tx<Rels>) => R): WitnessedWriteResult<Rels, R>;
+    /**
+     * Prepares a query value built against THIS schema (identity is the
+     * membership rule): lowers it to the engine IR, pins the plan, and
+     * returns the typed {@link Prepared} value. Every IR roster refusal —
+     * rule caps, strata legality, type rules — is the ENGINE's typed
+     * judgment and throws here carrying its message intact.
+     */
+    prepare<Row, Params extends ParamsRecord>(q: Query<Rels, Row, Params>): Prepared<Rels, Row, Params>;
+}
+/**
+ * The store lifecycle — `Db.create(path, schema)` / `Db.open(path, schema)`.
+ * Create refuses an already-initialized directory; open verifies format
+ * version, store kind, and the schema fingerprint. Both return values
+ * CACHED per canonical path: a second open of the same path with the
+ * identical theory value returns the SAME `Db`, and a different theory on
+ * a cached path is a typed fingerprint error. There is no close anywhere:
+ * the process owns every cached environment until exit (a best-effort exit
+ * hook closes them; durability is the engine's per-commit fsync). One
+ * store kind exists: durable — resume = reopen, meaning this process's
+ * cached value or a fresh process's open.
+ */
+declare const Db: Readonly<{
+    /** Creates a fresh durable store at `path` from the schema; the value is cached for every later open. */
+    create<Rels extends SchemaRelations>(path: string, theory: Schema<Rels>): Promise<Db<Rels>>;
+    /**
+     * Opens an existing durable store at `path` with the same theory — the
+     * cached value when this process already holds it. A fingerprint-matching
+     * open also BACK-FILLS the store's persisted schema descriptor when it is
+     * absent (self-describing stores, engine 50-storage.md § the `_meta`
+     * block), so a legacy store becomes exhumable after one ordinary open —
+     * adoption is automatic, never a separate verb.
+     */
+    open<Rels extends SchemaRelations>(path: string, theory: Schema<Rels>): Promise<Db<Rels>>;
+    /**
+     * Opens a store READ-ONLY from its own persisted descriptor — the SDK's
+     * one schema-independent read path (no theory, no fingerprint check; the
+     * store rebirth tool's entry). Lives beside `open`/`create` so the path
+     * law stays in one place: the same `node:path.resolve` canonicalization,
+     * applied here. The value is NOT cached and carries no close: the
+     * engine-side handle (and the store's exclusive lock) is reclaimed by GC
+     * — reclamation only, never correctness. A store not yet adopted rejects
+     * with the typed `ErrExhumeNoDescriptor` (the remedy: one
+     * fingerprint-matching `Db.open` under the creating schema back-fills
+     * the descriptor).
+     */
+    exhume(storePath: string): Promise<Exhumed>;
+}>;
+export type { Abandon, DeclaredKeyFact, DeltaBuild, MemberRelation, OffendingFact, Prepared, ReadScope, Tx, Violation, WitnessedWriteResult, WriteResult };
+export { abandon, Db };
+//# sourceMappingURL=db.d.ts.map

package/dist/db.d.ts.map

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