keri-ts 0.10.5 → 1.0.0

package/README.md

@@ -15,17 +15,24 @@ npm install keri-ts
 - `keri-ts/runtime`: explicit non-browser-safe runtime surface
 - `keri-ts/db`: explicit LMDB-backed storage surface
 
-Only those three entrypoints are supported public surfaces. Runnable CLI/server
-ownership lives in the separate `tufa` package.
+Those three entrypoints are the general library surfaces. `keri-ts/cli` is the
+separate command-helper boundary used by Tufa. Runnable CLI/server ownership
+lives in `@keri-ts/tufa`.
+
+The runtime exports deliberate operations and data contracts. Scheduling details,
+handler installation, reply-slot state and constructor helpers remain internal;
+implementation-module exports do not automatically become package API. npm deep
+imports such as `keri-ts/app/...` and `keri-ts/core/...` are not supported. Import
+runtime operations from `keri-ts/runtime` and storage from `keri-ts/db`.
 
 ## Maintainer Docs
 
 - `docs/ARCHITECTURE_MAP.md`: package and module ownership map
-- `docs/design-docs/keri/ACDC_TEL_IPEX_VERIFIER_MAINTAINER_GUIDE.md`:
+- `docs/design-docs/credentials/ACDC_TEL_VERIFIER.md`:
   credential stack ownership and failure modes
-- `docs/design-docs/keri/DELEGATION_MULTISIG_ENDPOINT_ROLES_MAINTAINER_GUIDE.md`:
+- `docs/design-docs/kel/DELEGATION_AND_ENDPOINTS.md`:
   delegation, group coordination, and endpoint-role mental model
-- `docs/design-docs/keri/ATTACHMENT_COUNTER_GVRSN_MAINTAINER_GUIDE.md`:
+- `docs/design-docs/cesr/ATTACHMENT_COUNTER_GVRSN.md`:
   attachment counter versioning and replay boundaries
 
 ## License

package/esm/keri/npm/src/_dnt.polyfills.js

@@ -125,6 +125,42 @@ export let import_meta_ponyfill = ((...args) => {
     //@ts-ignore
     return import_meta_ponyfill(...args);
 });
