keri-ts 0.7.0 → 0.9.0

package/README.md

@@ -18,6 +18,16 @@ npm install keri-ts
 Only those three entrypoints are supported public surfaces. Runnable CLI/server
 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`:
+  credential stack ownership and failure modes
+- `docs/design-docs/keri/DELEGATION_MULTISIG_ENDPOINT_ROLES_MAINTAINER_GUIDE.md`:
+  delegation, group coordination, and endpoint-role mental model
+- `docs/design-docs/keri/ATTACHMENT_COUNTER_GVRSN_MAINTAINER_GUIDE.md`:
+  attachment counter versioning and replay boundaries
+
 ## License
 
 Licensed under the Apache License, Version 2.0 (`Apache-2.0`). See the top-level

package/esm/cesr/src/primitives/counter.js

@@ -1,5 +1,6 @@
-import { b, b64ToInt, codeB2ToB64, codeB64ToB2, intToB64, nabSextets, sceil } from "../core/bytes.js";
+import { b, b64ToInt, codeB2ToB64, codeB64ToB2, concatBytes, intToB64, nabSextets, sceil } from "../core/bytes.js";
 import { DeserializeError, ShortageError, UnknownCodeError } from "../core/errors.js";
+import { CtrDexV2 } from "../tables/counter-codex.js";
 import { resolveCounterCodeNameTable, resolveCounterSizeTable } from "../tables/counter-version-registry.js";
 import { COUNTER_HARDS } from "../tables/counter.tables.generated.js";
 const COUNTER_BARDS = new Map([...COUNTER_HARDS.entries()].map(([code, hs]) => [
@@ -126,6 +127,38 @@ function encodeCounterFromFields(code, count, version) {
         version,
     };
 }
+function semanticNameForCode(code, version) {
+    const nameTable = resolveCounterCodeNameTable(version);
+    return nameTable[code] ?? null;
+}
+function codeForSemanticName(name, version) {
+    const nameTable = resolveCounterCodeNameTable(version);
+    for (const [code, candidate] of Object.entries(nameTable)) {
+        if (candidate === name) {
+            return code;
+        }
+    }
+    return null;
+}
+function promoteCounterCodeForCount(code, count, version) {
+    const sizeTable = resolveCounterSizeTable(version);
+    const sizage = sizeTable.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unsupported counter code for version: ${code}`);
+    }
+    if (count <= (64 ** sizage.ss) - 1) {
+        return code;
+    }
+    const name = semanticNameForCode(code, version);
+    if (!name || name.startsWith("Big")) {
+        throw new DeserializeError(`Invalid count=${count} for code=${code}`);
+    }
+    const bigCode = codeForSemanticName(`Big${name}`, version);
+    if (!bigCode) {
+        throw new DeserializeError(`Counter code=${code} has no Big${name} form.`);
+    }
+    return bigCode;
+}
 /** Normalize the supported constructor variants into one shared counter payload. */
 function parseCounterInit(init) {
     const version = init.version ?? { major: 2, minor: 0 };
@@ -152,6 +185,34 @@ function parseCounterInit(init) {
  * payload groups and carry versioned code-name semantics.
  */
 export class Counter {
+    static makeGVC(version) {
+        return new Counter({
+            code: CtrDexV2.KERIACDCGenusVersion,
+            countB64: `${intToB64(version.major, 1)}${intToB64(version.minor, 2)}`,
+            version,
+        }).qb64b;
+    }
+    static enclose({ qb64 = undefined, qb2 = undefined, code = "AttachmentGroup", version = { major: 2, minor: 0 }, } = {}) {
+        const actualQb64 = typeof qb64 === "string" ? b(qb64) : qb64;
+        if (actualQb64 !== undefined && actualQb64 !== null) {
+            if (actualQb64.length % 4 !== 0) {
+                throw new DeserializeError(`Bad enclosed qb64 length=${actualQb64.length}`);
+            }
+            const count = actualQb64.length / 4;
+            const counterCode = promoteCounterCodeForCount(codeForSemanticName(code, version) ?? code, count, version);
+            return concatBytes(new Counter({ code: counterCode, count, version }).qb64b, actualQb64);
+        }
+        if (qb2 !== undefined && qb2 !== null) {
+            if (qb2.length % 3 !== 0) {
+                throw new DeserializeError(`Bad enclosed qb2 length=${qb2.length}`);
+            }
+            const count = qb2.length / 3;
+            const counterCode = promoteCounterCodeForCount(codeForSemanticName(code, version) ?? code, count, version);
+            return concatBytes(new Counter({ code: counterCode, count, version }).qb2, qb2);
+        }
+        const counterCode = promoteCounterCodeForCount(codeForSemanticName(code, version) ?? code, 0, version);
+        return new Counter({ code: counterCode, count: 0, version }).qb64b;
+    }
     constructor(init) {
         Object.defineProperty(this, "_code", {
             enumerable: true,
@@ -195,11 +256,7 @@ export class Counter {
             writable: true,
             value: void 0
         });
-        const data = init instanceof Counter
-            ? init.toCounterData()
-            : isCounterData(init)
-                ? init
-                : parseCounterInit(init);
+        const data = init instanceof Counter ? init.toCounterData() : isCounterData(init) ? init : parseCounterInit(init);
         this._code = data.code;
         this._count = data.count;
         this._fullSize = data.fullSize;
@@ -287,7 +344,5 @@ export function parseCounterFromBinary(input, version) {
 }
 /** Parse counter using domain hint (`txt` or `bny`) and versioned codex tables. */
 export function parseCounter(input, version, cold) {
-    return cold === "bny"
-        ? parseCounterFromBinary(input, version)
-        : parseCounterFromText(input, version);
+    return cold === "bny" ? parseCounterFromBinary(input, version) : parseCounterFromText(input, version);
 }

package/esm/cesr/src/primitives/mapper.js

@@ -149,9 +149,7 @@ export function interpretMapperBodySyntax(syntax) {
             label: pendingLabel,
             primitive: entry.primitive,
             isCounter: entry.isCounter,
-            children: entry.children
-                ? interpretMapperBodySyntax(entry.children)
-                : undefined,
+            children: entry.children ? interpretMapperBodySyntax(entry.children) : undefined,
         });
         pendingLabel = null;
     }
@@ -215,19 +213,13 @@ function encodeTag(text) {
     if (!code) {
         throw new SerializeError(`Unsupported mapper tag length=${text.length}`);
     }
-    const pad = code === LabelDex.Tag1 || code === LabelDex.Tag5 || code === LabelDex.Tag9
-        ? "_"
-        : "";
+    const pad = code === LabelDex.Tag1 || code === LabelDex.Tag5 || code === LabelDex.Tag9 ? "_" : "";
     return `${code}${pad}${text}`;
 }
 /** Encode base64-safe text through the compact StrB64/Bexter families. */
 function encodeBext(text) {
     const rem = text.length % 4;
-    const code = rem === 0
-        ? LabelDex.StrB64_L0
-        : rem === 1
-            ? LabelDex.StrB64_L1
-            : LabelDex.StrB64_L2;
+    const code = rem === 0 ? LabelDex.StrB64_L0 : rem === 1 ? LabelDex.StrB64_L1 : LabelDex.StrB64_L2;
     const raw = Bexter.rawify(text);
     return new Bexter({ code, raw }).qb64;
 }
@@ -235,13 +227,16 @@ function encodeBext(text) {
 function encodeBytes(text) {
     const raw = b(text);
     const rem = raw.length % 3;
-    const code = rem === 0
-        ? LabelDex.Bytes_L0
-        : rem === 1
-            ? LabelDex.Bytes_L1
-            : LabelDex.Bytes_L2;
+    const code = rem === 0 ? LabelDex.Bytes_L0 : rem === 1 ? LabelDex.Bytes_L1 : LabelDex.Bytes_L2;
     return new Texter({ code, raw }).qb64;
 }
+function encodeShortLabel(text) {
+    const raw = b(text);
+    return new Matter({
+        code: raw.length === 1 ? LabelDex.Label1 : LabelDex.Label2,
+        raw,
+    }).qb64;
+}
 /**
  * Choose the narrowest native text encoding that can round-trip `text`.
  *
@@ -260,6 +255,26 @@ function encodeText(text) {
     }
     return encodeBytes(text);
 }
+/** Encode scalar string values with KERIpy's tag-or-bytes native map policy. */
+function encodeValueText(text) {
+    if (text.length === 0) {
+        return LabelDex.Empty;
+    }
+    if (/^[A-Za-z0-9_-]+$/.test(text)) {
+        if (text.length <= 11) {
+            return encodeTag(text);
+        }
+        const wadSize = (4 - (text.length % 4)) % 4;
+        if (text[0] !== "A" || (wadSize !== 0 && wadSize !== 1)) {
+            return encodeBext(text);
+        }
+        return encodeBytes(text);
+    }
+    if (text.length === 1 || text.length === 2) {
+        return encodeShortLabel(text);
+    }
+    return encodeBytes(text);
+}
 function serializeValue(value, strict) {
     // This is the recursive mapper exhale ladder. Ordering matters because a
     // string might be either already-qualified CESR text or ordinary text that
@@ -280,42 +295,36 @@ function serializeValue(value, strict) {
         return new Decimer({ dns: value.toString() }).qb64;
     }
     if (typeof value === "string") {
-        try {
-            const primitive = parseMatter(b(value), "txt");
-            if (primitive.qb64.length === value.length) {
-                const escape = ESCAPE_CODES.has(primitive.code)
-                    ? new Matter({ code: MtrDex.Escape, raw: new Uint8Array() }).qb64
-                    : "";
-                return `${escape}${primitive.qb64}`;
+        if (/^[A-Za-z0-9_-]+$/.test(value)) {
+            try {
+                const primitive = parseMatter(b(value), "txt");
+                if (primitive.qb64.length === value.length) {
+                    const escape = ESCAPE_CODES.has(primitive.code)
+                        ? new Matter({ code: MtrDex.Escape, raw: new Uint8Array() }).qb64
+                        : "";
+                    return `${escape}${primitive.qb64}`;
+                }
+            }
+            catch {
+                // fall through to text encoding
             }
         }
-        catch {
-            // fall through to text encoding
-        }
-        return encodeText(value);
+        return encodeValueText(value);
     }
     if (value instanceof Uint8Array) {
         return new Texter({
-            code: value.length % 3 === 0
-                ? LabelDex.Bytes_L0
-                : value.length % 3 === 1
-                    ? LabelDex.Bytes_L1
-                    : LabelDex.Bytes_L2,
+            code: value.length % 3 === 0 ? LabelDex.Bytes_L0 : value.length % 3 === 1 ? LabelDex.Bytes_L1 : LabelDex.Bytes_L2,
             raw: value,
         }).qb64;
     }
     if (Array.isArray(value)) {
         const payload = value.map((entry) => serializeValue(entry, strict)).join("");
-        const code = payload.length / 4 < 64 ** 2
-            ? CtrDexV2.GenericListGroup
-            : CtrDexV2.BigGenericListGroup;
+        const code = payload.length / 4 < 64 ** 2 ? CtrDexV2.GenericListGroup : CtrDexV2.BigGenericListGroup;
         return `${new Counter({ code, count: payload.length / 4 }).qb64}${payload}`;
     }
     if (value && typeof value === "object") {
         const payload = Object.entries(value).map(([label, entry]) => `${strict ? encodeText(label) : encodeText(label)}${serializeValue(entry, strict)}`).join("");
-        const code = payload.length / 4 < 64 ** 2
-            ? CtrDexV2.GenericMapGroup
-            : CtrDexV2.BigGenericMapGroup;
+        const code = payload.length / 4 < 64 ** 2 ? CtrDexV2.GenericMapGroup : CtrDexV2.BigGenericMapGroup;
         return `${new Counter({ code, count: payload.length / 4 }).qb64}${payload}`;
     }
     throw new SerializeError(`Nonserializable mapper value=${String(value)}`);
@@ -687,9 +696,7 @@ export class Mapper {
                 : serializeValue(value, strict);
             return `${encodeText(label)}${rendered}`;
         }).join("");
-        const code = payload.length / 4 < 64 ** 2
-            ? CtrDexV2.GenericMapGroup
-            : CtrDexV2.BigGenericMapGroup;
+        const code = payload.length / 4 < 64 ** 2 ? CtrDexV2.GenericMapGroup : CtrDexV2.BigGenericMapGroup;
         return b(`${new Counter({ code, count: payload.length / 4 }).qb64}${payload}`);
     }
     static serializeNonNativeMap(mad, kind) {

package/esm/cesr/src/serder/native.js

@@ -1,6 +1,7 @@
 import { b, codeB2ToB64, intToB64, t } from "../core/bytes.js";
-import { DeserializeError, SerializeError } from "../core/errors.js";
+import { DeserializeError, SerializeError, ShortageError, UnknownCodeError } from "../core/errors.js";
 import { Ilks } from "../core/vocabulary.js";
+import { sniff } from "../parser/cold-start.js";
 import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
 import { Aggor, isAggorListCode, isAggorMapCode, parseAggor } from "../primitives/aggor.js";
 import { Bexter } from "../primitives/bexter.js";
@@ -116,36 +117,78 @@ export function canonicalizeCesrNativeRaw(raw, version) {
     }
     return b(codeB2ToB64(raw, nativeQb64Size(raw, version)));
 }
+/**
+ * Reap one CESR-native body group and derive the smellage metadata that
+ * non-native bodies expose through `smell()`.
+ */
+export function reapCesrNativeBody(input, version = Vrsn_2_0) {
+    const cold = sniff(input);
+    if (cold !== "txt" && cold !== "bny") {
+        return null;
+    }
+    let counter;
+    try {
+        counter = parseCounter(input, version, cold);
+    }
+    catch (error) {
+        if (error instanceof ShortageError) {
+            throw error;
+        }
+        if (error instanceof UnknownCodeError || error instanceof DeserializeError) {
+            return null;
+        }
+        throw error;
+    }
+    if (counter.code !== CtrDexV2.FixBodyGroup
+        && counter.code !== CtrDexV2.BigFixBodyGroup
+        && counter.code !== CtrDexV2.MapBodyGroup
+        && counter.code !== CtrDexV2.BigMapBodyGroup) {
+        return null;
+    }
+    const consumed = cold === "txt" ? counter.fullSize + counter.count * 4 : counter.fullSizeB2 + counter.count * 3;
+    if (input.length < consumed) {
+        throw new ShortageError(consumed, input.length);
+    }
+    const raw = canonicalizeCesrNativeRaw(input.slice(0, consumed), version);
+    const textCounter = parseCounter(raw, version, "txt");
+    let offset = textCounter.fullSize;
+    if (textCounter.code === CtrDexV2.MapBodyGroup
+        || textCounter.code === CtrDexV2.BigMapBodyGroup) {
+        offset += parseLabeler(raw.slice(offset), "txt").fullSize;
+    }
+    const verser = parseVerser(raw.slice(offset), "txt");
+    return {
+        raw,
+        smellage: {
+            proto: verser.proto,
+            pvrsn: verser.pvrsn,
+            gvrsn: verser.gvrsn,
+            kind: Kinds.cesr,
+            size: raw.length,
+        },
+        consumed,
+    };
+}
 /** Emit the narrowest fixed-width tag family that can carry `text`. */
 function encodeTag(text) {
     const code = TAG_CODES_BY_LENGTH.get(text.length);
     if (!code) {
         throw new SerializeError(`Unsupported tag length=${text.length}`);
     }
-    const pad = code === LabelDex.Tag1 || code === LabelDex.Tag5 || code === LabelDex.Tag9
-        ? "_"
-        : "";
+    const pad = code === LabelDex.Tag1 || code === LabelDex.Tag5 || code === LabelDex.Tag9 ? "_" : "";
     return `${code}${pad}${text}`;
 }
 /** Emit base64-safe text through the StrB64/Bexter family. */
 function encodeBext(text) {
     const rem = text.length % 4;
-    const code = rem === 0
-        ? LabelDex.StrB64_L0
-        : rem === 1
-            ? LabelDex.StrB64_L1
-            : LabelDex.StrB64_L2;
+    const code = rem === 0 ? LabelDex.StrB64_L0 : rem === 1 ? LabelDex.StrB64_L1 : LabelDex.StrB64_L2;
     return new Bexter({ code, raw: Bexter.rawify(text) }).qb64;
 }
 /** Emit arbitrary UTF-8 text through the bytes label family. */
 function encodeBytes(text) {
     const raw = b(text);
     const rem = raw.length % 3;
-    const code = rem === 0
-        ? LabelDex.Bytes_L0
-        : rem === 1
-            ? LabelDex.Bytes_L1
-            : LabelDex.Bytes_L2;
+    const code = rem === 0 ? LabelDex.Bytes_L0 : rem === 1 ? LabelDex.Bytes_L1 : LabelDex.Bytes_L2;
     return new Texter({ code, raw }).qb64;
 }
 /**
@@ -237,9 +280,7 @@ function encodePath(path) {
 function encodeList(entries, gvrsn) {
     const frame = entries.join("");
     const count = frame.length / 4;
-    const code = count < 64 ** 2
-        ? CtrDexV2.GenericListGroup
-        : CtrDexV2.BigGenericListGroup;
+    const code = count < 64 ** 2 ? CtrDexV2.GenericListGroup : CtrDexV2.BigGenericListGroup;
     return `${new Counter({ code, count, version: gvrsn ?? Vrsn_2_0 }).qb64}${frame}`;
 }
 /**
@@ -527,9 +568,7 @@ function parseNestedSealOrDataListField(raw, offset, gvrsn) {
     const listCounter = parseCounter(raw.slice(offset), gvrsn, "txt");
     const total = listCounter.fullSize + listCounter.count * 4;
     return {
-        value: listCounter.count === 0
-            ? []
-            : decodeList(raw.slice(offset, offset + total), gvrsn),
+        value: listCounter.count === 0 ? [] : decodeList(raw.slice(offset, offset + total), gvrsn),
         nextOffset: offset + total,
     };
 }
@@ -1265,9 +1304,7 @@ export function dumpCesrNativeSad(sad) {
     const pvrsn = sad.v[4] === "1"
         ? { major: 1, minor: Number.parseInt(sad.v[5], 16) }
         : { major: 2, minor: 0 };
-    const gvrsn = sad.v.includes("CESR") && sad.v.length >= 19
-        ? { major: 2, minor: 0 }
-        : null;
+    const gvrsn = sad.v.includes("CESR") && sad.v.length >= 19 ? { major: 2, minor: 0 } : null;
     const smellage = {
         proto: sad.v.slice(0, 4),
         pvrsn,
@@ -1300,9 +1337,7 @@ export function dumpCesrNativeSad(sad) {
                 frame += encodeLabel(label);
                 frame += encodeNativeFieldValue(sad[label], label, spec, version);
             }
-            const code = frame.length / 4 < 64 ** 2
-                ? CtrDexV2.MapBodyGroup
-                : CtrDexV2.BigMapBodyGroup;
+            const code = frame.length / 4 < 64 ** 2 ? CtrDexV2.MapBodyGroup : CtrDexV2.BigMapBodyGroup;
             return `${new Counter({ code, count: frame.length / 4, version }).qb64}${frame}`;
         })()
         : (() => {
@@ -1317,9 +1352,7 @@ export function dumpCesrNativeSad(sad) {
                 }
                 frame += encodeNativeFieldValue(sad[label], label, spec, version);
             }
-            const code = frame.length / 4 < 64 ** 2
-                ? CtrDexV2.FixBodyGroup
-                : CtrDexV2.BigFixBodyGroup;
+            const code = frame.length / 4 < 64 ** 2 ? CtrDexV2.FixBodyGroup : CtrDexV2.BigFixBodyGroup;
             return `${new Counter({ code, count: frame.length / 4, version }).qb64}${frame}`;
         })();
     return b(body);

package/esm/cesr/src/serder/serder.js

@@ -20,7 +20,7 @@ import { Verfer } from "../primitives/verfer.js";
 import { resolveMUDex } from "../tables/counter-version-registry.js";
 import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
 import { Kinds, Protocols, Vrsn_1_0, Vrsn_2_0 } from "../tables/versions.js";
-import { dumpCesrNativeSad, parseCesrNativeKed } from "./native.js";
+import { dumpCesrNativeSad, parseCesrNativeKed, reapCesrNativeBody } from "./native.js";
 import { smell, versify } from "./smell.js";
 const ACDC_COMPACT_TOP_LEVEL_ILKS = new Set([
     Ilks.acm,
@@ -101,21 +101,19 @@ function makeNumberPrimitive(value) {
     if (value === null || value === undefined) {
         return null;
     }
-    const bigint = typeof value === "string"
-        ? BigInt(`0x${value || "0"}`)
-        : typeof value === "number"
-            ? (() => {
-                if (!Number.isInteger(value) || value < 0) {
-                    throw new SerializeError(`Invalid numeric CESR number=${value}`);
-                }
-                return BigInt(value);
-            })()
-            : (() => {
-                if (value < 0n) {
-                    throw new SerializeError(`Negative CESR number=${value}`);
-                }
-                return value;
-            })();
+    const bigint = typeof value === "string" ? BigInt(`0x${value || "0"}`) : typeof value === "number"
+        ? (() => {
+            if (!Number.isInteger(value) || value < 0) {
+                throw new SerializeError(`Invalid numeric CESR number=${value}`);
+            }
+            return BigInt(value);
+        })()
+        : (() => {
+            if (value < 0n) {
+                throw new SerializeError(`Negative CESR number=${value}`);
+            }
+            return value;
+        })();
     const raw = bigintToBytes(bigint);
     const entry = NUMBER_CAPACITIES.find(({ rawSize }) => raw.length <= rawSize);
     if (!entry) {
@@ -911,22 +909,24 @@ function computeAcdcFieldVariants(label, value, kind, topLevelCompactable, compa
     }
     return { display: cloneDefault(value), compact: cloneDefault(value) };
 }
-function computeAcdcSad(sad, { kind, saids, compactify, }) {
+function computeAcdcSad(sad, { kind, pvrsn, saids, compactify, }) {
     // This is the heart of ACDC compactification parity. KERIpy's rule is not
     // "hash the visible sad"; it is "hash the most compact sad, while optionally
     // preserving an expanded caller-visible sad".
     const displaySad = shallowCloneSad(sad);
     const compactSad = shallowCloneSad(sad);
     const ilk = typeof sad.t === "string" ? sad.t : null;
-    const topLevelCompactable = isAcdcCompactiveIlk(ilk);
+    const topLevelCompactable = pvrsn.major >= 2 && isAcdcCompactiveIlk(ilk);
     const partialSection = isAcdcPartialSectionIlk(ilk);
-    for (const label of ["s", "a", "A", "e", "r"]) {
-        if (!(label in sad)) {
-            continue;
+    if (pvrsn.major >= 2) {
+        for (const label of ["s", "a", "A", "e", "r"]) {
+            if (!(label in sad)) {
+                continue;
+            }
+            const variants = computeAcdcFieldVariants(label, sad[label], kind, topLevelCompactable, compactify, partialSection);
+            displaySad[label] = variants.display;
+            compactSad[label] = variants.compact;
         }
-        const variants = computeAcdcFieldVariants(label, sad[label], kind, topLevelCompactable, compactify, partialSection);
-        displaySad[label] = variants.display;
-        compactSad[label] = variants.compact;
     }
     const code = saids.d ?? DigDex.Blake3_256;
     const sizage = MATTER_SIZES.get(code);
@@ -1166,10 +1166,9 @@ export class Serder {
             return;
         }
         if (isRawInit(init)) {
-            const smellage = init.smellage ?? smell(init.raw).smellage;
-            const raw = init.raw.length === smellage.size
-                ? init.raw
-                : init.raw.slice(0, smellage.size);
+            const native = init.smellage ? null : reapCesrNativeBody(init.raw);
+            const smellage = init.smellage ?? native?.smellage ?? smell(init.raw).smellage;
+            const raw = native?.raw ?? (init.raw.length === smellage.size ? init.raw : init.raw.slice(0, smellage.size));
             const parsed = parseRawToKed(raw, smellage);
             this.raw = raw;
             this.kind = smellage.kind;
@@ -1203,6 +1202,7 @@ export class Serder {
             ? resolved.proto === Protocols.acdc
                 ? computeAcdcSad(normalized, {
                     kind: resolved.kind,
+                    pvrsn: resolved.pvrsn,
                     saids: resolved.saids,
                     compactify: init.compactify ?? false,
                 })
@@ -1526,25 +1526,19 @@ export class SerderKERI extends Serder {
         return this.sealRecords.filter(isSealEventRecord);
     }
     get traits() {
-        return Array.isArray(this.ked?.c)
-            ? this.ked.c.filter((value) => typeof value === "string")
-            : [];
+        return Array.isArray(this.ked?.c) ? this.ked.c.filter((value) => typeof value === "string") : [];
     }
     get tholder() {
         return makeThreshold(this.ked?.kt ?? null);
     }
     get keys() {
-        return Array.isArray(this.ked?.k)
-            ? this.ked.k.filter((value) => typeof value === "string")
-            : [];
+        return Array.isArray(this.ked?.k) ? this.ked.k.filter((value) => typeof value === "string") : [];
     }
     get verfers() {
         return this.keys.map((key) => new Verfer({ qb64: key }));
     }
     get ndigs() {
-        return Array.isArray(this.ked?.n)
-            ? this.ked.n.filter((value) => typeof value === "string")
-            : [];
+        return Array.isArray(this.ked?.n) ? this.ked.n.filter((value) => typeof value === "string") : [];
     }
     get ntholder() {
         return makeThreshold(this.ked?.nt ?? null);
@@ -1563,9 +1557,7 @@ export class SerderKERI extends Serder {
         return this.bner ? Number(this.bner.num) : null;
     }
     get backs() {
-        return Array.isArray(this.ked?.b)
-            ? this.ked.b.filter((value) => typeof value === "string")
-            : [];
+        return Array.isArray(this.ked?.b) ? this.ked.b.filter((value) => typeof value === "string") : [];
     }
     get berfers() {
         return this.backs.map((back) => new Verfer({ qb64: back }));
@@ -1577,14 +1569,10 @@ export class SerderKERI extends Serder {
         return this.prior ? b(this.prior) : null;
     }
     get cuts() {
-        return Array.isArray(this.ked?.br)
-            ? this.ked.br.filter((value) => typeof value === "string")
-            : [];
+        return Array.isArray(this.ked?.br) ? this.ked.br.filter((value) => typeof value === "string") : [];
     }
     get adds() {
-        return Array.isArray(this.ked?.ba)
-            ? this.ked.ba.filter((value) => typeof value === "string")
-            : [];
+        return Array.isArray(this.ked?.ba) ? this.ked.ba.filter((value) => typeof value === "string") : [];
     }
     get delpre() {
         return this.ked && typeof this.ked.di === "string" ? this.ked.di : null;
@@ -1630,6 +1618,7 @@ export class SerderACDC extends Serder {
         const { ked, saids } = validateSadAgainstFieldDom(ctor, this);
         const actual = computeAcdcSad(shallowCloneSad(ked), {
             kind: this.kind,
+            pvrsn: this.pvrsn,
             saids,
             compactify: false,
         });

package/esm/cesr/src/serder/serdery.js

@@ -1,11 +1,5 @@
 import { ShortageError } from "../core/errors.js";
-import { sniff } from "../parser/cold-start.js";
-import { parseCounter } from "../primitives/counter.js";
-import { parseLabeler } from "../primitives/labeler.js";
-import { parseVerser } from "../primitives/verser.js";
-import { CtrDexV2 } from "../tables/counter-codex.js";
-import { Vrsn_2_0 } from "../tables/versions.js";
-import { canonicalizeCesrNativeRaw } from "./native.js";
+import { reapCesrNativeBody } from "./native.js";
 import { parseSerder } from "./serder.js";
 import { smell } from "./smell.js";
 /**
@@ -45,42 +39,12 @@ export class Serdery {
      * for that final acceptance decision.
      */
     reap(input) {
-        const cold = sniff(input);
-        if (cold === "txt" || cold === "bny") {
-            const counter = parseCounter(input, Vrsn_2_0, cold);
-            if (counter.code === CtrDexV2.FixBodyGroup
-                || counter.code === CtrDexV2.BigFixBodyGroup
-                || counter.code === CtrDexV2.MapBodyGroup
-                || counter.code === CtrDexV2.BigMapBodyGroup) {
-                const consumed = cold === "txt"
-                    ? counter.fullSize + counter.count * 4
-                    : counter.fullSizeB2 + counter.count * 3;
-                if (input.length < consumed) {
-                    throw new ShortageError(consumed, input.length);
-                }
-                const raw = input.slice(0, consumed);
-                // Native qb2 bodies are canonicalized to qb64 text before hydration so
-                // the serder layer sees one stable native representation.
-                const textRaw = canonicalizeCesrNativeRaw(raw, Vrsn_2_0);
-                const textCounter = parseCounter(textRaw, Vrsn_2_0, "txt");
-                let offset = textCounter.fullSize;
-                if (textCounter.code === CtrDexV2.MapBodyGroup
-                    || textCounter.code === CtrDexV2.BigMapBodyGroup) {
-                    offset += parseLabeler(textRaw.slice(offset), "txt").fullSize;
-                }
-                const verser = parseVerser(textRaw.slice(offset), "txt");
-                const smellage = {
-                    proto: verser.proto,
-                    pvrsn: verser.pvrsn,
-                    gvrsn: verser.gvrsn,
-                    kind: "CESR",
-                    size: textRaw.length,
-                };
-                return {
-                    serder: parseSerder(textRaw, smellage),
-                    consumed,
-                };
-            }
+        const native = reapCesrNativeBody(input);
+        if (native) {
+            return {
+                serder: parseSerder(native.raw, native.smellage),
+                consumed: native.consumed,
+            };
         }
         const { smellage } = smell(input);
         if (input.length < smellage.size) {

package/esm/cesr/src/version.js

@@ -6,9 +6,9 @@
  * `src/version.ts` files by hand; edit this template instead.
  */
 /** Package semantic version copied from the owning package manifest. */
-export const PACKAGE_VERSION = "0.7.0";
+export const PACKAGE_VERSION = "0.9.0";
 /** Optional build metadata stamp injected by release/CI workflows. */
-export const BUILD_METADATA = "build.12.6aeea4790568f27066636c48ec39d2f098e3c26d";
+export const BUILD_METADATA = "build.14.a6b6e2ba5a202ef9b6cd9eaeb62fabdb904cc8f3";
 /** User-facing version string with build metadata appended when present. */
 export const DISPLAY_VERSION = BUILD_METADATA
     ? `${PACKAGE_VERSION}+${BUILD_METADATA}`

package/esm/keri/src/acdc/index.js

@@ -0,0 +1 @@
+export * from "./messaging.js";