cesr-ts 0.4.0 → 0.6.0

package/esm/src/serder/serder.js

@@ -1,13 +1,160 @@
-import { decode as decodeMsgpack } from "@msgpack/msgpack";
-import { t } from "../core/bytes.js";
-import { decodeKeriCbor } from "../core/cbor.js";
-import { DeserializeError } from "../core/errors.js";
+import { decode as decodeMsgpack, encode as encodeMsgpack } from "@msgpack/msgpack";
+import { b, t } from "../core/bytes.js";
+import { decodeKeriCbor, encodeKeriCbor } from "../core/cbor.js";
+import { DeserializeError, SerializeError } from "../core/errors.js";
+import { Ilks } from "../core/vocabulary.js";
 import { Aggor, isAggorCode } from "../primitives/aggor.js";
 import { Blinder, isBlinderCode } from "../primitives/blinder.js";
+import { DigDex, DIGEST_CODES, NON_DIGEST_PREFIX_CODES, NON_TRANSFERABLE_CODES, PREFIX_CODES, } from "../primitives/codex.js";
+import { Compactor } from "../primitives/compactor.js";
+import { Diger } from "../primitives/diger.js";
+import { parseMatter } from "../primitives/matter.js";
 import { isMediarCode, Mediar } from "../primitives/mediar.js";
+import { NumberPrimitive } from "../primitives/number.js";
 import { isCounterGroupLike, isPrimitiveTuple, } from "../primitives/primitive.js";
+import { Saider } from "../primitives/saider.js";
 import { isSealerCode, Sealer } from "../primitives/sealer.js";
