cesr-ts 0.4.0 → 0.6.0

package/esm/src/primitives/mapper.js

@@ -1,22 +1,49 @@
-import { DeserializeError, SemanticInterpretationError, ShortageError, SyntaxParseError, UnknownCodeError, } from "../core/errors.js";
+import { decode as decodeMsgpack, encode as encodeMsgpack } from "@msgpack/msgpack";
+import { b, codeB2ToB64, codeB64ToB2, t } from "../core/bytes.js";
+import { decodeKeriCbor, encodeKeriCbor } from "../core/cbor.js";
+import { DeserializeError, SemanticInterpretationError, SerializeError, ShortageError, SyntaxParseError, UnknownCodeError, } from "../core/errors.js";
 import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
+import { CtrDexV2 } from "../tables/counter-codex.js";
 import { AGGOR_LIST_CODES, AGGOR_MAP_CODES } from "../tables/counter-groups.js";
-import { parseCounter } from "./counter.js";
+import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { Bexter } from "./bexter.js";
+import { BEXTER_CODES, DECIMAL_CODES, ESCAPE_CODES, LabelDex, LABELER_CODES, MtrDex } from "./codex.js";
+import { Counter, parseCounter } from "./counter.js";
+import { Decimer } from "./decimer.js";
+import { Diger } from "./diger.js";
 import { parseLabeler } from "./labeler.js";
-import { parseMatter } from "./matter.js";
+import { Matter, parseMatter } from "./matter.js";
+import { Texter } from "./texter.js";
+/** Deep-clone helper so semantic constructors never mutate caller-provided SAD input. */
+function cloneValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneValue(entry));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cloneValue(v)]));
+    }
+    return value;
+}
 function tokenSize(token, domain) {
     return domain === "bny" ? token.fullSizeB2 : token.fullSize;
 }
 function isMapGroupCode(code) {
     return AGGOR_MAP_CODES.has(code);
 }
