keri-ts 2.0.1 → 2.1.0

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

@@ -1,28 +1,33 @@
-/** Read-only ACDC chaining over caller-owned node verdicts; authentication and application state policy stay separate. */
+/**
+ * Read-only ACDC chaining over caller-owned node verdicts; authentication and application state policy stay separate.
+ *
+ * KERIpy correspondence: the graph walk and Edge evaluation of upstream PR 1757's
+ * `acdc.evaluating.EdgeEvaluator`. keri-ts keeps a functional seam: protocols
+ * (IPEX) own node authentication and frame admission, then call `walkAcdcGraph`
+ * and `evaluateChain` without this module knowing any disclosure protocol.
+ */
 import { ParserError, Saider } from "cesr-ts";
 import { ValidationError } from "../core/errors.js";
+import { delegationAncestry } from "../core/kel/delegation-ancestry.js";
 import { Schemer } from "../core/scheming.js";
-import { delegationRelation } from "./relating.js";
 import { validateSchema } from "./scheming.js";
-/** Reserved section/group labels include a pin at every level. */
+/** Every Grant-side caller defaults to `open`, matching KERIpy's Grant walk default. */
+export const DEFAULT_GRANT_WALK = "open";
+/** Reserved Edge-group labels include a pin at every level. The top-level Edge Section additionally forbids `w`. */
 export const acdcGroupLabels = new Set(["d", "u", "s", "o", "w"]);
 const leafLabels = new Set([...acdcGroupLabels, "n"]);
-const unary = new Set(["I2I", "NI2I", "DI2I", "E1E", "NOT"]);
+const unary = new Set(["I2I", "NI2I", "DI2I", "E1E", "I1I", "DI1I", "NOT"]);
+/** Latest-wins issuer-to-issuee group. */
 const delegative = new Set(["I2I", "NI2I", "DI2I"]);
-const suppressDefault = new Set([...delegative, "E1E"]);
+/** Latest-wins issuer-to-issuer group, independent of the delegative group; E1E composes with both. */
+const issuerIdentity = new Set(["I1I", "DI1I"]);
+/** Any explicit relation suppresses the implicit I2I/NI2I default. */
+const suppressDefault = new Set([...delegative, "E1E", ...issuerIdentity]);
 /** SAD maps exclude scalar/array edge representations. */
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-/** Empty section containers carry no disclosed edge semantics; malformed nonempty values refuse. */
-export function acdcEdgeBlocks(value) {
-    if (!value || (Array.isArray(value) && !value.length) || (record(value) && !Object.keys(value).length))
-        return [];
-    if (record(value))
-        return [value];
-    return Array.isArray(value) && value.every(record) ? value : null;
-}
-/** Only canonical qualified digests identify expanded leaf targets and schema pins. */
+/** Only canonical qualified digests identify expanded leaf targets, compact commitments and schema pins. */
 function said(value) {
     if (typeof value !== "string")
         return false;
@@ -33,12 +38,116 @@ function said(value) {
         return false;
     }
 }
+/**
+ * Classify a node's `e` field; null is malformed.
+ * Lists, falsy non-map values, non-SAID strings and a top-level `n` or `w` are
+ * malformed. A compact SAID is a valid opaque terminal that names no far nodes.
+ */
+export function acdcEdgeSection(sad) {
+    if (!Object.hasOwn(sad, "e"))
+        return { kind: "none" };
+    const value = sad.e;
+    if (record(value)) {
+        if (!Object.keys(value).length)
+            return { kind: "none" };
+        // The Edge Section is itself an Edge-group, never a leaf, and carries no weight.
+        if (Object.hasOwn(value, "n") || Object.hasOwn(value, "w"))
+            return null;
+        return { kind: "expanded", section: value };
+    }
+    return said(value) ? { kind: "compact", said: value } : null;
+}
 /** Compact Edge strings name blocks, never far ACDCs. Expanded leaves have exact labels. */
 export function acdcEdgeTarget(value) {
     if (!record(value) || !Object.hasOwn(value, "n"))
         return null;
     return Object.keys(value).every((label) => leafLabels.has(label)) && said(value.n) ? value.n : false;
 }
