keri-ts 0.10.4 → 0.11.0

package/README.md

@@ -21,11 +21,11 @@ ownership lives in the separate `tufa` package.
 ## 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.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,122 @@
+/** Explicit public registry intake; this TypeScript integration is beyond frozen KERIpy 927. */
+import { Diger, Ilks, ParserError, ResourceLimitError } from "cesr-ts";
+import { DatabaseNotOpenError } 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, { maxEvents = 16384 } = {}) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: store
+        });
+        Object.defineProperty(this, "maxEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!Number.isSafeInteger(maxEvents) || maxEvents < 1) {
+            throw new RangeError("Registry maxEvents must be positive and safe.");
+        }
+        this.maxEvents = maxEvents;
+    }
+    /** 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) || error instanceof ResourceLimitError)
+                throw error;
+            return { kind: "reject", reason: "registry" };
+        }
+        this.checkOrdinal(event.sn);
+        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) {
+            this.checkStored(event.regid, 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;
+        baser.initializeStorage();
+        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;
+        this.checkStored(regid, engine);
+        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);
+    }
+    /** Bound chain length before processing; this does not bound queued rows, scans or native allocation. */
+    checkOrdinal(sn) {
+        if (sn >= BigInt(this.maxEvents))
+            throw new ResourceLimitError("Registry evidence exceeds configured event limit.");
+    }
+    /** A tighter observer must not advance previously staged rows beyond its own finite ceiling. */
+    checkStored(regid, engine) {
+        this.checkOrdinal(engine.sn);
+        for (const escrow of [this.store.baser.maes, this.store.baser.ooes]) {
+            for (const [, sn] of escrow?.getTopItemIter(regid) ?? []) {
+                if (!Number.isSafeInteger(sn) || sn < 0)
+                    throw new RangeError("Unsafe observer escrow ordinal.");
+                this.checkOrdinal(BigInt(sn));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+/** Public ACDC registry database layout and joined LMDB lifecycle. */
+import { b, Diger, NumberPrimitive, Saider, SerderACDC } from "cesr-ts";
+import { DatabaseNotOpenError, DatabaseOperationError } 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. Absent anchor/escrow tables stay null until an
+ * explicit storage write initializes them, preserving readonly old layouts.
+ * 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;
+    }
+    /** Explicit writable initialization; never called by opening or reading a store. */
+    initializeStorage() {
+        if (this.readonly)
+            throw new DatabaseOperationError("Cannot initialize readonly registry storage.");
+        this.ancs ??= new CatCesrSuber(this, { subkey: "ancs.", ctor: [NumberPrimitive, Diger] });
+        this.maes ??= new B64OnIoSetSuber(this, { subkey: "maes." });
+        this.ooes ??= new B64OnIoSetSuber(this, { subkey: "ooes." });
+    }
+    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, when this table exists. */
+        Object.defineProperty(this, "ancs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Insertion-ordered missing-anchor event-SAID tuples by registry and ordinal. */
+        Object.defineProperty(this, "maes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Insertion-ordered out-of-order event-SAID tuples by registry and ordinal. */
+        Object.defineProperty(this, "ooes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /** 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 = this.hasTable("ancs.")
+                ? new CatCesrSuber(this, { subkey: "ancs.", ctor: [NumberPrimitive, Diger] })
+                : null;
+            this.maes = this.hasTable("maes.") ? new B64OnIoSetSuber(this, { subkey: "maes." }) : null;
+            this.ooes = this.hasTable("ooes.") ? new B64OnIoSetSuber(this, { subkey: "ooes." }) : null;
+            return true;
+        }
+        catch (error) {
+            yield* this.close();
+            throw error;
+        }
+    }
+}