@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/dist/native.d.ts

@@ -1,50 +1,42 @@
 import type { SchemaSpec, ValueSpec, ValueTypeSpec } from "./spec.js";
-/** The opaque database handle (owns the LMDB environment + exclusive lock). */
+/**
+ * The opaque managed database capability. The native runtime registry —
+ * not this wrapper — owns the LMDB environment, the kernel directory
+ * lock and every session; a retained wrapper after a completed close is
+ * inert. Minted only by the managed handshake
+ * (`runtimeDirectoryDbOpen` → `runtimeDbTake` in #runtime-native.ts).
+ */
 type DbHandle = {
     readonly __brand: "bumbledb.db";
 };
-type InstanceHandle = {
-    readonly __brand: "bumbledb.instance";
-};
-type WitnessHandle = {
-    readonly __brand: "bumbledb.witness";
-};
-type BuilderHandle = {
-    readonly __brand: "bumbledb.builder";
-};
-type OwnedHandle = {
-    readonly __brand: "bumbledb.owned";
-};
-type TxHandle = {
-    readonly __brand: "bumbledb.tx";
-};
-type PreparedHandle = {
-    readonly __brand: "bumbledb.prepared";
-};
+/** Admitted owned instance attached through directory publish — not a JS builder. */
 /**
- * The sealed per-theory log codec (`crates/bumbledb-log`): descriptor
- * parsed once — vocabulary + braid map — beside the fingerprint the wire
- * pins. Immutable plain data; no lifecycle verbs.
+ * The sealed per-theory log schema (`crates/bumbledb-log` successor
+ * lanes): the validated core schema plus its fingerprint, shared by the
+ * command/decision grammar. Immutable plain data; no lifecycle verbs.
  */