+function findLastIndex(self, callbackfn, that) {
+    const boundFunc = that === undefined ? callbackfn : callbackfn.bind(that);
+    let index = self.length - 1;
+    while (index >= 0) {
+        const result = boundFunc(self[index], index, self);
+        if (result) {
+            return index;
+        }
+        index--;
+    }
+    return -1;
+}
+function findLast(self, callbackfn, that) {
+    const index = self.findLastIndex(callbackfn, that);
+    return index === -1 ? undefined : self[index];
+}
+if (!Array.prototype.findLastIndex) {
+    Array.prototype.findLastIndex = function (callbackfn, that) {
+        return findLastIndex(this, callbackfn, that);
+    };
+}
+if (!Array.prototype.findLast) {
+    Array.prototype.findLast = function (callbackfn, that) {
+        return findLast(this, callbackfn, that);
+    };
+}
+if (!Uint8Array.prototype.findLastIndex) {
+    Uint8Array.prototype.findLastIndex = function (callbackfn, that) {
+        return findLastIndex(this, callbackfn, that);
+    };
+}
+if (!Uint8Array.prototype.findLast) {
+    Uint8Array.prototype.findLast = function (callbackfn, that) {
+        return findLast(this, callbackfn, that);
+    };
+}
 // https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
 if (!Object.hasOwn) {
     Object.defineProperty(Object, "hasOwn", {

package/esm/keri/npm/src/_dnt.shims.js

@@ -1,5 +1,5 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
+import { Deno } from "./npm/deno-shim.js";
+export { Deno } from "./npm/deno-shim.js";
 const dntGlobals = {
     Deno,
 };

package/esm/keri/npm/src/acdc/messaging.js

@@ -62,6 +62,11 @@ function schemaSaidAndSad(schema, fallback, kind) {
     if (typeof schema === "string") {
         return [schema, schema];
     }
+    // Supplied content-bound JSON resources keep their identity across body kinds.
+    // Default/unbound schema construction retains its frozen format-specific IDs.
+    const resource = defaultSchema(cloneMapperValue(schema), Kinds.json);
+    if (schema.$id === resource[0])
+        return resource;
     return defaultSchema(cloneMapperValue(schema), kind);
 }
 function withIssuee(attribute, issuee) {

package/esm/keri/npm/src/acdc/observing.js

@@ -0,0 +1,96 @@
+/** Explicit public registry intake; this TypeScript integration is beyond frozen KERIpy 927. */
+import { Diger, Ilks, ParserError } from "cesr-ts";
+import { DatabaseNotOpenError, DatabaseOperationError } from "../core/errors.js";
+import { RegistryEventer } from "./regengine.js";
+import { validateRip, validateUpdate } from "./regeventing.js";
+/**
+ * Borrow accepted public KEL state and one registry store without habitats, aliases or handles.
+ * Reconstruct the engine's issuer from stored inception after reopen. Intake uses the engine's
+ * full tuple/witness anchor policy, distinct from digest-only observer vetting. Each accepted
+ * event commits independently; a later failure preserves the already accepted prefix.
+ * Parsed evidence stays borrowed. This installs no automatic parser or runtime route.
+ */
+export class RegistryObserver {
+    constructor(db, store) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: store
+        });
+    }
+    /** Stage parsed events before inception, otherwise delegate ordinary validation and acceptance. */
+    processEvent(serder) {
+        const result = serder.ilk === Ilks.rip ? validateRip(serder) : validateUpdate(serder, serder.regid ?? "");
+        if (result.kind === "reject")
+            return result;
+        const event = result.event;
+        // Unknown registry routing cannot rely on a stored RIP to validate its qualified SAID.
+        try {
+            if (new Diger({ qb64: event.regid }).qb64 !== event.regid)
+                return { kind: "reject", reason: "registry" };
+        }
+        catch (error) {
+            if (!(error instanceof ParserError))
+                throw error;
+            return { kind: "reject", reason: "registry" };
+        }
+        if (event.sn > BigInt(Number.MAX_SAFE_INTEGER))
+            return { kind: "reject", reason: "ordinalRange" };
+        let engine = this.engine(event.regid);
+        if (engine && !(engine instanceof RegistryEventer))
+            return engine;
+        if (event.ilk === Ilks.rip) {
+            if (!event.issuer)
+                return { kind: "reject", reason: "issuer" };
+            engine ??= new RegistryEventer(this.db, event.issuer, this.store, event.regid);
+        }
+        if (engine) {
+            return engine.processEvent(serder);
+        }
+        // Issuer/anchor discovery is impossible until RIP arrives; the existing anchor escrow owns this body.
+        const baser = this.store.baser;
+        if (baser.readonly)
+            throw new DatabaseOperationError("Cannot write readonly registry storage.");
+        return baser.env.transactionSync(() => {
+            this.store.putEvent(serder);
+            this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
+            return { kind: "escrow", reason: "inception", event };
+        });
+    }
+    /** Retry one registry after inception/KEL dependencies arrive; never scan every registry implicitly. */
+    processEscrows(regid) {
+        const engine = this.engine(regid);
+        if (!(engine instanceof RegistryEventer))
+            return;
+        engine.processEscrows();
+    }
+    /** Stored inception is durable issuer identity, including while its anchor is still absent. */
+    engine(regid) {
+        if (!this.store.baser.env)
+            throw new DatabaseNotOpenError("Registry observer store is closed.");
+        const rip = this.store.event(regid);
+        if (!rip) {
+            if (this.store.head(regid) || this.store.seqSaider(regid, 0)) {
+                throw new Error("Corrupt observer registry inception.");
+            }
+            return null;
+        }
+        if (rip.said !== regid)
+            throw new Error("Corrupt observer registry inception.");
+        // evts also owns valid BUP bodies; naming one as a registry is remote misuse, not store corruption.
+        if (rip.ilk !== Ilks.rip && rip.verify())
+            return { kind: "reject", reason: "registry" };
+        const result = validateRip(rip);
+        if (result.kind !== "valid" || result.event.regid !== regid || !result.event.issuer) {
+            throw new Error("Corrupt observer registry inception.");
+        }
+        return new RegistryEventer(this.db, result.event.issuer, this.store, regid);
+    }
+}

package/esm/keri/npm/src/acdc/regbasing.js

@@ -0,0 +1,89 @@
+/** Public ACDC registry database layout and joined LMDB lifecycle. */
+import { b, Diger, NumberPrimitive, Saider, SerderACDC } from "cesr-ts";
+import { DatabaseNotOpenError } from "../core/errors.js";
+import { LMDBer } from "../db/core/lmdber.js";
+import { B64OnIoSetSuber, CatCesrSuber, CesrOnSuber, CesrSuber, SerderSuber } from "../db/subing.js";
+/**
+ * Own one environment for public registry TEL bodies, accepted ordinals and heads.
+ * Mirrors frozen KERIpy RegBaser's typed tables; opening neither verifies
+ * evidence nor migrates rows. Every current store has anchor and escrow tables.
+ * Construction stays closed; callers own reopen and joined close.
+ */
+export class RegBaser extends LMDBer {
+    /** Named databases are root entries; testing presence opens no additional handles. */
+    hasTable(name) {
+        if (!this.env)
+            throw new DatabaseNotOpenError("Registry environment is closed.");
+        return this.env.getBinary(b(name)) !== undefined;
+    }
+    constructor(options = {}) {
+        super(options, {
+            tailDirPath: "keri/acdc/reg",
+            cleanTailDirPath: "keri/clean/acdc/reg",
+            altTailDirPath: options.compat ? ".keri/acdc/reg" : ".tufa/acdc/reg",
+            altCleanTailDirPath: options.compat ? ".keri/clean/acdc/reg" : ".tufa/clean/acdc/reg",
+            tempPrefix: "keri_acdc_reg_",
+        });
+        /** Event-SAID -> parsed rip/bup body; body presence alone is not acceptance. */
+        Object.defineProperty(this, "evts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Registry-SAID + ordinal -> accepted event SAID; this is the acceptance marker. */
+        Object.defineProperty(this, "tels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Registry-SAID -> current accepted head SAID; physical heds. is rebuildable from tels. */
+        Object.defineProperty(this, "heads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Event-SAID -> earliest verified KEL source couple, in the current store. */
+        Object.defineProperty(this, "ancs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Insertion-ordered missing-anchor event-SAID tuples by registry and ordinal. */
+        Object.defineProperty(this, "maes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Insertion-ordered out-of-order event-SAID tuples by registry and ordinal. */
+        Object.defineProperty(this, "ooes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    /** Rebind the same environment's typed tables after every joined reopen. */
+    *reopen(options = {}) {
+        const opened = yield* super.reopen(options);
+        if (!opened)
+            return false;
+        try {
+            this.evts = new SerderSuber(this, { subkey: "evts.", ctor: SerderACDC });
+            this.tels = new CesrOnSuber(this, { subkey: "tels.", ctor: Saider });
+            this.heads = new CesrSuber(this, { subkey: "heds.", ctor: Saider });
+            this.ancs = new CatCesrSuber(this, { subkey: "ancs.", ctor: [NumberPrimitive, Diger] });
+            this.maes = new B64OnIoSetSuber(this, { subkey: "maes." });
+            this.ooes = new B64OnIoSetSuber(this, { subkey: "ooes." });
+            return true;
+        }
+        catch (error) {
+            yield* this.close();
+            throw error;
+        }
+    }
+}

package/esm/keri/npm/src/acdc/regengine.js

@@ -0,0 +1,355 @@
+/** Shared TEL validation, accepted-state publication, anchoring and retry for local and foreign registries. */
+import { Diger, Ilks, NumberPrimitive, } from "cesr-ts";
+import { DatabaseNotOpenError, DatabaseOperationError } from "../core/errors.js";
+import { validateRip, validateUpdate, verifyRegistryAnchor, } from "./regeventing.js";
+/**
+ * Borrow the issuer's accepted KEL and registry store; no keys or handles are acquired.
+ * The local facade and foreign observer share this accepted-state engine.
+ * Publication is atomic; binding this instance happens only after successful commit.
+ */
+export class RegistryEventer {
+    constructor(db, issuer, store, regk = null) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "issuer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: issuer
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: store
+        });
+        Object.defineProperty(this, "regk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: regk
+        });
+    }
+    /** Validated accepted head metadata; local construction may inspect it without duplicating acceptance checks. */
+    get acceptedHeadEvent() {
+        return this.regk ? this.acceptedHead(this.regk) : null;
+    }
+    /** Read the accepted head only after validating its body and ordinal marker. */
+    get head() {
+        const event = this.acceptedHeadEvent;
+        return event ? this.store.head(event.regid) : null;
+    }
+    /** Accepted TEL ordinal, retaining -1n for a staged but unaccepted inception. */
+    get sn() {
+        return this.acceptedHeadEvent?.sn ?? -1n;
+    }
+    /** Return an accepted inception; a corrupt marker/body pair throws. */
+    get regser() {
+        return this.regk ? this.acceptedAt(this.regk, 0) : null;
+    }
+    /** Retry newly visible anchors, then advance the contiguous accepted chain. */
+    processEscrows() {
+        this.processMissingAnchors();
+        this.processQueued();
+    }
+    /** Authenticate a complete explicit source couple or discover one for a stored event. */
+    anchorMsg(said, number, diger) {
+        const serder = this.store.event(said);
+        if (!serder)
+            return { kind: "reject", reason: "event" };
+        if (serder.said !== said)
+            throw new Error("Corrupt escrowed registry event.");
+        const result = this.regk === null || serder.ilk === Ilks.rip
+            ? validateRip(serder, this.issuer)
+            : validateUpdate(serder, this.regk);
+        if (result.kind === "reject")
+            return result;
+        const event = result.event;
+        if (this.regk !== null && event.regid !== this.regk)
+            return { kind: "reject", reason: "registry" };
+        if (event.sn > BigInt(Number.MAX_SAFE_INTEGER))
+            return { kind: "reject", reason: "ordinalRange" };
+        const occupied = this.acceptedEvent(event);
+        if (occupied?.kind === "reject")
+            return occupied;
+        const prior = event.sn > 0n ? this.acceptedAt(event.regid, Number(event.sn) - 1) : null;
+        if (prior && prior.said !== event.prior)
+            return { kind: "reject", reason: "prior" };
+        if ((number === undefined) !== (diger === undefined))
+            return { kind: "reject", reason: "anchor" };
+        if (number && diger) {
+            if (!verifyRegistryAnchor(event, { db: this.db, issuer: this.issuer, number, diger })) {
+                return { kind: "reject", reason: "anchor" };
+            }
+            this.store.putAnchor(said, number, diger);
+        }
+        else {
+            this.discoverAnchor(event);
+        }
+        if (!this.store.anchor(said))
+            return { kind: "reject", reason: "anchor" };
+        return this.processEvent(serder);
+    }
+    /** Advance only the next ordinal, committing one verified winner per transaction. */
+    processQueued() {
+        if (this.regk === null)
+            return;
+        while (true) {
+            const head = this.acceptedHead(this.regk);
+            if (!head)
+                return;
+            const sn = head.sn + 1n;
+            if (sn > BigInt(Number.MAX_SAFE_INTEGER))
+                return;
+            const candidates = this.store.baser.ooes.get(this.regk, Number(sn)).map(([said]) => said);
+            candidates.sort((a, b) => this.compareAnchors(a, b));
+            let advanced = false;
+            for (const said of candidates) {
+                const event = this.replayCandidate(said, Number(sn));
+                if (!event || !this.store.anchor(said))
+                    continue;
+                const decision = this.processOne(event.serder);
+                if (decision.kind === "accept") {
+                    advanced = true;
+                    break;
+                }
+            }
+            if (!advanced)
+                return;
+        }
+    }
+    /** Retry anchor escrow by ordinal, arbitrating siblings before entering normal acceptance. */
+    processMissingAnchors() {
+        if (this.regk === null)
+            return;
+        const slots = new Map();
+        // Finish the read cursor before writes.
+        for (const [, sn, [said]] of this.store.baser.maes.getTopItemIter(this.regk)) {
+            if (!Number.isSafeInteger(sn) || sn < 0)
+                throw new RangeError("Unsafe registry escrow ordinal.");
+            const candidates = slots.get(sn) ?? [];
+            candidates.push(said);
+            slots.set(sn, candidates);
+        }
+        for (const [sn, saids] of [...slots].sort(([a], [b]) => a - b)) {
+            const candidates = [];
+            for (const said of saids) {
+                const event = this.replayCandidate(said, sn);
+                if (!event)
+                    continue;
+                this.discoverAnchor(event);
+                candidates.push(event);
+            }
+            candidates.sort((a, b) => this.compareAnchors(a.said, b.said));
+            for (const event of candidates) {
+                const result = this.processEvent(event.serder);
+                if (result.kind === "reject" || result.kind === "duplicate") {
+                    this.store.clearEscrows(this.regk, sn, event.said);
+                }
+            }
+        }
+    }
+    /** Prune unrecoverable candidates; corrupt records and storage failures still propagate. */
+    replayCandidate(said, sn) {
+        const serder = this.store.event(said);
+        if (!serder) {
+            this.store.clearEscrows(this.regk, sn, said);
+            return null;
+        }
+        if (serder.said !== said)
+            throw new Error("Corrupt escrowed registry event.");
+        const result = serder.ilk === Ilks.rip
+            ? validateRip(serder, this.issuer)
+            : validateUpdate(serder, this.regk);
+        if (result.kind === "valid") {
+            const event = result.event;
+            if (event.regid === this.regk && event.sn === BigInt(sn)) {
+                const existing = this.acceptedEvent(event);
+                const prior = sn > 0 ? this.acceptedAt(event.regid, sn - 1) : null;
+                if (!existing && (!prior || prior.said === event.prior))
+                    return event;
+            }
+        }
+        this.store.clearEscrows(this.regk, sn, said);
+        return null;
+    }
+    /** Earliest verified anchor wins; digest then event SAID break ties using code-point order. */
+    compareAnchors(left, right) {
+        const a = this.store.anchor(left), b = this.store.anchor(right);
+        if (a && !b)
+            return -1;
+        if (!a && b)
+            return 1;
+        if (a && b) {
+            if (a[0].num !== b[0].num)
+                return a[0].num < b[0].num ? -1 : 1;
+            if (a[1].qb64 !== b[1].qb64)
+                return a[1].qb64 < b[1].qb64 ? -1 : 1;
+        }
+        return left < right ? -1 : left > right ? 1 : 0;
+    }
+    /** Accept one parsed event, then advance ready successors without recursive replay. */
+    processEvent(serder) {
+        const decision = this.processOne(serder);
+        if (decision.kind === "accept")
+            this.processQueued();
+        return decision;
+    }
+    /** Decide and persist one event; callers own subsequent chain progression. */
+    processOne(serder) {
+        if (this.regk === null || serder.ilk === Ilks.rip)
+            return this.processInception(serder);
+        const result = validateUpdate(serder, this.regk);
+        if (result.kind === "reject")
+            return result;
+        const event = result.event;
+        // Preserve protocol precision until the existing ordinal storage seam can represent it.
+        if (event.sn > BigInt(Number.MAX_SAFE_INTEGER))
+            return { kind: "reject", reason: "ordinalRange" };
+        const prior = this.acceptedAt(event.regid, Number(event.sn) - 1);
+        if (prior && prior.said !== event.prior)
+            return { kind: "reject", reason: "prior" };
+        const previous = this.acceptedEvent(event);
+        if (previous)
+            return previous;
+        const env = this.store.baser.env;
+        if (!env)
+            throw new DatabaseNotOpenError("Registry acceptance requires an open backing store.");
+        if (this.store.baser.readonly)
+            throw new DatabaseOperationError("Cannot write readonly registry storage.");
+        return env.transactionSync(() => {
+            const prior = this.acceptedAt(event.regid, Number(event.sn) - 1);
+            if (prior && prior.said !== event.prior)
+                return { kind: "reject", reason: "prior" };
+            const previous = this.acceptedEvent(event);
+            if (previous)
+                return previous;
+            this.store.putEvent(serder);
+            this.discoverAnchor(event);
+            if (!this.store.anchor(event.said)) {
+                this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
+                return { kind: "escrow", reason: "anchor", event };
+            }
+            this.store.baser.maes.rem(event.regid, Number(event.sn), [event.said]);
+            if (!prior) {
+                this.store.escrowOutOfOrder(event.regid, Number(event.sn), event.said);
+                return { kind: "escrow", reason: "order", event };
+            }
+            const head = this.acceptedHead(event.regid);
+            if (head && head.sn >= event.sn)
+                throw new Error("Registry update would downgrade accepted head.");
+            this.commit(event);
+            return { kind: "accept", event };
+        });
+    }
+    /** Validate, anchor and accept one inception, or retain its body in anchor escrow. */
+    processInception(serder) {
+        const result = validateRip(serder, this.issuer);
+        if (result.kind === "reject")
+            return result;
+        const event = result.event;
+        if (this.regk !== null && this.regk !== event.regid)
+            return { kind: "reject", reason: "registry" };
+        const previous = this.acceptedEvent(event);
+        if (previous) {
+            if (previous.kind === "duplicate")
+                this.regk = event.regid;
+            return previous;
+        }
+        const env = this.store.baser.env;
+        if (!env)
+            throw new DatabaseNotOpenError("Registry acceptance requires an open backing store.");
+        if (this.store.baser.readonly)
+            throw new DatabaseOperationError("Cannot write readonly registry storage.");
+        const decision = env.transactionSync(() => {
+            const previous = this.acceptedEvent(event);
+            if (previous)
+                return previous;
+            if (this.store.head(event.regid))
+                throw new Error("Registry head exists without its accepted inception.");
+            this.store.putEvent(serder);
+            this.discoverAnchor(event);
+            if (!this.store.anchor(event.said)) {
+                this.store.escrowMissingAnchor(event.regid, 0, event.said);
+                return { kind: "escrow", reason: "anchor", event };
+            }
+            this.commit(event);
+            return { kind: "accept", event };
+        });
+        if (decision.kind !== "reject")
+            this.regk = event.regid;
+        return decision;
+    }
+    /** Replay is read-only; first acceptance repeats this check under its write transaction. */
+    acceptedEvent(event) {
+        const existing = this.acceptedAt(event.regid, Number(event.sn));
+        if (!existing)
+            return null;
+        if (existing.said !== event.said)
+            return { kind: "reject", reason: "duplicity" };
+        return { kind: "duplicate", event };
+    }
+    /** Accepted markers require a matching body at the exact ordinal, unlike mere staged bodies. */
+    acceptedAt(regid, sn) {
+        const marker = this.store.seqSaider(regid, sn);
+        if (!marker)
+            return null;
+        const body = this.store.event(marker.qb64);
+        if (!body)
+            throw new Error("Corrupt accepted registry event.");
+        const result = body.ilk === Ilks.rip
+            ? validateRip(body, this.issuer)
+            : validateUpdate(body, regid);
+        if (result?.kind !== "valid" || result.event.said !== marker.qb64
+            || result.event.sn !== BigInt(sn) || result.event.regid !== regid) {
+            throw new Error("Corrupt accepted registry event.");
+        }
+        return result.event.serder;
+    }
+    /** An accepted head must identify this registry's body and its matching accepted ordinal. */
+    acceptedHead(regid) {
+        const marker = this.store.head(regid);
+        if (!marker)
+            return null;
+        const body = this.store.event(marker.qb64);
+        if (!body)
+            throw new Error("Corrupt registry head.");
+        const result = body.ilk === Ilks.rip
+            ? validateRip(body, this.issuer)
+            : validateUpdate(body, regid);
+        if (result?.kind !== "valid" || result.event.said !== marker.qb64 || result.event.regid !== regid
+            || result.event.sn > BigInt(Number.MAX_SAFE_INTEGER))
+            throw new Error("Corrupt registry head.");
+        if (this.acceptedAt(regid, Number(result.event.sn))?.said !== marker.qb64) {
+            throw new Error("Corrupt registry head ordinal.");
+        }
+        return result.event;
+    }
+    /** Publish one verified winner and remove all siblings from its decided slot atomically. */
+    commit(event) {
+        this.store.accept(event.regid, Number(event.sn), event.serder);
+        this.store.baser.maes.rem(event.regid, Number(event.sn));
+        this.store.baser.ooes.rem(event.regid, Number(event.sn));
+    }
+    /** Keep an already verified anchor or discover the earliest fully witnessed seal. */
+    discoverAnchor(event) {
+        if (this.store.anchor(event.said))
+            return;
+        const anchor = this.db.fetchLastSealingEventByEventSeal(this.issuer, {
+            i: event.regid,
+            s: event.serder.sad.n,
+            d: event.said,
+        });
+        if (!anchor)
+            return;
+        const number = NumberPrimitive.fromNum(BigInt(anchor.sn));
+        const diger = new Diger({ qb64: anchor.said });
+        if (verifyRegistryAnchor(event, { db: this.db, issuer: this.issuer, number, diger })) {
+            this.store.putAnchor(event.said, number, diger);
+        }
+    }
+}