+/**
+ * Walk a disclosed graph of credential views from `origin` in BFS order.
+ *
+ * Every view must verify (including its carried section SAIDs) under its own
+ * SAID key, every Edge Section must be well shaped, every disclosed node must be
+ * reachable and the reachable graph must be acyclic. Closed walks also require
+ * every expanded leaf target to be disclosed; open walks skip undisclosed ones
+ * (see `AcdcWalkPolicy`).
+ * Compact Edge Sections and compact Edge members are opaque terminals.
+ * Protocol frame admission (ilks, nests, duplicates) belongs to the caller.
+ */
+export function walkAcdcGraph(origin, nodes, walk) {
+    for (const [id, { body }] of nodes)
+        if (body.said !== id || !body.verify())
+            return null;
+    if (!nodes.has(origin))
+        return null;
+    const seen = new Set();
+    const order = [];
+    const dependencies = new Map();
+    const queue = [origin];
+    for (let index = 0; index < queue.length; index++) {
+        const id = queue[index];
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        order.push(id);
+        const farNodes = new Set();
+        dependencies.set(id, farNodes);
+        const section = acdcEdgeSection(nodes.get(id).body.sad);
+        if (!section)
+            return null;
+        if (section.kind !== "expanded")
+            continue;
+        const groups = [section.section];
+        for (let g = 0; g < groups.length; g++) {
+            for (const [label, member] of Object.entries(groups[g])) {
+                if (acdcGroupLabels.has(label))
+                    continue;
+                if (typeof member === "string") {
+                    if (!said(member))
+                        return null;
+                    continue;
+                }
+                const target = acdcEdgeTarget(member);
+                if (target === false)
+                    return null;
+                if (target === null) {
+                    if (!record(member))
+                        return null;
+                    groups.push(member);
+                }
+                else if (!nodes.has(target)) {
+                    if (walk === "closed")
+                        return null;
+                }
+                else {
+                    farNodes.add(target);
+                    if (!seen.has(target))
+                        queue.push(target);
+                }
+            }
+        }
+    }
+    if (seen.size !== nodes.size)
+        return null;
+    const parents = new Map();
+    for (const [near, children] of dependencies) {
+        for (const far of children) {
+            if (!parents.has(far))
+                parents.set(far, new Set());
+            parents.get(far).add(near);
+        }
+    }
+    const dependencyOrder = order.filter((id) => dependencies.get(id).size === 0);
+    for (let i = 0; i < dependencyOrder.length; i++) {
+        for (const near of parents.get(dependencyOrder[i]) ?? []) {
+            const children = dependencies.get(near);
+            children.delete(dependencyOrder[i]);
+            if (!children.size)
+                dependencyOrder.push(near);
+        }
+    }
+    return dependencyOrder.length === nodes.size ? order : null;
+}
 /** Missing proof/pin dependencies retain their ordered schema causes for the existing escrow owner. */
 function unknown(reason, retryable = false, schemas = []) {
     return { kind: "unknown", reason, retryable, schemas };
@@ -54,11 +163,64 @@ function reduce(op, members) {
     }
     return { kind: op === "AND" ? "valid" : "invalid" };
 }