+/**
+ * Normalize qb2 map bytes into the canonical qb64 text form used internally.
+ *
+ * This follows the broader native-serder rule that qb64 text is the maintainer
+ * source of truth even when the original transport was qb2.
+ */
+function canonicalizeNativeRaw(input, version) {
+    if (input.length > 0 && input[0] === "-".charCodeAt(0)) {
+        return input;
+    }
+    const counter = parseCounter(input, version, "bny");
+    return b(codeB2ToB64(input, counter.fullSize + counter.count * 4));
+}
 function parseCounterProbe(input, version, domain) {
-    /**
-     * Syntax probe only: attempt known major versions without committing semantic
-     * meaning until dispatch selection succeeds.
-     */
-    // Probe both active and known majors so map parsing remains robust when
-    // streams mix legacy and current counters in nested structures.
     const attempts = [
         version,
         { major: 2, minor: 0 },
@@ -40,7 +67,8 @@ function parseCounterProbe(input, version, domain) {
     return null;
 }
 function parseLabelProbe(input, domain) {
-    /** Label probe only; non-label parse failures are treated as "not a label". */
+    // A failed label parse is not automatically an error. In a native map
+    // payload, it may simply mean the next token is a value rather than a key.
     try {
         return parseLabeler(input, domain);
     }
@@ -56,12 +84,8 @@ function parseLabelProbe(input, domain) {
     }
 }
 function parseMapperValueSyntax(input, version, domain) {
-    /**
-     * Parse a single map value token artifact.
-     *
-     * If the value is itself a map-group counter, recurse into
-     * `parseMapperBodySyntax` and attach nested syntax in `children`.
-     */
+    // Grouped list/map values always start with a counter token, so probe that
+    // shape before falling back to plain Matter parsing.
     const counter = parseCounterProbe(input, version, domain);
     if (counter) {
         const dispatch = parseAttachmentDispatch(input, version, domain);
@@ -85,12 +109,8 @@ function parseMapperValueSyntax(input, version, domain) {
     };
 }
 function parseMapPayloadSyntax(input, version, domain, start, end) {
-    /**
-     * Tokenize payload bytes into an ordered syntax stream.
-     *
-     * This phase does not pair labels with values; pairing is deferred to
-     * `interpretMapperBodySyntax`.
-     */
+    // This phase is syntax-only: it tokenizes "label" and "value" artifacts
+    // without yet enforcing that every label is paired with a value.
     const entries = [];
     let offset = start;
     while (offset < end) {
@@ -177,9 +197,558 @@ export function parseMapperBodySyntax(input, version, domain) {
         throw error;
     }
 }
+function encodeTag(text) {
+    const tags = new Map([
+        [1, LabelDex.Tag1],
+        [2, LabelDex.Tag2],
+        [3, LabelDex.Tag3],
+        [4, LabelDex.Tag4],
+        [5, LabelDex.Tag5],
+        [6, LabelDex.Tag6],
+        [7, LabelDex.Tag7],
+        [8, LabelDex.Tag8],
+        [9, LabelDex.Tag9],
+        [10, LabelDex.Tag10],
+        [11, LabelDex.Tag11],
+    ]);
+    const code = tags.get(text.length);
+    if (!code) {
+        throw new SerializeError(`Unsupported mapper tag length=${text.length}`);
+    }
+    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 raw = Bexter.rawify(text);
+    return new Bexter({ code, raw }).qb64;
+}
+/** Encode arbitrary UTF-8 text through CESR bytes-label families. */
+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;
+    return new Texter({ code, raw }).qb64;
+}
 /**
- * Parse map-style native bodies/counters into labeled semantic fields.
- * Compatibility wrapper over syntax parsing + semantic interpretation phases.
+ * Choose the narrowest native text encoding that can round-trip `text`.
+ *
+ * Read this as the mapper-side "smallest truthful token" rule:
+ * tag first for tiny safe labels/text, then StrB64, then raw bytes.
+ */
+function encodeText(text) {
+    if (text.length === 0) {
+        return LabelDex.Empty;
+    }
+    if (/^[A-Za-z0-9_-]{1,11}$/.test(text)) {
+        return encodeTag(text);
+    }
+    if (/^[A-Za-z0-9_-]+$/.test(text)) {
+        return encodeBext(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
+    // needs label-style encoding.
+    if (value === null) {
+        return new Matter({ code: MtrDex.Null, raw: new Uint8Array() }).qb64;
+    }
+    if (typeof value === "boolean") {
+        return new Matter({
+            code: value ? MtrDex.Yes : MtrDex.No,
+            raw: new Uint8Array(),
+        }).qb64;
+    }
+    if (typeof value === "number") {
+        return new Decimer({ decimal: value }).qb64;
+    }
+    if (typeof value === "bigint") {
+        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}`;
+            }
+        }
+        catch {
+            // fall through to text encoding
+        }
+        return encodeText(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,
+            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;
+        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;
+        return `${new Counter({ code, count: payload.length / 4 }).qb64}${payload}`;
+    }
+    throw new SerializeError(`Nonserializable mapper value=${String(value)}`);
+}
+function deserializeValue(raw, strict) {
+    // This is the inverse of `serializeValue()`: grouped containers first, then
+    // leaf primitives. `nextOffset` tells the caller exactly how much wire space
+    // was consumed by this one semantic value.
+    const counter = parseCounterProbe(raw, { major: 2, minor: 0 }, "txt");
+    if (counter) {
+        if (AGGOR_LIST_CODES.has(counter.code)) {
+            const total = counter.fullSize + counter.count * 4;
+            const payload = raw.slice(counter.fullSize, total);
+            const list = [];
+            let offset = 0;
+            while (offset < payload.length) {
+                const parsed = deserializeValue(payload.slice(offset), strict);
+                list.push(parsed.value);
+                offset += parsed.nextOffset;
+            }
+            return { value: list, nextOffset: total };
+        }
+        if (AGGOR_MAP_CODES.has(counter.code)) {
+            const total = counter.fullSize + counter.count * 4;
+            const payload = raw.slice(counter.fullSize, total);
+            const map = {};
+            let offset = 0;
+            while (offset < payload.length) {
+                const labeler = parseLabeler(payload.slice(offset), "txt");
+                const label = strict ? labeler.label : labeler.text;
+                offset += labeler.fullSize;
+                const parsed = deserializeValue(payload.slice(offset), strict);
+                map[label] = parsed.value;
+                offset += parsed.nextOffset;
+            }
+            return { value: map, nextOffset: total };
+        }
+    }
+    const matter = parseMatter(raw, "txt");
+    let offset = matter.fullSize;
+    if (matter.code === MtrDex.Escape) {
+        const escaped = parseMatter(raw.slice(offset), "txt");
+        return { value: escaped.qb64, nextOffset: offset + escaped.fullSize };
+    }
+    if (matter.code === MtrDex.Null) {
+        return { value: null, nextOffset: offset };
+    }
+    if (matter.code === MtrDex.Yes) {
+        return { value: true, nextOffset: offset };
+    }
+    if (matter.code === MtrDex.No) {
+        return { value: false, nextOffset: offset };
+    }
+    if (DECIMAL_CODES.has(matter.code)) {
+        return { value: new Decimer(matter).decimal, nextOffset: offset };
+    }
+    if (LABELER_CODES.has(matter.code) || BEXTER_CODES.has(matter.code)) {
+        return {
+            value: parseLabeler(b(matter.qb64), "txt").text,
+            nextOffset: offset,
+        };
+    }
+    return { value: matter.qb64, nextOffset: offset };
+}
+function buildFieldProjection(value, strict) {
+    // `fields` is rebuilt from semantic data so the projection stays coherent
+    // even when the mapper originated from `Mapper.fromSad(...)` rather than a
+    // syntax-parse path.
+    return Object.entries(value).map(([label, entry]) => {
+        const serialized = serializeValue(entry, strict);
+        const primitive = serialized.startsWith("-")
+            ? parseCounter(b(serialized), { major: 2, minor: 0 }, "txt")
+            : parseMatter(b(serialized), "txt");
+        const children = entry && typeof entry === "object" && !Array.isArray(entry)
+            ? buildFieldProjection(entry, strict)
+            : undefined;
+        return {
+            label,
+            primitive,
+            isCounter: AGGOR_LIST_CODES.has(primitive.code)
+                || AGGOR_MAP_CODES.has(primitive.code),
+            children,
+        };
+    });
+}
+function verifyMapRoundTrip(mapper) {
+    // Verification is explicit on purpose: rebuild a mapper from the semantic
+    // view and require byte-for-byte raw equality. If this fails, our semantic
+    // projection lost information or our serializer is dishonest.
+    const actual = mapper.kind === "CESR"
+        ? Mapper.fromSad(mapper.mad, {
+            strict: mapper.strict,
+            saidive: mapper.saidive,
+            saids: mapper.saids,
+            kind: mapper.kind,
+            makify: false,
+            verify: false,
+        })
+        : Mapper.fromSad(mapper.mad, {
+            strict: mapper.strict,
+            saidive: mapper.saidive,
+            saids: mapper.saids,
+            kind: mapper.kind,
+            makify: false,
+            verify: false,
+        });
+    if (t(actual.raw) !== t(mapper.raw)) {
+        throw new DeserializeError("Invalid mapper round trip against raw.");
+    }
+}
+/**
+ * Semantic CESR-native map primitive.
+ *
+ * KERIpy substance: `Mapper` is the reusable native field-map engine beneath
+ * compactable ACDC sections. It owns both the semantic map view (`mad`) and the
+ * exact enclosed native group serialization (`raw`, `qb64`, `qb2`).
+ *
+ * Cohesive mental model:
+ * 1. `parseMapperBodySyntax()` tokenizes raw native bytes into syntax artifacts.
+ * 2. `interpretMapperBodySyntax()` pairs those artifacts into readable fields.
+ * 3. `Mapper` owns the full semantic lifecycle: build from `mad`, or inhale
+ *    from raw, then expose both semantic (`mad`) and wire (`raw`, `qb64`,
+ *    `qb2`) views.
+ *
+ * Put differently:
+ * syntax helpers are for inspection and parser diagnostics;
+ * `Mapper` is for truth.
+ *
+ * Compare carefully:
+ * - use `Mapper` when the disclosed thing is a general map
+ * - do not use it for fixed-field blind/bound/media tuples, which have their
+ *   own explicit schema and workflow layer
+ */
+export class Mapper {
+    /**
+     * Create one semantic mapper from either a field map (`mad`) or raw bytes.
+     *
+     * Constructor modes:
+     * - semantic mode: caller provides `mad`, optional `makify`, optional
+     *   `saidive`, and the constructor serializes deterministically
+     * - native inhale mode: caller provides `raw`/`qb64`/`qb64b`/`qb2` with
+     *   `kind="CESR"` and the constructor decodes grouped native content
+     * - non-native inhale mode: caller provides raw JSON/CBOR/MGPK with
+     *   `kind!="CESR"` and the constructor decodes via the corresponding codec
+     */
+    constructor(init = {}) {
+        Object.defineProperty(this, "code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fullSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fullSizeB2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "totalSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "totalSizeB2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "strict", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "saids", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "saidive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_mad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.strict = init.strict ?? true;
+        this.saids = { ...(init.saids ?? { d: "E" }) };
+        this.saidive = init.saidive ?? false;
+        this.kind = init.kind ?? "CESR";
+        if (init.mad || (!init.raw && !init.qb64 && !init.qb64b && !init.qb2)) {
+            const mad = cloneValue(init.mad ?? {});
+            if (init.makify && this.saidive) {
+                // Mapper saidification is intentionally top-level only. Recursive leaf
+                // discovery belongs to `Compactor`; `Mapper` just makes one map
+                // self-addressing when asked.
+                const dummy = cloneValue(mad);
+                for (const [label, code] of Object.entries(this.saids)) {
+                    if (!(label in dummy))
+                        continue;
+                    try {
+                        const valueCode = parseMatter(b(String(dummy[label])), "txt").code;
+                        if (valueCode) {
+                            this.saids[label] = valueCode;
+                        }
+                    }
+                    catch {
+                        // keep configured default
+                    }
+                    const sizage = MATTER_SIZES.get(this.saids[label]);
+                    if (!sizage?.fs) {
+                        throw new SerializeError(`Unsupported mapper SAID code=${this.saids[label]}`);
+                    }
+                    dummy[label] = "#".repeat(sizage.fs);
+                }
+                const dummiedRaw = this.kind === "CESR"
+                    ? Mapper.serializeCesrMap(dummy, this.strict, true, this.saids)
+                    : Mapper.serializeNonNativeMap(dummy, this.kind);
+                for (const [label, code] of Object.entries(this.saids)) {
+                    if (!(label in mad))
+                        continue;
+                    mad[label] = new Diger({ code, raw: Diger.digest(dummiedRaw, code) }).qb64;
+                }
+            }
+            if (this.kind === "CESR") {
+                // In semantic->native mode we already trust `mad`, so we derive the
+                // readable `fields` projection directly from semantic data instead of
+                // re-parsing the raw bytes we just emitted.
+                this.raw = Mapper.serializeCesrMap(mad, this.strict);
+                const counter = parseCounter(this.raw, init.version ?? { major: 2, minor: 0 }, "txt");
+                this.code = counter.code;
+                this.count = counter.count;
+                this.fullSize = counter.fullSize;
+                this.fullSizeB2 = counter.fullSizeB2;
+                this.totalSize = counter.fullSize + counter.count * 4;
+                this.totalSizeB2 = Math.ceil(this.totalSize * 3 / 4);
+                this.fields = buildFieldProjection(mad, this.strict);
+            }
+            else {
+                this.raw = Mapper.serializeNonNativeMap(mad, this.kind);
+                this.code = CtrDexV2.GenericMapGroup;
+                this.count = 0;
+                this.fullSize = 0;
+                this.fullSizeB2 = 0;
+                this.totalSize = this.raw.length;
+                this.totalSizeB2 = this.raw.length;
+                this.fields = buildFieldProjection(mad, this.strict);
+            }
+            this._mad = mad;
+            if (init.verify ?? true) {
+                verifyMapRoundTrip(this);
+            }
+            return;
+        }
+        if (this.kind !== "CESR") {
+            // Non-native support matters because compact/disclose logic for ACDC has
+            // to reason about JSON/CBOR/MGPK section forms too, not just native wire
+            // forms.
+            this.raw = init.raw ?? init.qb64b ?? b(init.qb64 ?? "");
+            this._mad = Mapper.deserializeNonNativeMap(this.raw, this.kind);
+            this.code = CtrDexV2.GenericMapGroup;
+            this.count = 0;
+            this.fullSize = 0;
+            this.fullSizeB2 = 0;
+            this.totalSize = this.raw.length;
+            this.totalSizeB2 = this.raw.length;
+            this.fields = buildFieldProjection(this._mad, this.strict);
+            if (init.verify ?? true) {
+                verifyMapRoundTrip(this);
+            }
+            return;
+        }
+        const version = init.version ?? { major: 2, minor: 0 };
+        const raw = init.qb2
+            ? canonicalizeNativeRaw(init.qb2, version)
+            : init.qb64
+                ? b(init.qb64)
+                : init.qb64b
+                    ? init.qb64b
+                    : init.raw;
+        // In native inhale mode we *do* walk the wire payload because the whole
+        // point is to reconstruct semantic values from the compact map encoding.
+        const counter = parseCounter(raw, version, "txt");
+        if (!isMapGroupCode(counter.code)) {
+            throw new UnknownCodeError(`Expected map-body/group counter, got ${counter.code}`);
+        }
+        const totalSize = counter.fullSize + counter.count * 4;
+        const payload = raw.slice(counter.fullSize, totalSize);
+        const mad = {};
+        let offset = 0;
+        while (offset < payload.length) {
+            const labeler = parseLabeler(payload.slice(offset), "txt");
+            const label = this.strict ? labeler.label : labeler.text;
+            offset += labeler.fullSize;
+            const parsed = deserializeValue(payload.slice(offset), this.strict);
+            mad[label] = parsed.value;
+            offset += parsed.nextOffset;
+        }
+        this.raw = raw.slice(0, totalSize);
+        this.code = counter.code;
+        this.count = counter.count;
+        this.fullSize = counter.fullSize;
+        this.fullSizeB2 = counter.fullSizeB2;
+        this.totalSize = totalSize;
+        this.totalSizeB2 = Math.ceil(totalSize * 3 / 4);
+        this.fields = buildFieldProjection(mad, this.strict);
+        this._mad = mad;
+        if (init.verify ?? true) {
+            verifyMapRoundTrip(this);
+        }
+    }
+    static fromSad(mad, options = {}) {
+        return new Mapper({ ...options, mad });
+    }
+    /**
+     * Serialize one semantic map into an enclosed CESR native map-group.
+     *
+     * The result includes the leading group counter. Nested maps/lists are
+     * recursively enclosed in their own grouped payloads.
+     */
+    static serializeCesrMap(mad, strict = true, dummy = false, saids = {}) {
+        const payload = Object.entries(mad).map(([label, value]) => {
+            const rendered = dummy && label in saids
+                ? (() => {
+                    const sizage = MATTER_SIZES.get(saids[label]);
+                    if (!sizage?.fs) {
+                        throw new SerializeError(`Unsupported mapper SAID code=${saids[label]}`);
+                    }
+                    return "#".repeat(sizage.fs);
+                })()
+                : serializeValue(value, strict);
+            return `${encodeText(label)}${rendered}`;
+        }).join("");
+        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) {
+        if (kind === "JSON") {
+            return b(JSON.stringify(mad));
+        }
+        if (kind === "CBOR") {
+            return encodeKeriCbor(mad);
+        }
+        if (kind === "MGPK") {
+            return encodeMsgpack(mad);
+        }
+        throw new SerializeError(`Unsupported mapper serialization kind=${kind}`);
+    }
+    static deserializeNonNativeMap(raw, kind) {
+        if (kind === "JSON") {
+            return JSON.parse(t(raw));
+        }
+        if (kind === "CBOR") {
+            return decodeKeriCbor(raw);
+        }
+        if (kind === "MGPK") {
+            return decodeMsgpack(raw);
+        }
+        throw new DeserializeError(`Unsupported mapper deserialization kind=${kind}`);
+    }
+    get mad() {
+        // Clone on read so callers can inspect or tweak the returned object
+        // without mutating mapper internals behind the class's back.
+        return cloneValue(this._mad);
+    }
+    get qb64b() {
+        return this.raw.slice();
+    }
+    get qb64() {
+        return t(this.raw);
+    }
+    get qb2() {
+        if (this.kind !== "CESR") {
+            throw new SerializeError(`Binary domain undefined for non-native kind=${this.kind}`);
+        }
+        return codeB64ToB2(this.qb64);
+    }
+    get said() {
+        const label = Object.keys(this.saids)[0];
+        const value = this._mad[label];
+        return typeof value === "string" ? value : null;
+    }
+    get size() {
+        return this.raw.length;
+    }
+}
+/**
+ * Parse map-style native bodies/counters into a semantic `Mapper`.
+ *
+ * Compatibility wrapper: existing parser-oriented tests can keep calling this
+ * helper, while newer code can instantiate `Mapper` directly from `mad` or
+ * raw. This wrapper preserves the older parser-friendly feel while the class
+ * itself is the new semantic authority.
  */
 export function parseMapperBody(input, version, domain) {
     let syntax;
@@ -192,9 +761,8 @@ export function parseMapperBody(input, version, domain) {
         }
         throw error;
     }
-    let fields;
     try {
-        fields = interpretMapperBodySyntax(syntax);
+        interpretMapperBodySyntax(syntax);
     }
     catch (error) {
         if (error instanceof SemanticInterpretationError) {
@@ -202,15 +770,24 @@ export function parseMapperBody(input, version, domain) {
         }
         throw error;
     }
-    return {
-        code: syntax.code,
-        count: syntax.count,
-        fullSize: syntax.fullSize,
-        fullSizeB2: syntax.fullSizeB2,
-        totalSize: syntax.totalSize,
-        totalSizeB2: syntax.totalSizeB2,
-        fields,
-    };
+    const mapper = new Mapper({
+        mad: {},
+        strict: true,
+        kind: "CESR",
+        verify: false,
+    });
+    mapper.code = syntax.code;
+    mapper.count = syntax.count;
+    mapper.fullSize = syntax.fullSize;
+    mapper.fullSizeB2 = syntax.fullSizeB2;
+    mapper.totalSize = syntax.totalSize;
+    mapper.totalSizeB2 = syntax.totalSizeB2;
+    mapper.fields = interpretMapperBodySyntax(syntax);
+    mapper.raw = domain === "txt"
+        ? input.slice(0, syntax.totalSize)
+        : canonicalizeNativeRaw(input, version).slice(0, syntax.totalSize);
+    mapper._mad = {};
+    return mapper;
 }
 /** True for counter codes that represent map/list-native aggregate primitives. */
 export function isMapperCounterCode(code) {