-import { Protocols } from "../tables/versions.js";
+import { SealDescriptors } from "../primitives/structing.js";
+import { Tholder } from "../primitives/tholder.js";
+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 { smell, versify } from "./smell.js";
+const ACDC_COMPACT_TOP_LEVEL_ILKS = new Set([
+    Ilks.acm,
+    Ilks.ace,
+    Ilks.act,
+    Ilks.acg,
+]);
+const ACDC_PARTIAL_SECTION_ILKS = new Set([
+    Ilks.sch,
+    Ilks.att,
+    Ilks.agg,
+    Ilks.edg,
+    Ilks.rul,
+]);
+const KERI_ESTABLISHMENT_ILKS = new Set([
+    Ilks.icp,
+    Ilks.rot,
+    Ilks.dip,
+    Ilks.drt,
+]);
+const ACDC_SAIDIVE_TOP_LEVEL_ILKS = new Set([
+    Ilks.acm,
+    Ilks.ace,
+    Ilks.act,
+    Ilks.acg,
+    Ilks.rip,
+]);
+/**
+ * Shared CESR genus mapping for protocol messages.
+ *
+ * KERIpy keeps this indirection as `GenDex` + `ProGen`: today both KERI and
+ * ACDC messages ride the shared KERI message-universal genus `-_AAA`, while
+ * the reserved ACDC genus remains unused for serder framing.
+ */
+const MESSAGE_GENUS_BY_PROTOCOL = Object
+    .freeze({
+    [Protocols.keri]: "-_AAA",
+    [Protocols.acdc]: "-_AAA",
+});
+function versionKey(version) {
+    return `${version.major}.${version.minor}`;
+}
+function cloneDefault(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneDefault(entry));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cloneDefault(v)]));
+    }
+    return value;
+}
+const NUMBER_CAPACITIES = [
+    { code: "M", rawSize: 2 },
+    { code: "0H", rawSize: 4 },
+    { code: "R", rawSize: 5 },
+    { code: "N", rawSize: 8 },
+    { code: "S", rawSize: 11 },
+    { code: "T", rawSize: 14 },
+    { code: "0A", rawSize: 16 },
+    { code: "U", rawSize: 17 },
+];
+function bigintToBytes(value) {
+    if (value < 0n) {
+        throw new SerializeError(`Negative CESR number=${value}`);
+    }
+    if (value === 0n) {
+        return new Uint8Array([0]);
+    }
+    const bytes = [];
+    let working = value;
+    while (working > 0n) {
+        bytes.unshift(Number(working & 0xffn));
+        working >>= 8n;
+    }
+    return new Uint8Array(bytes);
+}
+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 raw = bigintToBytes(bigint);
+    const entry = NUMBER_CAPACITIES.find(({ rawSize }) => raw.length <= rawSize);
+    if (!entry) {
+        throw new SerializeError(`Unsupported number width=${raw.length}`);
+    }
+    const padded = new Uint8Array(entry.rawSize);
+    padded.set(raw, entry.rawSize - raw.length);
+    return new NumberPrimitive({ code: entry.code, raw: padded });
+}
+function isPlainSadObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const SEAL_PROJECTION_DESCRIPTORS = SealDescriptors;
+function parseSealRecord(value, index) {
+    if (!isPlainSadObject(value)) {
+        throw new DeserializeError(`Invalid seal at a[${index}]: expected plain object.`);
+    }
+    for (const descriptor of SEAL_PROJECTION_DESCRIPTORS) {
+        if (descriptor.isSad(value)) {
+            return descriptor.fromSad(value);
+        }
+    }
+    throw new DeserializeError(`Invalid seal at a[${index}]: no known KERI seal shape matched.`);
+}
+function isSealEventRecord(value) {
+    return "i" in value && "s" in value && "d" in value;
+}
+/** Convert semantic `sith` content back into a `Tholder` wrapper when possible. */
+function makeThreshold(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    try {
+        return new Tholder({ sith: value });
+    }
+    catch {
+        return null;
+    }
+}
 function normalizeDecodedMap(value, kind) {
     if (value && typeof value === "object" && !Array.isArray(value)) {
         if (value instanceof Map) {
@@ -24,6 +171,898 @@ function normalizeDecodedMap(value, kind) {
     }
     throw new DeserializeError(`${kind} root must be a map/object`);
 }
+/**
+ * Serialize one KERI/ACDC body using the requested wire kind.
+ *
+ * Mirrors KERIpy's `dumps()` helper: this is a format utility, not a `Serder`
+ * instance method, so upper layers can size or saidify SADs before they have a
+ * body object.
+ */
+export function dumps(ked, kind) {
+    if (kind === "JSON") {
+        return b(JSON.stringify(ked));
+    }
+    if (kind === "MGPK") {
+        return encodeMsgpack(ked);
+    }
+    if (kind === "CBOR") {
+        return encodeKeriCbor(ked);
+    }
+    if (kind === "CESR") {
+        if (!ked || typeof ked !== "object" || Array.isArray(ked)) {
+            throw new SerializeError("CESR native body must be a map/object");
+        }
+        // Native emit is factored out so `Serder`, `Serdery`, and parser-native
+        // hydration all share one CESR-native serialization contract.
+        return dumpCesrNativeSad(ked);
+    }
+    throw new SerializeError(`Unsupported serialization kind: ${kind}`);
+}
+/**
+ * Measure one versioned SAD and rewrite its embedded version string size.
+ *
+ * Mirrors KERIpy's `sizeify()` utility closely enough for local parity work:
+ * callers provide a mutable SAD carrying a `v` field, optionally override the
+ * serialization kind, and receive the updated raw bytes plus parsed version
+ * metadata.
+ */
+export function sizeify(ked, kind) {
+    if (typeof ked.v !== "string" || ked.v.length === 0) {
+        throw new SerializeError("Missing or empty version string in SAD");
+    }
+    const { smellage } = (() => {
+        try {
+            return {
+                smellage: parseVersionString(ked.v),
+            };
+        }
+        catch (error) {
+            throw new SerializeError(`Invalid version string in SAD: ${ked.v}`, undefined, error instanceof Error ? error.message : undefined);
+        }
+    })();
+    const actualKind = kind ?? smellage.kind;
+    let raw = dumps(ked, actualKind);
+    const size = raw.length;
+    const vs = versify({
+        proto: smellage.proto,
+        pvrsn: smellage.pvrsn,
+        gvrsn: smellage.gvrsn,
+        kind: actualKind,
+        size,
+    });
+    ked.v = vs;
+    raw = dumps(ked, actualKind);
+    if (raw.length !== size) {
+        throw new SerializeError(`Malformed version string size for ${vs}`);
+    }
+    return {
+        raw,
+        proto: smellage.proto,
+        kind: actualKind,
+        ked,
+        pvrsn: smellage.pvrsn,
+        gvrsn: smellage.gvrsn,
+    };
+}
+function parseVersionString(vs) {
+    return smell(b(vs)).smellage;
+}
+function versionFields(entries) {
+    return Object.fromEntries(Object.entries(entries).map(([ilk, dom]) => [
+        ilk,
+        {
+            alls: dom.alls,
+            opts: dom.opts ?? {},
+            alts: dom.alts ?? {},
+            saids: dom.saids ?? {},
+            strict: dom.strict ?? true,
+        },
+    ]));
+}
+const FIELDS = {
+    [Protocols.keri]: {
+        [versionKey(Vrsn_1_0)]: versionFields({
+            icp: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    b: [],
+                    c: [],
+                    a: [],
+                },
+                saids: { d: DigDex.Blake3_256, i: DigDex.Blake3_256 },
+            },
+            rot: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    p: "",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    br: [],
+                    ba: [],
+                    a: [],
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            ixn: {
+                alls: { v: "", t: "", d: "", i: "", s: "0", p: "", a: [] },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            dip: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    b: [],
+                    c: [],
+                    a: [],
+                    di: "",
+                },
+                saids: { d: DigDex.Blake3_256, i: DigDex.Blake3_256 },
+            },
+            drt: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    p: "",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    br: [],
+                    ba: [],
+                    a: [],
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rct: { alls: { v: "", t: "", d: "", i: "", s: "0" } },
+            qry: {
+                alls: { v: "", t: "", d: "", dt: "", r: "", rr: "", q: {} },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rpy: {
+                alls: { v: "", t: "", d: "", dt: "", r: "", a: [] },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            pro: {
+                alls: { v: "", t: "", d: "", dt: "", r: "", rr: "", q: {} },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            bar: {
+                alls: { v: "", t: "", d: "", dt: "", r: "", a: [] },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            exn: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    rp: "",
+                    p: "",
+                    dt: "",
+                    r: "",
+                    q: {},
+                    a: [],
+                    e: {},
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            vcp: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    ii: "",
+                    s: "0",
+                    c: [],
+                    bt: "0",
+                    b: [],
+                    n: "",
+                },
+                saids: { d: DigDex.Blake3_256, i: DigDex.Blake3_256 },
+            },
+            vrt: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    p: "",
+                    s: "0",
+                    bt: "0",
+                    br: [],
+                    ba: [],
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            iss: {
+                alls: { v: "", t: "", d: "", i: "", s: "0", ri: "", dt: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rev: {
+                alls: { v: "", t: "", d: "", i: "", s: "0", ri: "", p: "", dt: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            bis: {
+                alls: { v: "", t: "", d: "", i: "", ii: "", s: "0", ra: {}, dt: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            brv: {
+                alls: { v: "", t: "", d: "", i: "", s: "0", p: "", ra: {}, dt: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+        }),
+        [versionKey(Vrsn_2_0)]: versionFields({
+            icp: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    b: [],
+                    c: [],
+                    a: [],
+                },
+                saids: { d: DigDex.Blake3_256, i: DigDex.Blake3_256 },
+            },
+            rot: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    p: "",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    br: [],
+                    ba: [],
+                    c: [],
+                    a: [],
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            ixn: {
+                alls: { v: "", t: "", d: "", i: "", s: "0", p: "", a: [] },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            dip: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    b: [],
+                    c: [],
+                    a: [],
+                    di: "",
+                },
+                saids: { d: DigDex.Blake3_256, i: DigDex.Blake3_256 },
+            },
+            drt: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    s: "0",
+                    p: "",
+                    kt: "0",
+                    k: [],
+                    nt: "0",
+                    n: [],
+                    bt: "0",
+                    br: [],
+                    ba: [],
+                    c: [],
+                    a: [],
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rct: { alls: { v: "", t: "", d: "", i: "", s: "0" } },
+            qry: {
+                alls: { v: "", t: "", d: "", i: "", dt: "", r: "", rr: "", q: {} },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rpy: {
+                alls: { v: "", t: "", d: "", i: "", dt: "", r: "", a: {} },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            pro: {
+                alls: { v: "", t: "", d: "", i: "", dt: "", r: "", rr: "", q: {} },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            bar: {
+                alls: { v: "", t: "", d: "", i: "", dt: "", r: "", a: {} },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            xip: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    ri: "",
+                    dt: "",
+                    r: "",
+                    q: {},
+                    a: {},
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            exn: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    i: "",
+                    ri: "",
+                    x: "",
+                    p: "",
+                    dt: "",
+                    r: "",
+                    q: {},
+                    a: {},
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+        }),
+    },
+    [Protocols.acdc]: {
+        [versionKey(Vrsn_1_0)]: versionFields({
+            "<none>": {
+                alls: {
+                    v: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    ri: "",
+                    s: "",
+                    a: "",
+                    A: "",
+                    e: "",
+                    r: "",
+                },
+                opts: { u: "", ri: "", a: "", A: "", e: "", r: "" },
+                alts: { a: "A", A: "a" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            ace: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    ri: "",
+                    s: "",
+                    a: "",
+                    A: "",
+                    e: "",
+                    r: "",
+                },
+                opts: { u: "", ri: "", a: "", A: "", e: "", r: "" },
+                alts: { a: "A", A: "a" },
+                saids: { d: DigDex.Blake3_256 },
+                strict: false,
+            },
+        }),
+        [versionKey(Vrsn_2_0)]: versionFields({
+            "<none>": {
+                alls: {
+                    v: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    rd: "",
+                    s: "",
+                    a: "",
+                    A: "",
+                    e: "",
+                    r: "",
+                },
+                opts: { u: "", rd: "", a: "", A: "", e: "", r: "" },
+                alts: { a: "A", A: "a" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            acm: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    rd: "",
+                    s: "",
+                    a: "",
+                    A: "",
+                    e: "",
+                    r: "",
+                },
+                opts: { t: "", u: "", rd: "", a: "", A: "", e: "", r: "" },
+                alts: { a: "A", A: "a" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            ace: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    ri: "",
+                    s: "",
+                    a: "",
+                    A: "",
+                    e: "",
+                    r: "",
+                },
+                opts: { u: "", ri: "", a: "", A: "", e: "", r: "" },
+                alts: { a: "A", A: "a" },
+                saids: { d: DigDex.Blake3_256 },
+                strict: false,
+            },
+            act: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    rd: "",
+                    s: "",
+                    a: "",
+                    e: "",
+                    r: "",
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            acg: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    u: "",
+                    i: "",
+                    rd: "",
+                    s: "",
+                    A: "",
+                    e: "",
+                    r: "",
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            sch: {
+                alls: { v: "", t: "", d: "", s: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            att: {
+                alls: { v: "", t: "", d: "", a: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            agg: {
+                alls: { v: "", t: "", d: "", A: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            edg: {
+                alls: { v: "", t: "", d: "", e: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rul: {
+                alls: { v: "", t: "", d: "", r: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            rip: {
+                alls: { v: "", t: "", d: "", u: "", i: "", n: "", dt: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            bup: {
+                alls: { v: "", t: "", d: "", rd: "", n: "", p: "", dt: "", b: "" },
+                saids: { d: DigDex.Blake3_256 },
+            },
+            upd: {
+                alls: {
+                    v: "",
+                    t: "",
+                    d: "",
+                    rd: "",
+                    n: "",
+                    p: "",
+                    dt: "",
+                    td: "",
+                    ts: "",
+                },
+                saids: { d: DigDex.Blake3_256 },
+            },
+        }),
+    },
+};
+function isHydratedInit(init) {
+    return "smellage" in init && "ked" in init && "ilk" in init && "said" in init;
+}
+function isRawInit(init) {
+    return "raw" in init && !isHydratedInit(init) && !("sad" in init);
+}
+function nativeSmellage(proto, pvrsn, gvrsn, size) {
+    return {
+        proto,
+        pvrsn,
+        gvrsn,
+        kind: Kinds.cesr,
+        size,
+    };
+}
+function fieldMapKey(ilk) {
+    return ilk ?? "<none>";
+}
+/** Resolve the field-domain contract for one protocol/version/ilk combination. */
+function getFieldDom(registry, proto, pvrsn, ilk) {
+    const protoFields = registry[proto];
+    if (!protoFields) {
+        throw new SerializeError(`Invalid protocol=${proto}`);
+    }
+    const versionFields = protoFields[versionKey(pvrsn)];
+    if (!versionFields) {
+        throw new SerializeError(`Invalid version=${versionKey(pvrsn)} for protocol=${proto}`);
+    }
+    const fields = versionFields[fieldMapKey(ilk)];
+    if (!fields) {
+        throw new SerializeError(`Invalid packet type (ilk)=${String(ilk)} for protocol=${proto}`);
+    }
+    return fields;
+}
+/** Decode raw serialized bytes into a protocol SAD plus projected ilk/said fields. */
+function parseRawToKed(raw, smellage) {
+    const { kind } = smellage;
+    let ked = null;
+    let ilk = null;
+    let said = null;
+    try {
+        if (kind === "JSON") {
+            ked = JSON.parse(t(raw));
+        }
+        else if (kind === "MGPK") {
+            ked = normalizeDecodedMap(decodeMsgpack(raw), kind);
+        }
+        else if (kind === "CBOR") {
+            ked = normalizeDecodedMap(decodeKeriCbor(raw), kind);
+        }
+        else if (kind === "CESR") {
+            // Native inhale is delegated to the shared helper layer because CESR
+            // bodies are not self-describing through `smell()` the same way
+            // JSON/CBOR/MGPK bodies are.
+            const native = parseCesrNativeKed(raw, smellage);
+            ked = native.ked;
+            ilk = native.ilk;
+            said = native.said;
+        }
+    }
+    catch (error) {
+        if (error instanceof DeserializeError) {
+            throw new DeserializeError(`Failed to decode ${kind} Serder: ${String(error.message)}`);
+        }
+        if (kind === "JSON" && error instanceof SyntaxError) {
+            throw new DeserializeError(`Failed to decode JSON Serder: ${String(error)}`);
+        }
+        throw new DeserializeError(`Failed to decode ${kind} Serder: ${String(error)}`);
+    }
+    if (ked) {
+        ilk = typeof ked.t === "string" ? ked.t : null;
+        said = typeof ked.d === "string" ? ked.d : null;
+    }
+    return { ked, ilk, said };
+}
+function coerceMatterCode(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        return null;
+    }
+    try {
+        return parseMatter(b(value), "txt").code;
+    }
+    catch {
+        return null;
+    }
+}
+function shallowCloneSad(sad) {
+    return Object.fromEntries(Object.entries(sad).map(([k, v]) => [k, cloneDefault(v)]));
+}
+/** True when the top-level ACDC ilk participates in KERIpy's most-compact SAID rule. */
+function isAcdcCompactiveIlk(ilk) {
+    return ilk === null || ACDC_COMPACT_TOP_LEVEL_ILKS.has(ilk);
+}
+/** True when the message is an ACDC section-message that must verify embedded section ids. */
+function isAcdcPartialSectionIlk(ilk) {
+    return ACDC_PARTIAL_SECTION_ILKS.has(ilk ?? "");
+}
+/** Map ACDC section labels onto the saidive policy KERIpy applies to that section family. */
+function acdcSectionConfig(label) {
+    if (label === "s") {
+        return {
+            strict: false,
+            saids: { $id: DigDex.Blake3_256 },
+        };
+    }
+    if (label === "a" || label === "e" || label === "r") {
+        return {
+            strict: true,
+            saids: { d: DigDex.Blake3_256 },
+        };
+    }
+    return null;
+}
+/** Ensure the section carries the saidive placeholder label KERIpy computes over. */
+function withAcdcSectionPlaceholder(label, value) {
+    const copy = shallowCloneSad(value);
+    if (label === "s" && !("$id" in copy)) {
+        copy.$id = "";
+    }
+    if ((label === "a" || label === "e" || label === "r") && !("d" in copy)) {
+        copy.d = "";
+    }
+    return copy;
+}
+/**
+ * Build the "display" and "compact" variants of one ACDC section field.
+ *
+ * Maintainer model:
+ * - `display` is what the caller-visible SAD should keep
+ * - `compact` is what top-level `d` must be hashed over for compactive ilks
+ *
+ * This is the seam that translates plain semantic section data into the shared
+ * native primitives:
+ * - `Compactor` for `s`/`a`/`e`/`r`
+ * - `Aggor` for `A`
+ */
+function computeAcdcFieldVariants(label, value, kind, topLevelCompactable, compactify, partialSection) {
+    const sectionConfig = acdcSectionConfig(label);
+    if (sectionConfig && value && typeof value === "object" && !Array.isArray(value)) {
+        const expanded = new Compactor({
+            mad: withAcdcSectionPlaceholder(label, value),
+            kind,
+            verify: false,
+            saidive: true,
+            strict: sectionConfig.strict,
+            saids: sectionConfig.saids,
+            makify: true,
+        });
+        expanded.trace(true);
+        if (!topLevelCompactable) {
+            return {
+                display: expanded.mad,
+                compact: expanded.mad,
+            };
+        }
+        const compacted = new Compactor({
+            mad: withAcdcSectionPlaceholder(label, value),
+            kind,
+            verify: false,
+            saidive: true,
+            strict: sectionConfig.strict,
+            saids: sectionConfig.saids,
+            makify: true,
+        });
+        compacted.compact();
+        return {
+            display: compactify ? (compacted.said ?? compacted.mad) : expanded.mad,
+            compact: compacted.said ?? compacted.mad,
+        };
+    }
+    if (label === "A" && Array.isArray(value)) {
+        const aggor = new Aggor({
+            ael: cloneDefault(value),
+            kind,
+            makify: true,
+            verify: false,
+        });
+        if (!topLevelCompactable || partialSection) {
+            return {
+                display: aggor.ael,
+                compact: aggor.ael,
+            };
+        }
+        return {
+            display: compactify ? (aggor.agid ?? aggor.ael) : aggor.ael,
+            compact: aggor.agid ?? aggor.ael,
+        };
+    }
+    return { display: cloneDefault(value), compact: cloneDefault(value) };
+}
+function computeAcdcSad(sad, { kind, 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 partialSection = isAcdcPartialSectionIlk(ilk);
+    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 code = saids.d ?? DigDex.Blake3_256;
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage?.fs) {
+        throw new SerializeError(`Unsupported ACDC SAID code=${code}`);
+    }
+    const hashSad = shallowCloneSad(compactSad);
+    hashSad.d = "#".repeat(sizage.fs);
+    // `sizeify()` must happen before digesting because non-native version strings
+    // include size, so the hashed serialization has to already carry the final
+    // version-string span.
+    sizeify(hashSad, kind);
+    const digestRaw = dumps(hashSad, kind);
+    const said = new Diger({ code, raw: Diger.digest(digestRaw, code) }).qb64;
+    compactSad.d = said;
+    displaySad.d = said;
+    const sizedDisplay = shallowCloneSad(displaySad);
+    const { raw } = sizeify(sizedDisplay, kind);
+    return {
+        sad: sizedDisplay,
+        raw,
+        compactSad,
+    };
+}
+function validateSadAgainstFieldDom(ctor, serder) {
+    // This helper centralizes the generic field-domain checks used by both base
+    // `Serder` verification and the ACDC-specific override. Keeping it separate
+    // prevents the ACDC path from drifting on required/optional/order rules while
+    // still letting it customize SAID verification semantics afterward.
+    if (!serder.ked) {
+        throw new DeserializeError("Cannot verify Serder without decoded SAD.");
+    }
+    if (ctor.Protocol && serder.proto !== ctor.Protocol) {
+        throw new DeserializeError(`Required protocol=${ctor.Protocol}, got ${serder.proto}`);
+    }
+    const ked = serder.ked;
+    const fields = getFieldDom(ctor.Fields, serder.proto, serder.pvrsn, serder.ilk);
+    const currentKeys = Object.keys(ked);
+    const allowedKeys = Object.keys(fields.alls);
+    const extraKeys = currentKeys.filter((key) => !allowedKeys.includes(key));
+    if (extraKeys.length > 0 && (fields.strict ?? true)) {
+        throw new DeserializeError(`Unallowed extra field(s)=${extraKeys.join(",")}`);
+    }
+    const optional = new Set(Object.keys(fields.opts ?? {}));
+    const required = allowedKeys.filter((key) => !optional.has(key));
+    for (const label of required) {
+        if (!(label in ked)) {
+            throw new DeserializeError(`Missing required field=${label}`);
+        }
+    }
+    const orderWithoutExtras = currentKeys.filter((key) => allowedKeys.includes(key));
+    const expectedOrder = allowedKeys.filter((key) => key in ked);
+    if (orderWithoutExtras.join("|") !== expectedOrder.join("|")) {
+        throw new DeserializeError("Missing or out-of-order fields in SAD.");
+    }
+    for (const [label, alt] of Object.entries(fields.alts ?? {})) {
+        if (label in ked && alt in ked) {
+            throw new DeserializeError(`Unallowed alternate fields '${label}' and '${alt}' both present.`);
+        }
+    }
+    const saids = { ...(fields.saids ?? {}) };
+    for (const label of Object.keys(saids)) {
+        const code = coerceMatterCode(ked[label]);
+        if (code) {
+            saids[label] = code;
+        }
+    }
+    return { fields, saids, ked };
+}
+/** Fill default field values and normalize insertion order against one field-domain contract. */
+function normalizeSadWithFieldDom(sad, fields) {
+    const working = shallowCloneSad(sad ?? {});
+    const optional = new Set(Object.keys(fields.opts ?? {}));
+    for (const [label, value] of Object.entries(fields.alls)) {
+        if (!(label in working) && !optional.has(label)) {
+            working[label] = cloneDefault(value);
+        }
+    }
+    const ordered = {};
+    for (const label of Object.keys(fields.alls)) {
+        if (label in working) {
+            ordered[label] = working[label];
+        }
+    }
+    for (const [label, value] of Object.entries(working)) {
+        if (!(label in ordered)) {
+            ordered[label] = value;
+        }
+    }
+    return ordered;
+}
+/** Choose protocol/version/kind defaults for semantic serder construction from SAD input. */
+function resolveProtocolDefaults(ctor, init) {
+    const sad = shallowCloneSad(init.sad ?? {});
+    let smelled = null;
+    if (typeof sad.v === "string" && sad.v.length > 0) {
+        try {
+            smelled = parseVersionString(sad.v);
+        }
+        catch {
+            smelled = null;
+        }
+    }
+    const proto = init.proto ?? smelled?.proto ?? ctor.Proto;
+    const pvrsn = init.pvrsn ?? smelled?.pvrsn ?? ctor.PVrsn;
+    const gvrsn = init.gvrsn ?? smelled?.gvrsn
+        ?? (pvrsn.major >= 2 ? ctor.GVrsn : null);
+    const kind = init.kind ?? smelled?.kind ?? ctor.Kind;
+    const versionFields = ctor.Fields[proto]?.[versionKey(pvrsn)];
+    if (!versionFields) {
+        throw new SerializeError(`Invalid version=${versionKey(pvrsn)} for protocol=${proto}`);
+    }
+    const defaultIlk = Object.keys(versionFields)[0] ?? "<none>";
+    const ilk = init.ilk ?? (typeof sad.t === "string" ? sad.t : null)
+        ?? (defaultIlk === "<none>" ? null : defaultIlk);
+    const fields = getFieldDom(ctor.Fields, proto, pvrsn, ilk);
+    const normalized = normalizeSadWithFieldDom(sad, fields);
+    if (ilk !== null) {
+        normalized.t = ilk;
+    }
+    normalized.v = versify({ proto, pvrsn, gvrsn, kind, size: 0 });
+    const saids = { ...(fields.saids ?? {}) };
+    for (const [label, code] of Object.entries(init.saids ?? {})) {
+        saids[label] = code;
+    }
+    for (const label of Object.keys(saids)) {
+        if (label in (init.saids ?? {})) {
+            continue;
+        }
+        const valueCode = coerceMatterCode(normalized[label]);
+        if (valueCode) {
+            saids[label] = valueCode;
+        }
+    }
+    return { sad: normalized, proto, pvrsn, gvrsn, kind, ilk, saids };
+}
 function collectNestedGroups(entries, out) {
     for (const entry of entries) {
         if (isPrimitiveTuple(entry)) {
@@ -48,23 +1087,18 @@ function collectMessageGroups(message) {
 /**
  * Base Serder body class.
  *
- * KERIpy substance: Serders carry raw serialized event bytes plus decoded KED
- * projections (`ilk`/`said`) and protocol/version metadata.
+ * KERIpy substance: Serders own both halves of the message-body contract:
+ * serialization (`sad` -> `raw`) and deserialization (`raw` -> `sad`) plus
+ * verification of saidive fields against the serialized body bytes.
  */
 export class Serder {
-    constructor(init) {
+    constructor(init = { makify: true }) {
         Object.defineProperty(this, "raw", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "ked", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "kind", {
             enumerable: true,
             configurable: true,
@@ -101,27 +1135,147 @@ export class Serder {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "said", {
+        Object.defineProperty(this, "native", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "native", {
+        Object.defineProperty(this, "_ked", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.raw = init.raw;
-        this.ked = init.ked;
-        this.kind = init.smellage.kind;
-        this.size = init.smellage.size;
-        this.proto = init.smellage.proto;
-        this.pvrsn = init.smellage.pvrsn;
-        this.gvrsn = init.smellage.gvrsn;
-        this.ilk = init.ilk;
-        this.said = init.said;
+        Object.defineProperty(this, "_said", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (isHydratedInit(init)) {
+            this.raw = init.raw;
+            this.kind = init.smellage.kind;
+            this.size = init.smellage.size;
+            this.proto = init.smellage.proto;
+            this.pvrsn = init.smellage.pvrsn;
+            this.gvrsn = init.smellage.gvrsn;
+            this.ilk = init.ilk;
+            this._ked = init.ked;
+            this._said = init.said;
+            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 parsed = parseRawToKed(raw, smellage);
+            this.raw = raw;
+            this.kind = smellage.kind;
+            this.size = smellage.size;
+            this.proto = smellage.proto;
+            this.pvrsn = smellage.pvrsn;
+            this.gvrsn = smellage.gvrsn;
+            this.ilk = parsed.ilk;
+            this._ked = parsed.ked;
+            this._said = parsed.said;
+            if (init.verify ?? true) {
+                this._verify();
+            }
+            return;
+        }
+        const ctor = this.constructor;
+        const resolved = resolveProtocolDefaults(ctor, init);
+        const fields = getFieldDom(ctor.Fields, resolved.proto, resolved.pvrsn, resolved.ilk);
+        const normalized = normalizeSadWithFieldDom(resolved.sad, fields);
+        if (resolved.ilk !== null) {
+            normalized.t = resolved.ilk;
+        }
+        normalized.v = versify({
+            proto: resolved.proto,
+            pvrsn: resolved.pvrsn,
+            gvrsn: resolved.gvrsn,
+            kind: resolved.kind,
+            size: 0,
+        });
+        const actual = (init.makify ?? false)
+            ? resolved.proto === Protocols.acdc
+                ? computeAcdcSad(normalized, {
+                    kind: resolved.kind,
+                    saids: resolved.saids,
+                    compactify: init.compactify ?? false,
+                })
+                : Saider.saidifyFields(normalized, {
+                    kind: resolved.kind,
+                    saids: resolved.saids,
+                    digest: Diger.digest,
+                })
+            : (() => {
+                const existing = shallowCloneSad(normalized);
+                const { raw } = sizeify(existing, resolved.kind);
+                return { sad: existing, raw, saiders: {} };
+            })();
+        const smellage = resolved.kind === Kinds.cesr
+            ? nativeSmellage(resolved.proto, resolved.pvrsn, resolved.gvrsn, actual.raw.length)
+            : smell(actual.raw).smellage;
+        this.raw = actual.raw;
+        this.kind = smellage.kind;
+        this.size = smellage.size;
+        this.proto = smellage.proto;
+        this.pvrsn = smellage.pvrsn;
+        this.gvrsn = smellage.gvrsn;
+        this.ilk = typeof actual.sad.t === "string" ? actual.sad.t : resolved.ilk;
+        this._ked = actual.sad;
+        this._said = typeof actual.sad.d === "string" ? actual.sad.d : null;
+        if (init.verify ?? true) {
+            this._verify();
+        }
+    }
+    get ked() {
+        return this._ked;
+    }
+    get sad() {
+        return this._ked ? shallowCloneSad(this._ked) : null;
+    }
+    get verstr() {
+        return this._ked && typeof this._ked.v === "string" ? this._ked.v : null;
+    }
+    /** CESR message-universal genus code backing this serder's native framing. */
+    get genus() {
+        return MESSAGE_GENUS_BY_PROTOCOL[this.proto];
+    }
+    get protocol() {
+        return this.proto;
+    }
+    /**
+     * Message-universal counter codex selected by the serder's genus version.
+     *
+     * This mirrors KERIpy's `serder.mucodes`: native body-group parsing and emit
+     * use the latest compatible counter table for the active genus major/minor.
+     * Non-native legacy messages without `gvrsn` do not have a meaningful
+     * message-universal codex, so this accessor rejects that misuse explicitly.
+     */
+    get mucodes() {
+        if (!this.gvrsn) {
+            throw new DeserializeError("mucodes requires a CESR genus version.");
+        }
+        return resolveMUDex(this.gvrsn);
+    }
+    get said() {
+        if (this._ked
+            && this.ilk !== null
+            && Object.keys(getFieldDom(this.constructor.Fields, this.proto, this.pvrsn, this.ilk).saids ?? {}).length === 0
+            && typeof this._ked.d === "string") {
+            return this._ked.d;
+        }
+        return this._said;
+    }
+    get saidb() {
+        return this.said ? b(this.said) : null;
+    }
+    get stamp() {
+        return this._ked && typeof this._ked.dt === "string" ? this._ked.dt : null;
     }
     /** True when this body belongs to KERI protocol domain. */
     get isKeri() {
@@ -131,6 +1285,59 @@ export class Serder {
     get isAcdc() {
         return this.proto === Protocols.acdc;
     }
+    verify() {
+        try {
+            this._verify();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    _verify() {
+        const ctor = this.constructor;
+        const { saids, ked } = validateSadAgainstFieldDom(ctor, this);
+        const working = shallowCloneSad(ked);
+        const actual = Saider.saidifyFields(working, {
+            kind: this.kind,
+            saids,
+            digest: Diger.digest,
+        });
+        if (t(actual.raw) !== t(this.raw)) {
+            throw new DeserializeError("Invalid round trip of SAD against raw.");
+        }
+        const actualSmellage = this.kind === Kinds.cesr
+            ? nativeSmellage(this.proto, this.pvrsn, this.gvrsn, actual.raw.length)
+            : smell(actual.raw).smellage;
+        if (actualSmellage.proto !== this.proto) {
+            throw new DeserializeError("Inconsistent protocol after verification.");
+        }
+        if (actualSmellage.pvrsn.major !== this.pvrsn.major
+            || actualSmellage.pvrsn.minor !== this.pvrsn.minor) {
+            throw new DeserializeError("Inconsistent protocol version after verification.");
+        }
+        if (actualSmellage.kind !== this.kind) {
+            throw new DeserializeError("Inconsistent serialization kind after verification.");
+        }
+        if (actualSmellage.size !== this.size || actual.raw.length !== this.size) {
+            throw new DeserializeError("Inconsistent serialized size after verification.");
+        }
+        if ((actualSmellage.gvrsn?.major ?? -1) !== (this.gvrsn?.major ?? -1)
+            || (actualSmellage.gvrsn?.minor ?? -1) !== (this.gvrsn?.minor ?? -1)) {
+            throw new DeserializeError("Inconsistent genus version after verification.");
+        }
+    }
+    compare(said) {
+        if (!said || !this.saidb) {
+            throw new DeserializeError("Uncomparable saids.");
+        }
+        const other = typeof said === "string" ? b(said) : said;
+        return t(other) === t(this.saidb);
+    }
+    pretty(opts = {}) {
+        const pretty = JSON.stringify(this._ked, null, 1);
+        return opts.size ? pretty.slice(0, opts.size) : pretty;
+    }
     /**
      * Project counted attachment groups into structor subclasses.
      *
@@ -168,71 +1375,363 @@ export class Serder {
         return projection;
     }
 }
+Object.defineProperty(Serder, "Protocol", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: null
+});
+Object.defineProperty(Serder, "Proto", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Protocols.keri
+});
+Object.defineProperty(Serder, "PVrsn", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Vrsn_1_0
+});
+Object.defineProperty(Serder, "GVrsn", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Vrsn_2_0
+});
+Object.defineProperty(Serder, "Kind", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "JSON"
+});
+Object.defineProperty(Serder, "Fields", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: FIELDS
+});
 /** KERI-protocol Serder subtype (`proto=KERI`). */
 export class SerderKERI extends Serder {
-    constructor(init) {
+    constructor(init = { makify: true }) {
         super(init);
         if (!this.isKeri) {
             throw new DeserializeError(`Expected KERI protocol serder, got ${this.proto}`);
         }
     }
+    _verify() {
+        super._verify();
+        const sad = this.ked;
+        if (!sad) {
+            throw new DeserializeError("Missing decoded KERI SAD.");
+        }
+        const allowedKeys = Object.keys(getFieldDom(FIELDS, this.proto, this.pvrsn, this.ilk).alls);
+        const actualKeys = Object.keys(sad);
+        if (allowedKeys.join("|") !== actualKeys.join("|")) {
+            throw new DeserializeError(`Invalid top level field list. Expected ${allowedKeys.join(",")} got ${actualKeys.join(",")}.`);
+        }
+        const pre = this.pre;
+        if (pre && PREFIX_CODES.has(coerceMatterCode(pre) ?? "")) {
+            const code = coerceMatterCode(pre);
+            if (this.ilk === Ilks.dip && !DIGEST_CODES.has(code)) {
+                throw new DeserializeError(`Delegated inception requires digestive prefix code, got ${code}.`);
+            }
+            if (this.ilk === Ilks.icp || this.ilk === Ilks.dip) {
+                if (NON_DIGEST_PREFIX_CODES.has(code)) {
+                    if (this.keys.length !== 1) {
+                        throw new DeserializeError(`Non-digestive prefix ${code} requires exactly one key.`);
+                    }
+                    if (this.tholder?.num !== 1n || this.tholder.weighted) {
+                        throw new DeserializeError(`Non-digestive prefix ${code} requires signing threshold 1.`);
+                    }
+                    if (pre !== this.keys[0]) {
+                        throw new DeserializeError(`Non-digestive prefix ${code} must equal the zeroth key.`);
+                    }
+                }
+                if (NON_TRANSFERABLE_CODES.has(code)) {
+                    if (this.ndigs.length > 0) {
+                        throw new DeserializeError(`Non-transferable prefix ${code} requires empty nxt digests.`);
+                    }
+                    if (this.backs.length > 0) {
+                        throw new DeserializeError(`Non-transferable prefix ${code} requires no backers.`);
+                    }
+                    if (this.seals.length > 0) {
+                        throw new DeserializeError(`Non-transferable prefix ${code} requires no seals/data.`);
+                    }
+                }
+            }
+        }
+        if (this.ilk === Ilks.dip && this.delpre) {
+            const delCode = coerceMatterCode(this.delpre);
+            if (!delCode || !PREFIX_CODES.has(delCode) || !DIGEST_CODES.has(delCode)) {
+                throw new DeserializeError(`Invalid delegator/delegate prefix code=${String(delCode)}.`);
+            }
+        }
+    }
+    get estive() {
+        return KERI_ESTABLISHMENT_ILKS.has(this.ilk ?? "");
+    }
+    get pre() {
+        return this.ked && typeof this.ked.i === "string" ? this.ked.i : null;
+    }
+    get preb() {
+        return this.pre ? b(this.pre) : null;
+    }
+    get sner() {
+        return makeNumberPrimitive(this.snh);
+    }
+    get sn() {
+        return this.sner ? Number(this.sner.num) : null;
+    }
+    get snh() {
+        return this.ked && typeof this.ked.s === "string" ? this.ked.s : null;
+    }
+    /**
+     * Raw top-level `a` field from the decoded KERI SAD.
+     *
+     * Do not assume this is always a seal list. KERI reuses `a` for multiple
+     * semantic roles, which is why typed seal projection is exposed separately.
+     */
+    get a() {
+        return this.ked?.a;
+    }
+    /**
+     * Raw KERI `a` list as decoded from the SAD.
+     *
+     * This accessor intentionally stays raw for KERIpy parity. The same label `a`
+     * is used in KERI for more than one semantic purpose, so eager typing here
+     * would conflate raw SAD decoding with higher-level interpretation.
+     */
+    get seals() {
+        return Array.isArray(this.ked?.a) ? [...this.ked.a] : [];
+    }
+    /**
+     * Typed seal projection built from raw KERI `a` SAD entries.
+     *
+     * Boundary rule:
+     * - `seals` stays raw and untyped for KERIpy parity
+     * - `sealRecords` is the explicit semantic projection and therefore rejects
+     *   malformed or unknown seal dictionaries instead of silently skipping them
+     */
+    get sealRecords() {
+        return this.seals.map((seal, index) => parseSealRecord(seal, index));
+    }
+    /**
+     * Narrow `sealRecords` to event-style seals used for anchoring and delegation.
+     *
+     * Use this when the caller needs semantic seal fields (`i`, `s`, `d`) instead
+     * of raw `a` dictionaries.
+     */
+    get eventSeals() {
+        return this.sealRecords.filter(isSealEventRecord);
+    }
+    get traits() {
+        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")
+            : [];
+    }
+    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")
+            : [];
+    }
+    get ntholder() {
+        return makeThreshold(this.ked?.nt ?? null);
+    }
+    get ndigers() {
+        return this.ndigs.map((dig) => new Diger({ qb64: dig }));
+    }
+    get bner() {
+        return makeNumberPrimitive(this.ked
+            && (typeof this.ked.bt === "string" || typeof this.ked.bt === "number"
+                || typeof this.ked.bt === "bigint")
+            ? this.ked.bt
+            : null);
+    }
+    get bn() {
+        return this.bner ? Number(this.bner.num) : null;
+    }
+    get backs() {
+        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 }));
+    }
+    get prior() {
+        return this.ked && typeof this.ked.p === "string" ? this.ked.p : null;
+    }
+    get priorb() {
+        return this.prior ? b(this.prior) : null;
+    }
+    get cuts() {
+        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")
+            : [];
+    }
+    get delpre() {
+        return this.ked && typeof this.ked.di === "string" ? this.ked.di : null;
+    }
+    get delpreb() {
+        return this.delpre ? b(this.delpre) : null;
+    }
+    get route() {
+        return this.ked && typeof this.ked.r === "string" ? this.ked.r : null;
+    }
+    get uuid() {
+        return this.ked && typeof this.ked.u === "string" ? this.ked.u : null;
+    }
+    get nonce() {
+        if (this.pvrsn.major < 2 && this.pvrsn.minor < 1 && this.ilk === Ilks.vcp) {
+            return this.ked && typeof this.ked.n === "string" ? this.ked.n : null;
+        }
+        return this.uuid;
+    }
 }
+Object.defineProperty(SerderKERI, "Protocol", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Protocols.keri
+});
+Object.defineProperty(SerderKERI, "Proto", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Protocols.keri
+});
 /** ACDC-protocol Serder subtype (`proto=ACDC`). */
 export class SerderACDC extends Serder {
-    constructor(init) {
+    constructor(init = { makify: true }) {
         super(init);
         if (!this.isAcdc) {
             throw new DeserializeError(`Expected ACDC protocol serder, got ${this.proto}`);
         }
     }
-}
-/**
- * Parse one raw Serder body and hydrate protocol-specific Serder subclasses.
- */
-export function parseSerder(raw, smellage) {
-    const { proto, kind, pvrsn, gvrsn, size } = smellage;
-    let ked = null;
-    let ilk = null;
-    let said = null;
-    try {
-        if (kind === "JSON") {
-            const text = t(raw);
-            ked = JSON.parse(text);
-        }
-        else if (kind === "MGPK") {
-            ked = normalizeDecodedMap(decodeMsgpack(raw), kind);
+    _verify() {
+        const ctor = this.constructor;
+        const { ked, saids } = validateSadAgainstFieldDom(ctor, this);
+        const actual = computeAcdcSad(shallowCloneSad(ked), {
+            kind: this.kind,
+            saids,
+            compactify: false,
+        });
+        if (typeof ked.d !== "string" || actual.sad.d !== ked.d) {
+            throw new DeserializeError("Invalid compact-form ACDC SAID.");
         }
-        else if (kind === "CBOR") {
-            ked = normalizeDecodedMap(decodeKeriCbor(raw), kind);
+        const serialized = shallowCloneSad(ked);
+        const { raw } = sizeify(serialized, this.kind);
+        if (t(raw) !== t(this.raw)) {
+            throw new DeserializeError("Invalid ACDC raw serialization against SAD.");
         }
-        if (ked) {
-            ilk = typeof ked.t === "string" ? ked.t : null;
-            said = typeof ked.d === "string" ? ked.d : null;
+        if (this.ilk === null
+            || ACDC_SAIDIVE_TOP_LEVEL_ILKS.has(this.ilk)) {
+            const issuer = this.issuer;
+            if (!issuer) {
+                throw new DeserializeError("Invalid issuer AID.");
+            }
+            const code = coerceMatterCode(issuer);
+            if (!code || !PREFIX_CODES.has(code)) {
+                throw new DeserializeError(`Invalid issuer AID code=${String(code)}.`);
+            }
         }
     }
-    catch (error) {
-        if (error instanceof DeserializeError) {
-            throw new DeserializeError(`Failed to decode ${kind} Serder: ${String(error.message)}`);
+    get uuid() {
+        return this.ked && typeof this.ked.u === "string" ? this.ked.u : null;
+    }
+    get uuidb() {
+        return this.uuid ? b(this.uuid) : null;
+    }
+    get issuer() {
+        return this.ked && typeof this.ked.i === "string" ? this.ked.i : null;
+    }
+    get issuerb() {
+        return this.issuer ? b(this.issuer) : null;
+    }
+    get regid() {
+        if (!this.ked) {
+            return null;
         }
-        if (kind === "JSON" && error instanceof SyntaxError) {
-            throw new DeserializeError(`Failed to decode JSON Serder: ${String(error)}`);
+        if (this.pvrsn.major === 1) {
+            return typeof this.ked.ri === "string" ? this.ked.ri : null;
         }
-        if (kind === "MGPK" || kind === "CBOR") {
-            throw new DeserializeError(`Failed to decode ${kind} Serder: ${String(error)}`);
+        return typeof this.ked.rd === "string" ? this.ked.rd : null;
+    }
+    get regidb() {
+        return this.regid ? b(this.regid) : null;
+    }
+    get schema() {
+        return this.ked?.s;
+    }
+    get attrib() {
+        return this.ked?.a;
+    }
+    get issuee() {
+        const attrib = this.attrib;
+        if (attrib && typeof attrib === "object" && !Array.isArray(attrib)) {
+            const issuee = attrib.i;
+            return typeof issuee === "string" ? issuee : null;
         }
-        throw error;
+        return null;
     }
+    get issueeb() {
+        return this.issuee ? b(this.issuee) : null;
+    }
+    get aggreg() {
+        return this.ked?.A;
+    }
+    get edge() {
+        return this.ked?.e;
+    }
+    get rule() {
+        return this.ked?.r;
+    }
+}
+Object.defineProperty(SerderACDC, "Protocol", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Protocols.acdc
+});
+Object.defineProperty(SerderACDC, "Proto", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Protocols.acdc
+});
+/**
+ * Parse one raw Serder body and hydrate protocol-specific Serder subclasses.
+ */
+export function parseSerder(raw, smellage) {
+    const { ked, ilk, said } = parseRawToKed(raw, smellage);
     const init = {
         raw,
-        smellage: { proto, kind, pvrsn, gvrsn, size },
+        smellage,
         ked,
         ilk,
         said,
     };
-    if (proto === Protocols.keri) {
+    if (smellage.proto === Protocols.keri) {
         return new SerderKERI(init);
     }
-    if (proto === Protocols.acdc) {
+    if (smellage.proto === Protocols.acdc) {
         return new SerderACDC(init);
     }
     return new Serder(init);