-type LogCodecHandle = {
-    readonly __brand: "bumbledb.logCodec";
-};
-interface WireMutationReport {
-    readonly submitted: bigint;
-    readonly changed: bigint;
-}
-type WireFreshRange = {
-    readonly empty: true;
-} | {
-    readonly empty: false;
-    readonly start: bigint;
-    readonly endExclusive: bigint;
+type LogSchemaHandle = {
+    readonly __brand: "bumbledb.logSchema";
 };
+/** A discrete half-open interval `[start, end)` over u64/i64. */
 interface IntervalValue {
     readonly start: bigint;
     readonly end: bigint;
 }
-type FactValue = boolean | bigint | string | Uint8Array | IntervalValue;
+/**
+ * A dense-line half-open interval with canonical binary64 endpoints:
+ * NaN-free, strictly ordered; ±Infinity are unbounded endpoints.
+ */
+interface F64IntervalValue {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * One marshalled cell. An application-owned Uuid crosses as its
+ * canonical hyphenated UUID string (chapter 32); there is no fresh
+ * range, reservation counter or issuance value anywhere on this wire.
+ */
+type FactValue = boolean | bigint | number | string | Uint8Array | IntervalValue | F64IntervalValue;
 type TaggedValue = ValueSpec;
 type QueryParam = TaggedValue | {
     readonly kind: "set";
@@ -73,11 +65,56 @@ interface RecIr {
 }
 type HeadTermIr = {
     readonly kind: "var";
+} | {
+    readonly kind: "compute";
 } | {
     readonly kind: "aggregate";
     readonly op: HeadOpIr;
 };
-type HeadOpIr = "sum" | "min" | "max" | "count" | "pack";
+type HeadOpIr = "sum" | "mean" | "min" | "max" | "count" | "pack";
+/**
+ * The computed-find scalar expression (C05 `FindTerm::Compute(ScalarExpr)`):
+ * exactly the frozen core roster, spelled as the migration plan JSON spells
+ * the same expressions (one grammar, no second evaluator). `var` binds a
+ * rule variable ordinal on this lane.
+ */
+type NumericCastIr = "toF64" | "toF64Exact" | "toI64Exact" | "toU64Exact";
+type ScalarExprIr = {
+    readonly kind: "var";
+    readonly var: number;
+} | {
+    readonly kind: "literal";
+    readonly value: TaggedValue;
+} | {
+    readonly kind: "negate";
+    readonly expr: ScalarExprIr;
+} | {
+    readonly kind: "add";
+    readonly left: ScalarExprIr;
+    readonly right: ScalarExprIr;
+} | {
+    readonly kind: "subtract";
+    readonly left: ScalarExprIr;
+    readonly right: ScalarExprIr;
+} | {
+    readonly kind: "multiply";
+    readonly left: ScalarExprIr;
+    readonly right: ScalarExprIr;
+} | {
+    readonly kind: "divide";
+    readonly left: ScalarExprIr;
+    readonly right: ScalarExprIr;
+} | {
+    readonly kind: "cast";
+    readonly cast: NumericCastIr;
+    readonly expr: ScalarExprIr;
+} | {
+    readonly kind: "isNaN";
+    readonly expr: ScalarExprIr;
+} | {
+    readonly kind: "isFinite";
+    readonly expr: ScalarExprIr;
+};
 interface RuleIr {
     readonly finds: readonly FindTermIr[];
     readonly atoms: readonly AtomIr[];
@@ -86,6 +123,8 @@ interface RuleIr {
 }
 type FoldOpIr = {
     readonly kind: "sum";
+} | {
+    readonly kind: "mean";
 } | {
     readonly kind: "min";
 } | {
@@ -94,6 +133,9 @@ type FoldOpIr = {
 type FindTermIr = {
     readonly kind: "var";
     readonly var: number;
+} | {
+    readonly kind: "compute";
+    readonly expr: ScalarExprIr;
 } | {
     readonly kind: "count";
 } | {
@@ -110,6 +152,8 @@ type ParsedQuery = QueryIr & {
 };
 type AggOpIr = {
     readonly kind: "sum";
+} | {
+    readonly kind: "mean";
 } | {
     readonly kind: "min";
 } | {
@@ -178,9 +222,9 @@ type ConditionTreeIr = {
 };
 type StatementKindTag = "functionality" | "containment" | "capacity";
 /**
- * A log grammar lane's domain outcome: the payload, or a refusal row
- * whose `kind` is an identity string spelled exactly as
- * `crates/bumbledb-log` spells it (the `log-identities.json` mint table).
+ * A grammar lane's domain outcome: the payload, or a refusal row whose
+ * `kind` is an identity string spelled exactly as `bumbledb-log`'s
+ * identities emitter spells it (`logIdentities()` / log-identities.json).
  */
 type LogResult<T, K extends string> = {
     readonly ok: true;
@@ -190,98 +234,155 @@ type LogResult<T, K extends string> = {
     readonly kind: K;
     readonly message: string;
 };
-/** `DecodeError::identity` — the batch decode refusal identities. */
-type LogBatchDecodeKind = "Truncated" | "BadMagic" | "Version" | "Flags" | "FingerprintMismatch" | "UnknownBraid" | "UnknownOpKind" | "UnknownRelation" | "ClosedRelation" | "OpRelationOutsideBraid" | "TagMismatch" | "BoolByte" | "InvalidUtf8" | "EmptyInterval" | "IntervalOverflow" | "TrailingBytes";
-/** The batch encode refusal identities (`EncodeError`, bridge-spelled). */
-type LogBatchEncodeKind = "FingerprintMismatch" | "UnknownBraid" | "UnknownRelation" | "ClosedRelation" | "OpRelationOutsideBraid" | "Arity" | "Value" | "TooManyOps" | "TooManyRows";
-/** `ManifestError::identity`. */
-type LogManifestKind = "Malformed" | "Version";
-/** `CheckpointError::identity`. */
-type LogCheckpointKind = "Malformed" | "Version" | "Overflow" | "UnknownBraid" | "BraidSet";
-/** `SidecarError::identity`. */
-type LogSidecarKind = "Malformed" | "Version" | "UnknownBraid" | "Overflow";
-/**
- * The batch header both directions. The codec handle is the fingerprint
- * authority — the wire never carries one. `braid` is the raw braid id
- * (the smallest relation id in its component).
- */
-interface LogBatchHeader {
-    readonly braid: number;
-    readonly braidGen: bigint;
-    readonly prev: Uint8Array;
-    readonly writer: bigint;
-    readonly timestamp: bigint;
-}
-type LogOpKind = "insert" | "delete";
-/**
- * One op inbound to `logEncodeBatch`: rows carry TAGGED values (the
- * query-literal lane's inbound spelling) so the bridge stays layout-blind
- * and the codec core is the one judge of every cell.
- */
-interface LogOpIn {
-    readonly kind: LogOpKind;
-    readonly relation: number;
-    readonly rows: ReadonlyArray<readonly TaggedValue[]>;
-}
-/** One decoded op: rows cross exactly as the engine's `ValueOut` walk. */
-interface LogOpOut {
-    readonly kind: LogOpKind;
-    readonly relation: number;
-    readonly rows: FactValue[][];
+/** `FrameError` kinds (the `frame` identity family). */
+type LogFrameKind = "limitExceeded" | "lengthOverflow" | "allocation" | "truncated" | "family" | "layout" | "kind" | "tag" | "invalidEpoch" | "stateIdentityMismatch" | "emptyChangeSummary" | "emptyEvidence" | "invalidTerminalStamp" | "invalidPreconditionEvidence" | "invalidPolicy" | "invalidSequence" | "invalidCount" | "trailingBytes";
+/** Receipt-row kinds: the frame family plus the foreign-scope refusal. */
+type LogReceiptKind = LogFrameKind | "foreignRow";
+/** Command-lane kinds: frame family plus the two command-only arms. */
+type LogCommandKind = LogFrameKind | "core" | "schemaMismatch";
+/** Chain-step refusals from the decode-and-verify lane. */
+type LogChainKind = "wrongParent" | "wrongSequence";
+/** The complete database scope of every command/receipt/decision. */
+interface LogIdentity {
+    /** Application-owned Uuid, canonical hyphenated UUID. */
+    readonly databaseId: string;
+    readonly incarnationId: string;
+    /** The core schema fingerprint, 64 lowercase hex characters. */
+    readonly schemaId: string;
 }
-interface LogBatch {
-    readonly header: LogBatchHeader;
-    readonly ops: readonly LogOpOut[];
+interface LogStateStamp {
+    readonly incarnation: string;
+    readonly dataRevision: bigint;
 }
-interface LogBraidComponent {
-    readonly braid: number;
-    readonly relations: readonly number[];
+interface LogDecisionStamp {
+    readonly seq: bigint;
+    readonly hash: Uint8Array;
 }
-/** The braid decomposition + serial-at statement ids of one theory. */
-interface LogBraids {
-    readonly components: readonly LogBraidComponent[];
-    readonly serialAt: readonly number[];
+type LogCondition = {
+    readonly kind: "unconditional";
+} | {
+    readonly kind: "exactState";
+    readonly state: LogStateStamp;
+};
+interface LogCommandId {
+    readonly receiptEpoch: bigint;
+    readonly requestId: string;
 }
-/** The manifest document: an absent `checkpoint` is the store-birth null arm. */
-interface LogManifestDoc {
-    readonly fingerprint: Uint8Array;
-    readonly checkpoint?: Uint8Array;
+interface LogCommandMetadata {
+    readonly identity: LogIdentity;
+    readonly id: LogCommandId;
+    readonly condition: LogCondition;
 }
-interface LogCheckpointHead {
-    readonly braid: number;
-    readonly g: bigint;
-    readonly hash: Uint8Array;
-    readonly ts: bigint;
+interface LogCommandRef {
+    readonly identity: LogIdentity;
+    readonly receiptEpoch: bigint;
+    readonly requestId: string;
+    readonly digest: Uint8Array;
 }
-/** The `ckpt/{digest}` document. Derived facts (digest, vector sum) stay derived. */
-interface LogCheckpointDoc {
-    readonly braids: readonly LogCheckpointHead[];
-    readonly catalog: Uint8Array;
-    readonly writer: bigint;
-    readonly prev?: Uint8Array;
+type LogOutcomeWire = {
+    readonly kind: "committed";
+    readonly added: bigint;
+    readonly removed: bigint;
+    readonly result?: Uint8Array;
+} | {
+    readonly kind: "noChange";
+    readonly result?: Uint8Array;
+} | {
+    readonly kind: "preconditionFailed";
+    readonly expected: LogStateStamp;
+    readonly observed: LogStateStamp;
+} | {
+    readonly kind: "invariantRejected";
+    readonly evidence: Uint8Array;
+};
+interface LogReceipt {
+    readonly command: LogCommandRef;
+    readonly decisionAt: LogDecisionStamp;
+    readonly stateAt: LogStateStamp;
+    readonly outcome: LogOutcomeWire;
 }
-interface LogChainEntry {
-    readonly braid: number;
-    readonly g: bigint;
-    readonly prev: Uint8Array;
-    readonly ts: bigint;
+interface LogLimits {
+    readonly envelopeBytes: bigint;
+    readonly changeBytes: bigint;
+    readonly evidenceBytes: bigint;
+    readonly resultBytes: bigint;
 }
-interface LogPendingBatch {
-    readonly braid: number;
-    readonly slot: bigint;
-    readonly bytes: Uint8Array;
+type LogAccess = {
+    readonly kind: "active";
+} | {
+    readonly kind: "frozen";
+    readonly operation: string;
+    readonly intent: {
+        readonly kind: "erasure";
+    } | {
+        readonly kind: "migration";
+        readonly planSetDigest: Uint8Array;
+        readonly target: string;
+    };
+};
+type LogLifecycle = {
+    readonly kind: "live";
+    readonly access: LogAccess;
+    readonly decision: LogDecisionStamp;
+    readonly state: LogStateStamp;
+    readonly receipts: {
+        readonly openEpoch: bigint;
+        readonly retiredThrough: bigint;
+    };
+} | {
+    readonly kind: "deleted";
+    readonly operation: string;
+    readonly reason: {
+        readonly kind: "erasure";
+    } | {
+        readonly kind: "migrationAborted";
+        readonly sourceDatabase: string;
+        readonly sourceIncarnation: string;
+        readonly planSetDigest: Uint8Array;
+    };
+};
+type LogActivation = {
+    readonly kind: "notActivated";
+} | {
+    readonly kind: "activated";
+    readonly operation: string;
+    readonly targetGenesis: Uint8Array;
+    readonly cause: {
+        readonly kind: "create";
+    } | {
+        readonly kind: "restore";
+    } | {
+        readonly kind: "migration";
+        readonly planSetDigest: Uint8Array;
+    };
+};
+interface LogAuthority {
+    readonly identity: LogIdentity;
+    readonly revision: bigint;
+    readonly lifecycle: LogLifecycle;
+    readonly activation: LogActivation;
 }
-/** The chain sidecar document: an absent `pending` is the `Settled` arm. */
-interface LogChain {
-    readonly entries: readonly LogChainEntry[];
-    readonly pending?: LogPendingBatch;
+type LogGenesisProvenance = {
+    readonly kind: "create";
+} | {
+    readonly kind: "restore";
+    readonly sourceEvidence: Uint8Array;
+} | {
+    readonly kind: "migration";
+    readonly sourceDatabase: string;
+    readonly sourceIncarnation: string;
+    readonly planSetDigest: Uint8Array;
+};
+interface LogGenesis {
+    readonly identity: LogIdentity;
+    readonly initialApplicationDigest: Uint8Array;
+    readonly initialSystemDigest: Uint8Array;
+    readonly provenance: LogGenesisProvenance;
 }
 interface ManifestField {
     readonly name: string;
     readonly id: number;
     readonly valueType: ValueTypeSpec;
-    /** The field's fresh attribute, straight off the declared spec; a closed relation's synthetic `id` slot is never fresh. */
-    readonly fresh: boolean;
     /** The field's host newtype name off the declared spec; a closed relation's synthetic `id` slot carries the handle newtype. Absent on a bare column. */
     readonly newtype?: string;
 }
@@ -299,15 +400,6 @@ interface ManifestRelation {
     readonly fields: readonly ManifestField[];
     readonly extension?: readonly ManifestRow[];
 }
-interface ManifestStatement {
-    readonly id: number;
-    readonly kind: StatementKindTag;
-    readonly spelling: string;
-}
-interface Manifest {
-    readonly relations: readonly ManifestRelation[];
-    readonly statements: readonly ManifestStatement[];
-}
 interface SealedSide {
     readonly relation: number;
     readonly projection: readonly number[];
@@ -386,159 +478,48 @@ type Violation = {
     readonly measure: bigint;
     readonly facts: readonly ViolationFact[];
 };
-type CreateResult = {
-    readonly tag: "accepted";
-    readonly db: DbHandle;
-} | {
-    readonly tag: "rejected";
-    readonly violations: readonly Violation[];
-} | {
-    readonly tag: "schemaError";
-    readonly message: string;
-} | {
-    readonly tag: "newtypeMismatch";
-    readonly message: string;
-};
-/**
- * `dbOpen`'s domain outcome. `schemaError` spans both spec
- * resolution (unresolvable names, banned spellings — every issue in one
- * message) and schema validation at the declaration boundary;
- * `newtypeMismatch` is the coherence wall's own kind; `fingerprintMismatch`
- * is `dbOpen`'s stored-theory refusal.
- */
-type DbOpenResult = {
-    readonly ok: true;
-    readonly db: DbHandle;
-} | {
-    readonly ok: false;
-    readonly kind: "schemaError" | "newtypeMismatch" | "fingerprintMismatch";
-    readonly message: string;
-};
-type NativeWriteOutcome = {
-    readonly tag: "accepted";
-    readonly generation: bigint;
-} | {
-    readonly tag: "rejected";
-    readonly violations: readonly Violation[];
-} | {
-    readonly tag: "abandoned";
-} | {
-    readonly tag: "moved";
-    readonly witnessed: bigint;
-    readonly current: bigint;
-};
-type AdmitResult = {
-    readonly tag: "accepted";
-    readonly value: OwnedHandle;
-} | {
-    readonly tag: "rejected";
-    readonly violations: readonly Violation[];
-};
-type PrepareResult = {
-    readonly ok: true;
-    readonly prepared: PreparedHandle;
-} | {
-    readonly ok: false;
-    readonly kind: "irError";
-    readonly message: string;
-};
-type ErrorFamilyKind = "formatMismatch" | "schemaMismatch" | "alreadyInitialized" | "destinationExists" | "publishedButUnsynced" | "environmentLocked" | "io" | "lmdb" | "readersFull" | "schema" | "validation" | "factShape" | "freshExhausted" | "closedRelationWrite" | "commitSync" | "transactionPoisoned" | "foreignPrepared" | "foreignWitness" | "param" | "capacityRayMeasure" | "derivedBudgetExceeded" | "overflow" | "resultBytesOverflow" | "corruption";
+type ErrorFamilyKind = "formatMismatch" | "schemaMismatch" | "alreadyInitialized" | "destinationExists" | "publishedButUnsynced" | "environmentLocked" | "io" | "lmdb" | "readersFull" | "schema" | "validation" | "factShape" | "closedRelationWrite" | "commitSync" | "transactionPoisoned" | "foreignPrepared" | "foreignWitness" | "param" | "capacityRayMeasure" | "derivedBudgetExceeded" | "overflow" | "scalar" | "resultBytesOverflow" | "corruption" | "store";
 type AdmissionTag = "accepted" | "rejected";
 type WriteTag = "accepted" | "rejected" | "abandoned" | "moved";
-type OpenKind = "schemaError" | "newtypeMismatch" | "fingerprintMismatch";
+type OpenKind = "schemaError" | "newtypeMismatch" | "fingerprintMismatch" | "destinationExists";
 type PrepareKind = "irError";
 interface Native {
     engineVersion(): string;
+    /** Small identity-sized inputs only; bulk hashing rides `runtimeHash`. */
     blake3Hash(data: Uint8Array): Uint8Array;
     descriptor(spec: SchemaSpec): SealedDescriptor;
-    dbCreate(path: string, spec: SchemaSpec): Promise<CreateResult>;
-    dbOpen(path: string, spec: SchemaSpec): Promise<DbOpenResult>;
-    dbManifest(db: DbHandle): Manifest;
-    dbFingerprint(db: DbHandle): string;
-    dbGeneration(db: DbHandle): bigint;
-    /**
-     * blake3 over the canonical catalog enumeration — the replication
-     * equality oracle: equal digests imply identical judged content
-     * regardless of page layout or allocation history.
-     */
-    dbCatalogDigest(db: DbHandle): Uint8Array;
-    dbFromInstance(path: string, instance: OwnedHandle): Promise<DbHandle>;
-    /**
-     * Runs `callback` synchronously inside the engine read lease. The
-     * instance handle is invalid after the callback returns; the witness
-     * handle is a clone and may escape.
-     */
-    dbRead<R>(db: DbHandle, callback: (instance: InstanceHandle, witness: WitnessHandle) => R): R;
-    instanceGeneration(instance: InstanceHandle): bigint;
-    instanceScan(instance: InstanceHandle, relationId: number): FactValue[][];
-    instanceCount(instance: InstanceHandle, relationId: number): bigint;
-    instanceContains(instance: InstanceHandle, relationId: number, values: readonly FactValue[]): boolean;
-    instanceGet(instance: InstanceHandle, relationId: number, keyStatementId: number, keyValues: readonly FactValue[]): FactValue[] | null;
-    instancePrepare(instance: InstanceHandle, query: ParsedQuery): PrepareResult;
-    witnessClose(witness: WitnessHandle): void;
-    dbWrite(db: DbHandle, callback: (tx: TxHandle) => boolean): NativeWriteOutcome;
-    dbWriteFrom(db: DbHandle, witness: WitnessHandle, callback: (tx: TxHandle) => boolean): NativeWriteOutcome;
-    /**
-     * Records a collection of inserts into the delta; returns the engine
-     * `{ submitted, changed }` report. `cells` is ONE flat row-major array
-     * (length rows×arity) in sealed field order, and `rows` is the EXPLICIT
-     * row count the caller states — the one collection crossing: the JS side
-     * alone knows N when the roster is fieldless (N nullary facts project to 0 cells, so no
-     * derivation can recover N), and the bridge verifies
-     * `cells.length === rows × arity` exactly against its resident sealed
-     * roster before building the engine's shape-proved collection in a
-     * single pass. Empty (`rows === 0n`, no cells) is lawful and still a
-     * mutation. Nothing is judged until commit; shape violations throw
-     * typed, naming relation and field.
-     */
-    txInsert(tx: TxHandle, relationId: number, rows: bigint, cells: readonly FactValue[]): WireMutationReport;
-    txDelete(tx: TxHandle, relationId: number, rows: bigint, cells: readonly FactValue[]): WireMutationReport;
-    txContains(tx: TxHandle, relationId: number, values: readonly FactValue[]): boolean;
-    txGet(tx: TxHandle, relationId: number, keyStatementId: number, keyValues: readonly FactValue[]): FactValue[] | null;
-    txReserve(tx: TxHandle, relationId: number, fieldId: number, count: bigint): WireFreshRange;
-    dbPrepare(db: DbHandle, query: ParsedQuery): PrepareResult;
-    preparedExecute(prepared: PreparedHandle, instance: InstanceHandle, params: readonly QueryParam[]): FactValue[][];
-    preparedClose(prepared: PreparedHandle): void;
-    instanceBuilderNew(spec: SchemaSpec): BuilderHandle;
-    instanceBuilderLoad(builder: BuilderHandle, relationId: number, rows: bigint, cells: readonly FactValue[]): WireMutationReport;
-    instanceBuilderDelete(builder: BuilderHandle, relationId: number, rows: bigint, cells: readonly FactValue[]): WireMutationReport;
-    instanceBuilderReserve(builder: BuilderHandle, relationId: number, fieldId: number, count: bigint): WireFreshRange;
-    instanceBuilderContains(builder: BuilderHandle, relationId: number, values: readonly FactValue[]): boolean;
-    instanceBuilderGet(builder: BuilderHandle, relationId: number, keyStatementId: number, keyValues: readonly FactValue[]): FactValue[] | null;
-    instanceBuilderClose(builder: BuilderHandle): void;
-    instanceBuilderAdmit(builder: BuilderHandle): Promise<AdmitResult>;
-    ownedInstanceClose(instance: OwnedHandle): void;
-    ownedScan(instance: OwnedHandle, relationId: number): FactValue[][];
-    ownedCount(instance: OwnedHandle, relationId: number): bigint;
-    ownedContains(instance: OwnedHandle, relationId: number, values: readonly FactValue[]): boolean;
-    ownedGet(instance: OwnedHandle, relationId: number, keyStatementId: number, keyValues: readonly FactValue[]): FactValue[] | null;
-    ownedPrepare(instance: OwnedHandle, query: ParsedQuery): PrepareResult;
-    ownedExecute(prepared: PreparedHandle, instance: OwnedHandle, params: readonly QueryParam[]): FactValue[][];
-    logCodec(descriptor: SealedDescriptor): LogCodecHandle;
-    logBraidsOf(descriptor: SealedDescriptor): LogBraids;
-    logEncodeBatch(handle: LogCodecHandle, header: LogBatchHeader, ops: readonly LogOpIn[]): LogResult<Uint8Array, LogBatchEncodeKind>;
-    logDecodeBatch(handle: LogCodecHandle, bytes: Uint8Array): LogResult<LogBatch, LogBatchDecodeKind>;
-    logParseManifest(bytes: Uint8Array): LogResult<LogManifestDoc, LogManifestKind>;
-    logRenderManifest(doc: LogManifestDoc): Uint8Array;
-    logParseCheckpoint(handle: LogCodecHandle, bytes: Uint8Array): LogResult<LogCheckpointDoc, LogCheckpointKind>;
-    logRenderCheckpoint(handle: LogCodecHandle, doc: LogCheckpointDoc): Uint8Array;
-    logParseSidecar(handle: LogCodecHandle, bytes: Uint8Array): LogResult<LogChain, LogSidecarKind>;
-    logRenderSidecar(handle: LogCodecHandle, chain: LogChain): Uint8Array;
-    logParseCkptScratch(bytes: Uint8Array): Uint8Array | null;
-    logRenderCkptScratch(digest: Uint8Array): Uint8Array;
+    logIdentities(): string;
+    logSchema(spec: SchemaSpec): LogSchemaHandle;
+    logSchemaFingerprint(schema: LogSchemaHandle): string;
+    logReceiptKey(id: LogCommandId): Uint8Array;
+    logReceiptEncode(receipt: LogReceipt, limits: LogLimits): LogResult<Uint8Array, LogReceiptKind>;
+    logReceiptDecode(expected: {
+        readonly identity: LogIdentity;
+        readonly receiptEpoch: bigint;
+        readonly requestId: string;
+    }, bytes: Uint8Array, limits: LogLimits): LogResult<LogReceipt, LogReceiptKind>;
+    logReceiptDecodeAt(id: LogCommandId, bytes: Uint8Array, limits: LogLimits): LogResult<LogReceipt, LogReceiptKind>;
+    logControlEncode(authority: LogAuthority, cap: bigint): LogResult<Uint8Array, LogFrameKind>;
+    logControlDecode(bytes: Uint8Array, cap: bigint): LogResult<LogAuthority, LogFrameKind>;
+    logGenesisEncode(record: LogGenesis, cap: bigint): LogResult<Uint8Array, LogFrameKind>;
+    logGenesisDecode(bytes: Uint8Array, cap: bigint): LogResult<LogGenesis, LogFrameKind>;
+    logGenesisStamp(record: LogGenesis, cap: bigint): LogResult<LogDecisionStamp, LogFrameKind>;
+    logBlankDigests(): {
+        readonly application: Uint8Array;
+        readonly system: Uint8Array;
+    };
 }
 declare const SHIPPED_PLATFORMS: readonly ["darwin-arm64", "linux-arm64", "linux-x64"];
-interface NativeBinding extends Native {
-    dbClose(db: DbHandle): void;
-}
+type NativeBinding = Native;
+/** Lazy singleton: the addon loads on first native access, not module evaluation. */
+declare const native: NativeBinding;
+declare function nativeBindingIsLoaded(): boolean;
 declare function loadNativeBinding(platform: string, arch: string): NativeBinding;
-declare const native: Native;
-declare function dbClose(db: DbHandle): void;
 /**
  * @internal blake3 of the given bytes via the resident native binding —
  * the engine's own hash, lent to the replication driver
  * (`@bjornpagen/bumbledb-log`). Not SDK API; the export is deliberately
- * undocumented in the package surface.
+ * undocumented in the package surface. Small identity-sized inputs only.
  */
 declare function internalBlake3(data: Uint8Array): Uint8Array;
 /**
@@ -550,44 +531,18 @@ declare function internalBlake3(data: Uint8Array): Uint8Array;
  */
 declare function internalDescriptor(spec: SchemaSpec): SealedDescriptor;
 /**
- * @internal the sealed per-theory log codec off the `DescriptorWire` —
- * one implementation of the protocol grammar (`crates/bumbledb-log`),
- * lent to the replication driver (`@bjornpagen/bumbledb-log`). Not SDK
- * API; the export is deliberately undocumented in the package surface.
- */
-declare function internalLogCodec(descriptor: SealedDescriptor): LogCodecHandle;
-/**
- * @internal the braid decomposition + serial-at statement ids, riding
- * the same `DescriptorWire`; the driver caches the result per theory
- * beside the codec handle. Not SDK API.
+ * @internal the successor identity table emitted by the log core's one
+ * speller (`bumbledb_log::identities::emit`). Not SDK API.
  */
-declare function internalLogBraidsOf(descriptor: SealedDescriptor): LogBraids;
-/** @internal batch encode through the sealed codec. Not SDK API. */
-declare function internalLogEncodeBatch(handle: LogCodecHandle, header: LogBatchHeader, ops: readonly LogOpIn[]): LogResult<Uint8Array, LogBatchEncodeKind>;
-/** @internal batch decode through the sealed codec. Not SDK API. */
-declare function internalLogDecodeBatch(handle: LogCodecHandle, bytes: Uint8Array): LogResult<LogBatch, LogBatchDecodeKind>;
-/** @internal manifest document parse — grammar only, no IO. Not SDK API. */
-declare function internalLogParseManifest(bytes: Uint8Array): LogResult<LogManifestDoc, LogManifestKind>;
-/** @internal the manifest's one encoding, byte-exact for CAS bodies. Not SDK API. */
-declare function internalLogRenderManifest(doc: LogManifestDoc): Uint8Array;
-/** @internal checkpoint document parse against the theory's braids. Not SDK API. */
-declare function internalLogParseCheckpoint(handle: LogCodecHandle, bytes: Uint8Array): LogResult<LogCheckpointDoc, LogCheckpointKind>;
-/** @internal checkpoint document render. Not SDK API. */
-declare function internalLogRenderCheckpoint(handle: LogCodecHandle, doc: LogCheckpointDoc): Uint8Array;
-/** @internal chain sidecar parse — the fs half stays in the driver. Not SDK API. */
-declare function internalLogParseSidecar(handle: LogCodecHandle, bytes: Uint8Array): LogResult<LogChain, LogSidecarKind>;
-/** @internal chain sidecar render. Not SDK API. */
-declare function internalLogRenderSidecar(handle: LogCodecHandle, chain: LogChain): Uint8Array;
+declare function internalLogIdentities(): string;
 /**
- * @internal the digest a scratch-lease body names, or null — the refusal
- * is undifferentiated by law. Not SDK API.
+ * @internal the sealed per-theory log schema off the same `SchemaSpec`
+ * every other lane speaks — one validated core schema, lent to the
+ * replication driver (`@bjornpagen/bumbledb-log`). Not SDK API.
  */
-declare function internalLogParseCkptScratch(bytes: Uint8Array): Uint8Array | null;
-/** @internal the scratch-lease body: version byte + 32-byte digest. Not SDK API. */
-declare function internalLogRenderCkptScratch(digest: Uint8Array): Uint8Array;
+declare function internalLogSchema(spec: SchemaSpec): LogSchemaHandle;
 declare function errorFromThrow(caught: unknown): Error;
 declare function bridged<T>(context: string, run: () => T): T;
-declare function bridgedAsync<T>(context: string, run: () => Promise<T>): Promise<T>;
-export type { AdmissionTag, AdmitResult, AggOpIr, AtomIr, AtomSourceIr, BuilderHandle, CmpOpIr, ComparisonIr, ConditionTreeIr, DbHandle, ErrorFamilyKind, FactValue, FindTermIr, HeadOpIr, HeadTermIr, InstanceHandle, IntervalValue, LogBatch, LogBatchDecodeKind, LogBatchEncodeKind, LogBatchHeader, LogBraidComponent, LogBraids, LogChain, LogChainEntry, LogCheckpointDoc, LogCheckpointHead, LogCheckpointKind, LogCodecHandle, LogManifestDoc, LogManifestKind, LogOpIn, LogOpKind, LogOpOut, LogPendingBatch, LogResult, LogSidecarKind, Manifest, NativeWriteOutcome, OpenKind, OwnedHandle, ParsedQuery, PreparedHandle, PrepareKind, QueryIr, QueryParam, RuleIr, SealedDescriptor, SealedHi, SealedSide, SealedStatement, SealedWeight, StatementKindTag, TaggedValue, TermIr, TxHandle, Violation, ViolationFact, WireFreshRange, WireMutationReport, WitnessHandle, WriteTag };
-export { bridged, bridgedAsync, dbClose, errorFromThrow, internalBlake3, internalDescriptor, internalLogBraidsOf, internalLogCodec, internalLogDecodeBatch, internalLogEncodeBatch, internalLogParseCheckpoint, internalLogParseCkptScratch, internalLogParseManifest, internalLogParseSidecar, internalLogRenderCheckpoint, internalLogRenderCkptScratch, internalLogRenderManifest, internalLogRenderSidecar, loadNativeBinding, native, SHIPPED_PLATFORMS };
+export type { AdmissionTag, AggOpIr, AtomIr, AtomSourceIr, CmpOpIr, ComparisonIr, ConditionTreeIr, DbHandle, ErrorFamilyKind, F64IntervalValue, FactValue, FindTermIr, HeadOpIr, HeadTermIr, IntervalValue, LogAccess, LogActivation, LogAuthority, LogChainKind, LogCommandId, LogCommandKind, LogCommandMetadata, LogCommandRef, LogCondition, LogDecisionStamp, LogFrameKind, LogGenesis, LogGenesisProvenance, LogIdentity, LogLifecycle, LogLimits, LogOutcomeWire, LogReceipt, LogReceiptKind, LogResult, LogSchemaHandle, LogStateStamp, NumericCastIr, OpenKind, ParsedQuery, PrepareKind, QueryIr, QueryParam, RuleIr, ScalarExprIr, SealedDescriptor, SealedHi, SealedSide, SealedStatement, SealedWeight, StatementKindTag, TaggedValue, TermIr, Violation, ViolationFact, WriteTag };
+export { bridged, errorFromThrow, internalBlake3, internalDescriptor, internalLogIdentities, internalLogSchema, loadNativeBinding, native, nativeBindingIsLoaded, SHIPPED_PLATFORMS };
 //# sourceMappingURL=native.d.ts.map