+/** Accepted delegation ancestry is the only evidence beyond the two ACDCs; missing KEL evidence can still arrive. */
+function delegatedFrom(db, op, pre, ancestor) {
+    const ancestry = delegationAncestry(db, pre, ancestor);
+    if (ancestry.kind === "valid")
+        return { kind: "valid" };
+    if (ancestry.kind === "refused")
+        return { kind: "invalid" };
+    return unknown(`${op} delegation evidence: ${ancestry.reason}`, true);
+}
+/**
+ * Evaluate the unary relations of one leaf between its near and far ACDCs.
+ *
+ * Unrecognized tokens and the unimplemented NOT are non-retryable unknowns that
+ * are ANDed with, not substituted for, the recognized relations. Absent any
+ * explicit relation, I2I applies when the far node has an issuee, else NI2I.
+ * The delegative and issuer-identity groups are each latest-wins.
+ */
+function leafRelation(db, ops, near, far) {
+    const relations = [];
+    const unrecognized = ops.filter((token) => !unary.has(token));
+    if (unrecognized.length)
+        relations.push(unknown(`Unrecognized unary Edge operator ${unrecognized.join(", ")}.`));
+    if (ops.includes("NOT"))
+        relations.push(unknown("Unimplemented unary Edge operator NOT."));
+    const operators = [...ops];
+    if (!operators.some((token) => suppressDefault.has(token)))
+        operators.push(far.issuee !== null ? "I2I" : "NI2I");
+    const delegate = operators.findLast((token) => delegative.has(token));
+    const identity = operators.findLast((token) => issuerIdentity.has(token));
+    const truth = (value) => ({ kind: value ? "valid" : "invalid" });
+    if (operators.includes("E1E")) {
+        relations.push(truth(Boolean(near.issuee && far.issuee && near.issuee === far.issuee)));
+    }
+    if (delegate === "I2I")
+        relations.push(truth(Boolean(far.issuee && near.issuer === far.issuee)));
+    if (delegate === "DI2I") {
+        if (!near.issuer || !far.issuee)
+            relations.push({ kind: "invalid" });
+        else if (near.issuer !== far.issuee)
+            relations.push(delegatedFrom(db, "DI2I", near.issuer, far.issuee));
+    }
+    // Issuer identity never reads issuees.
+    if (identity) {
+        if (!near.issuer || !far.issuer)
+            relations.push({ kind: "invalid" });
+        else if (near.issuer !== far.issuer) {
+            relations.push(identity === "I1I" ? { kind: "invalid" } : delegatedFrom(db, "DI1I", near.issuer, far.issuer));
+        }
+    }
+    return reduce("AND", relations);
+}
 /**
  * Validate every own schema, then conjoin each caller verdict with its complete edge expression.
  * Every branch is inspected for malformed shape, even when its truth value is unused.
+ * Under an open walk an undisclosed far node is a non-retryable unknown for its leaf.
  * Protocol callers supply issuer authentication; applications supply their state policy.
- * This helper reads schemas but writes no records and publishes no cues.
+ * The graph must come from `walkAcdcGraph` (directly or through a protocol walk).
+ * This helper reads schemas and KEL state but writes no records and publishes no cues.
  */
 export function evaluateChain(graph, verdicts, db) {
     // Own schemas are global obligations, unlike optional edge pins and node verdicts.
@@ -78,12 +240,15 @@ export function evaluateChain(graph, verdicts, db) {
         if (!node || !auth)
             return null;
         memo.set(id, unknown(`Node ${id} is already being evaluated.`));
-        const blocks = acdcEdgeBlocks(node.sad.e);
-        if (!blocks)
+        const section = acdcEdgeSection(node.sad);
+        if (!section)
             return null;
         const members = [auth];
-        for (const block of blocks) {
-            const result = evaluateEdge(block, node, []);
+        if (section.kind === "compact") {
+            members.push(unknown(`Node ${id} carries compact Edge Section ${section.said}, which cannot be evaluated.`));
+        }
+        else if (section.kind === "expanded") {
+            const result = evaluateGroup(section.section, node, []);
             if (!result)
                 return null;
             members.push(result);
@@ -92,50 +257,41 @@ export function evaluateChain(graph, verdicts, db) {
         memo.set(id, result);
         return result;
     };
-    const evaluateEdge = (edge, near, inherited) => {
-        const target = acdcEdgeTarget(edge);
-        if (target === false)
-            return null;
-        const pins = Object.hasOwn(edge, "s") ? [...inherited, edge.s] : inherited;
-        if (target !== null)
-            return evaluateLeaf(edge, target, near, pins);
-        const op = Object.hasOwn(edge, "o") ? edge.o : "AND";
+    const evaluateGroup = (group, near, inherited) => {
+        const pins = Object.hasOwn(group, "s") ? [...inherited, group.s] : inherited;
+        const op = Object.hasOwn(group, "o") ? group.o : "AND";
         if (typeof op !== "string")
             return null;
         const members = [];
-        for (const [label, member] of Object.entries(edge)) {
+        for (const [label, member] of Object.entries(group)) {
             if (acdcGroupLabels.has(label))
                 continue;
             if (typeof member === "string") {
-                members.push(unknown(`Compact Edge ${label} cannot be dereferenced.`));
-            }
-            else {
-                if (!record(member))
+                if (!said(member))
                     return null;
-                const result = evaluateEdge(member, near, pins);
-                if (!result)
-                    return null;
-                members.push(result);
+                members.push(unknown(`Compact Edge ${label} cannot be dereferenced.`));
+                continue;
             }
+            const target = acdcEdgeTarget(member);
+            if (target === false || !record(member))
+                return null;
+            const result = target === null ? evaluateGroup(member, near, pins) : evaluateLeaf(member, target, near, pins);
+            if (!result)
+                return null;
+            members.push(result);
         }
         if (!members.length)
             return null;
         return op === "AND" || op === "OR" ? reduce(op, members) : unknown(`Unsupported Edge-group operator ${op}.`);
     };
-    const evaluateLeaf = (edge, target, near, pins) => {
-        const far = graph.nodes.get(target)?.body;
-        if (!far)
-            return null;
+    const evaluateLeaf = (edge, target, near, inherited) => {
+        const pins = Object.hasOwn(edge, "s") ? [...inherited, edge.s] : inherited;
         const op = edge.o;
         const ops = op == null ? [] : typeof op === "string" ? [op] : Array.isArray(op) ? [...op] : null;
-        if (!ops)
+        if (!ops || !ops.every((token) => typeof token === "string"))
             return null;
         // Pin shape is morphological, so validate it before unsupported tokens or relations.
         const resolved = [];
-        const ownSchema = far.schema;
-        const ownSchemaId = record(ownSchema) ? ownSchema.$id : ownSchema;
-        if (pins.length && typeof ownSchemaId !== "string")
-            return null;
         for (const pin of pins) {
             if (typeof pin === "string") {
                 if (!said(pin))
@@ -159,55 +315,33 @@ export function evaluateChain(graph, verdicts, db) {
             else
                 return null;
         }
-        let own;
-        if (ops.some((token) => typeof token !== "string" || !unary.has(token))) {
-            own = unknown("Unrecognized unary Edge operator.");
+        const far = graph.nodes.get(target)?.body;
+        if (!far) {
+            // A closed walk never yields a graph with an undisclosed target.
+            return graph.walk === "open" ? unknown(`Far node ${target} is not disclosed.`) : null;
         }
-        else {
-            const operators = ops;
-            if (!operators.some((token) => suppressDefault.has(token)))
-                operators.push(far.issuee !== null ? "I2I" : "NI2I");
-            const delegate = operators.findLast((token) => delegative.has(token));
-            if (operators.includes("NOT")) {
-                own = unknown("Unimplemented unary Edge operator.");
-            }
-            else {
-                let matched = (!operators.includes("E1E") || Boolean(near.issuee && far.issuee && near.issuee === far.issuee))
-                    && (delegate !== "I2I" || Boolean(far.issuee && near.issuer === far.issuee));
-                let pending;
-                if (matched && delegate === "DI2I") {
-                    if (!far.issuee || !near.issuer)
-                        matched = false;
-                    else if (near.issuer !== far.issuee) {
-                        const relation = delegationRelation(db, near.issuer, far.issuee);
-                        if (relation.kind === "refused")
-                            matched = false;
-                        else if (relation.kind === "pending")
-                            pending = unknown(relation.reason, true);
-                    }
-                }
-                own = { kind: matched ? "valid" : "invalid" };
-                if (matched) {
-                    for (let pin of resolved) {
-                        if (pin === ownSchemaId && record(ownSchema))
-                            pin = ownSchema;
-                        const result = validateSchema(far, db, pin);
-                        if (result.kind === "valid")
-                            continue;
-                        own = result.kind === "missing"
-                            ? unknown(`Missing edge schema ${result.said}.`, true, [result.said])
-                            : { kind: "invalid" };
-                        break;
-                    }
-                }
-                // Pending delegation cannot replace a pin's decided refusal.
-                if (pending)
-                    own = reduce("AND", [own, pending]);
+        const ownSchema = far.schema;
+        const ownSchemaId = record(ownSchema) ? ownSchema.$id : ownSchema;
+        if (pins.length && typeof ownSchemaId !== "string")
+            return null;
+        const relation = leafRelation(db, ops, near, far);
+        const own = [relation];
+        // A decided relation refusal needs no pin evidence; otherwise every pin is evaluated, not only the first failure.
+        if (relation.kind !== "invalid") {
+            for (let pin of resolved) {
+                if (pin === ownSchemaId && record(ownSchema))
+                    pin = ownSchema;
+                const result = validateSchema(far, db, pin);
+                if (result.kind === "valid")
+                    continue;
+                own.push(result.kind === "missing"
+                    ? unknown(`Missing edge schema ${result.said}.`, true, [result.said])
+                    : { kind: "invalid" });
             }
         }
         // Do not short-circuit a far subtree: its shape cannot be outvoted by this leaf.
         const farVerdict = evaluateNode(target);
-        return farVerdict ? reduce("AND", [own, farVerdict]) : null;
+        return farVerdict ? reduce("AND", [reduce("AND", own), farVerdict]) : null;
     };
     return graph.order.length ? evaluateNode(graph.order[0]) : null;
 }

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

@@ -76,7 +76,7 @@ export class RegistryObserver {
         const baser = this.store.baser;
         if (baser.readonly)
             throw new DatabaseOperationError("Cannot write readonly registry storage.");
-        return baser.env.transactionSync(() => {
+        return baser.transaction(() => {
             this.store.putEvent(serder);
             this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
             if (opening)
@@ -106,7 +106,7 @@ export class RegistryObserver {
     }
     /** Stored inception is durable issuer identity, including while its anchor is still absent. */
     engine(regid) {
-        if (!this.store.baser.env)
+        if (!this.store.baser.opened)
             throw new DatabaseNotOpenError("Registry observer store is closed.");
         const rip = this.store.event(regid);
         if (!rip) {

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

@@ -1,7 +1,6 @@
 /** 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 { Diger, NumberPrimitive, Saider, SerderACDC } from "cesr-ts";
+import { StoreOwner } from "../db/core/store-owner.js";
 import { B64OnIoSetSuber, BytesSuber, CatCesrSuber, CesrOnSuber, CesrSuber, SerderSuber } from "../db/subing.js";
 /**
  * Own one environment for public registry TEL bodies, accepted ordinals and heads.
@@ -9,24 +8,9 @@ import { B64OnIoSetSuber, BytesSuber, CatCesrSuber, CesrOnSuber, CesrSuber, Serd
  * 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.");
-        // Native lmdb-js exposes its C-string terminator in root metadata keys;
-        // the Deno backend also supports the unterminated representation.
-        return this.env.getBinary(b(name)) !== undefined
-            || this.env.getBinary(b(`${name}\0`)) !== 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_",
-        });
+export class RegBaser extends StoreOwner {
+    constructor() {
+        super(...arguments);
         /** Event-SAID -> parsed rip/bup body; body presence alone is not acceptance. */
         Object.defineProperty(this, "evts", {
             enumerable: true,
@@ -79,17 +63,17 @@ export class RegBaser extends LMDBer {
     }
     /** Rebind the same environment's typed tables after every joined reopen. */
     *reopen(options = {}) {
-        const opened = yield* super.reopen(options);
+        const opened = yield* this.store.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.openings = new BytesSuber(this, { subkey: "openings." });
-            this.ancs = new CatCesrSuber(this, { subkey: "ancs.", ctor: [NumberPrimitive, Diger] });
-            this.maes = new B64OnIoSetSuber(this, { subkey: "maes." });
-            this.ooes = new B64OnIoSetSuber(this, { subkey: "ooes." });
+            this.evts = new SerderSuber(this.store, { subkey: "evts.", ctor: SerderACDC });
+            this.tels = new CesrOnSuber(this.store, { subkey: "tels.", ctor: Saider });
+            this.heads = new CesrSuber(this.store, { subkey: "heds.", ctor: Saider });
+            this.openings = new BytesSuber(this.store, { subkey: "openings." });
+            this.ancs = new CatCesrSuber(this.store, { subkey: "ancs.", ctor: [NumberPrimitive, Diger] });
+            this.maes = new B64OnIoSetSuber(this.store, { subkey: "maes." });
+            this.ooes = new B64OnIoSetSuber(this.store, { subkey: "ooes." });
             return true;
         }
         catch (error) {
@@ -98,3 +82,10 @@ export class RegBaser extends LMDBer {
         }
     }
 }
+/** Placement of this store kind. */
+Object.defineProperty(RegBaser, "Family", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: { tail: "acdc/reg" }
+});

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

@@ -256,12 +256,11 @@ export class RegistryEventer {
         const previous = this.acceptedEvent(event);
         if (previous)
             return previous;
-        const env = this.store.baser.env;
-        if (!env)
+        if (!this.store.baser.opened)
             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(() => {
+        return this.store.baser.transaction(() => {
             const prior = this.acceptedAt(event.regid, Number(event.sn) - 1);
             if (prior && prior.said !== event.prior)
                 return { kind: "reject", reason: "prior" };
@@ -303,12 +302,11 @@ export class RegistryEventer {
                 this.regk = event.regid;
             return previous;
         }
-        const env = this.store.baser.env;
-        if (!env)
+        if (!this.store.baser.opened)
             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 decision = this.store.baser.transaction(() => {
             const previous = this.acceptedEvent(event);
             if (previous)
                 return previous;

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

@@ -37,10 +37,13 @@ function retainedOpening(raw) {
 export class RegistryRecord extends RawRecord {
 }
 /** Acquire one backing owner; failures/cancellation join cleanup before ownership transfers. */
-export function* openRegistry({ web = false, reopen = true, ...options } = {}) {
-    if (web)
-        throw new ValidationError("web registry backend is not yet supported by V2 Regery");
-    const baser = new RegBaser(options);
+export function* openRegistry({ reopen = true, opener, ...options } = {}) {
+    if (!opener)
+        throw new ValidationError("A registry store needs a store opener.");
+    return yield* adoptRegistry(new RegBaser(opener.create(RegBaser.Family, options)), reopen);
+}
+/** Take ownership of a constructed registry owner, reopening it unless told otherwise. */
+export function* adoptRegistry(baser, reopen = true) {
     let delivered = false;
     try {
         if (reopen && !(yield* baser.reopen()))
@@ -81,7 +84,7 @@ export class RegistryStore {
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "aliasEnv", {
+        Object.defineProperty(this, "aliasTable", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -90,13 +93,13 @@ export class RegistryStore {
     }
     /** Local alias mapper is optional; refresh it after the owner's reopen. */
     get records() {
-        if (!this.baser.env)
+        if (!this.baser.opened)
             throw new DatabaseNotOpenError("Registry backing store is closed.");
-        if (this.aliasEnv !== this.baser.env) {
+        if (this.aliasTable !== this.baser.evts.sdb) {
             this.aliases = this.baser.hasTable("regs.")
-                ? new Komer(this.baser, { subkey: "regs.", recordClass: RegistryRecord })
+                ? new Komer(this.baser.store, { subkey: "regs.", recordClass: RegistryRecord })
                 : null;
-            this.aliasEnv = this.baser.env;
+            this.aliasTable = this.baser.evts.sdb;
         }
         return this.aliases;
     }
@@ -110,7 +113,7 @@ export class RegistryStore {
         if (!records) {
             if (this.baser.readonly)
                 throw new DatabaseOperationError("Cannot create readonly registry aliases.");
-            records = this.aliases = new Komer(this.baser, { subkey: "regs.", recordClass: RegistryRecord });
+            records = this.aliases = new Komer(this.baser.store, { subkey: "regs.", recordClass: RegistryRecord });
         }
         return records;
     }

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

@@ -13,12 +13,8 @@ export function* createRegery({ hby, baser, ...options }) {
     try {
         if (!baser) {
             baser = yield* openRegistry({
-                name: hby.name,
-                base: hby.base,
-                temp: hby.temp,
-                headDirPath: hby.headDirPath,
-                compat: hby.compat,
-                readonly: hby.readonly,
+                ...hby.storeIdentity(),
+                opener: hby.opener,
                 ...options,
             });
         }
@@ -90,12 +86,11 @@ export class Regery {
         const rip = regcept(hab.pre, options);
         if (this.regs.has(rip.said))
             throw new ValidationError(`Registry already exists: ${rip.said}`);
-        const env = this.baser.env;
-        if (!env)
+        if (!this.baser.opened)
             throw new DatabaseNotOpenError("Registry backing store is closed.");
         const records = this.store.initializeRecords();
         const registry = new Registry(hab, this.store, name);
-        env.transactionSync(() => {
+        this.baser.transaction(() => {
             if (records.get(name))
                 throw new ValidationError(`Registry alias already exists: ${name}`);
             const result = registry.processEvent(rip);