cesr-ts 0.3.1 → 0.4.0

package/README.md

@@ -18,7 +18,7 @@ const parser = createParser();
 const out = parser.feed(new TextEncoder().encode("...CESR..."));
 const last = parser.flush();
 
-const text = '{"v":"KERI10JSON00002e_","t":"rpy","d":"Eabc"}';
+const text = "{\"v\":\"KERI10JSON00002e_\",\"t\":\"rpy\",\"d\":\"Eabc\"}";
 const annotated = annotate(text, { domainHint: "txt", pretty: true });
 ```
 
@@ -61,5 +61,5 @@ tufa annotate --in mystream.cesr --pretty
 
 ## License
 
-Licensed under the Apache License, Version 2.0 (`Apache-2.0`). See the
-top-level `LICENSE` file in this repository.
+Licensed under the Apache License, Version 2.0 (`Apache-2.0`). See the top-level
+`LICENSE` file in this repository.

package/esm/src/annotate/annotator.js

@@ -1,5 +1,6 @@
+import { b } from "../core/bytes.js";
 import { parseBytes } from "../core/parser-engine.js";
-import { renderAnnotatedFrames, renderWrapperAnnotatedStream, } from "./render.js";
+import { renderAnnotatedFrames, renderWrapperAnnotatedStream } from "./render.js";
 const DEFAULT_OPTIONS = Object.freeze({
     commentMode: "inline",
     indent: 2,
@@ -26,17 +27,13 @@ function parsedFramesOrThrow(frames) {
 }
 export function annotateFrames(input, options) {
     const opts = resolveOptions(options);
-    const bytes = typeof input === "string"
-        ? new TextEncoder().encode(input)
-        : input;
+    const bytes = typeof input === "string" ? b(input) : input;
     const frames = parsedFramesOrThrow(parseBytes(bytes));
     return renderAnnotatedFrames(frames, opts);
 }
 export function annotate(input, options) {
     const opts = resolveOptions(options);
-    const bytes = typeof input === "string"
-        ? new TextEncoder().encode(input)
-        : input;
+    const bytes = typeof input === "string" ? b(input) : input;
     const wrapperAnnotated = renderWrapperAnnotatedStream(bytes, opts);
     if (wrapperAnnotated !== null) {
         return wrapperAnnotated;

package/esm/src/annotate/comments.js

@@ -1,6 +1,6 @@
+import { resolveCounterCodeNameTable } from "../tables/counter-version-registry.js";
 import { COUNTER_CODE_NAMES_V1, COUNTER_CODE_NAMES_V2, } from "../tables/counter.tables.generated.js";
 import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
-import { resolveCounterCodeNameTable } from "../tables/counter-version-registry.js";
 const NATIVE_FIELD_LABELS = Object.freeze({
     v: "version string",
     t: "ilk",

package/esm/src/annotate/render.js

@@ -1,14 +1,15 @@
-import { parseBytes } from "../core/parser-engine.js";
+import { b64ToInt, intToB64 } from "../core/bytes.js";
 import { DeserializeError, GroupSizeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
+import { parseBytes } from "../core/parser-engine.js";
 import { sniff } from "../parser/cold-start.js";
-import { parseCounter } from "../primitives/counter.js";
-import { parseMatter } from "../primitives/matter.js";
-import { parseIndexer } from "../primitives/indexer.js";
 import { parseAttachmentDispatchCompat } from "../parser/group-dispatch.js";
+import { Counter, parseCounter } from "../primitives/counter.js";
+import { Indexer } from "../primitives/indexer.js";
+import { Matter, parseMatter } from "../primitives/matter.js";
+import { isCounterGroupLike, isPrimitiveTuple } from "../primitives/primitive.js";
+import { UnknownPrimitive } from "../primitives/unknown.js";
 import { counterCodeName, counterCodeNameForVersion, matterCodeName, nativeLabelName, } from "./comments.js";
-import { b64ToInt, intToB64 } from "../core/bytes.js";
 const TEXT_DECODER = new TextDecoder();
-const TEXT_ENCODER = new TextEncoder();
 const OPAQUE_TOKEN_COMMENT = "opaque token";
 const OPAQUE_WRAPPER_PAYLOAD_COMMENT = "opaque wrapper payload";
 const WRAPPER_GROUP_NAMES = new Set([
@@ -27,10 +28,10 @@ function toHex(bytes) {
     return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function isRecoverableParseError(error) {
-    return error instanceof UnknownCodeError ||
-        error instanceof DeserializeError ||
-        error instanceof ShortageError ||
-        error instanceof GroupSizeError;
+    return error instanceof UnknownCodeError
+        || error instanceof DeserializeError
+        || error instanceof ShortageError
+        || error instanceof GroupSizeError;
 }
 function spaces(count) {
     return " ".repeat(Math.max(0, count));
@@ -58,51 +59,6 @@ function emitLine(lines, value, comment, indent, options) {
     }
     lines.push(`${pad}${value} # ${comment}`);
 }
-function describeToken(token, domain, version) {
-    const input = TEXT_ENCODER.encode(token);
-    try {
-        const counter = parseCounter(input, version, domain);
-        return {
-            comment: `${counterCodeNameForVersion(counter.code, version)} counter`,
-            size: domain === "bny" ? counter.fullSizeB2 : counter.fullSize,
-        };
-    }
-    catch (error) {
-        if (!isRecoverableParseError(error)) {
-            throw error;
-        }
-        // Try indexer/matter below.
-    }
-    try {
-        const indexer = parseIndexer(input, domain);
-        return {
-            comment: `Indexer ${indexer.code}`,
-            size: domain === "bny" ? indexer.fullSizeB2 : indexer.fullSize,
-        };
-    }
-    catch (error) {
-        if (!isRecoverableParseError(error)) {
-            throw error;
-        }
-        // Try matter below.
-    }
-    try {
-        const matter = parseMatter(input, domain);
-        return {
-            comment: matterCodeName(matter.code),
-            size: domain === "bny" ? matter.fullSizeB2 : matter.fullSize,
-        };
-    }
-    catch (error) {
-        if (!isRecoverableParseError(error)) {
-            throw error;
-        }
-        return {
-            comment: OPAQUE_TOKEN_COMMENT,
-            size: token.length,
-        };
-    }
-}
 function parseCounterCompat(input, version, domain) {
     try {
         return parseCounter(input, version, domain);
@@ -130,25 +86,35 @@ function decodeVersionCounter(counter) {
 }
 function renderGroupItems(lines, items, version, indent, options) {
     for (const item of items) {
-        if (item.kind === "qb64") {
-            const parsed = describeToken(item.qb64, "txt", version);
-            const comment = item.opaque
-                ? OPAQUE_WRAPPER_PAYLOAD_COMMENT
-                : parsed.comment;
-            emitLine(lines, item.qb64, comment, indent, options);
+        if (isPrimitiveTuple(item)) {
+            renderGroupItems(lines, item, version, indent + options.indent, options);
             continue;
         }
-        if (item.kind === "qb2") {
-            emitLine(lines, `0x${toHex(item.qb2)}`, item.opaque ? OPAQUE_WRAPPER_PAYLOAD_COMMENT : "raw qb2 triplet token", indent, options);
+        if (isCounterGroupLike(item)) {
+            emitLine(lines, item.qb64, `${item.name} nested group`, indent, options);
+            renderGroupItems(lines, [...item.items], version, indent + options.indent, options);
             continue;
         }
-        if (item.kind === "tuple") {
-            renderGroupItems(lines, item.items, version, indent + options.indent, options);
+        if (item instanceof UnknownPrimitive) {
+            const value = item.sourceDomain === "bny"
+                ? `0x${toHex(item.qb2)}`
+                : item.qb64;
+            emitLine(lines, value, OPAQUE_WRAPPER_PAYLOAD_COMMENT, indent, options);
             continue;
         }
-        if (item.kind === "group") {
-            emitLine(lines, `${item.code}`, `${item.name} nested group`, indent, options);
+        if (item instanceof Counter) {
+            emitLine(lines, item.qb64, `${counterCodeNameForVersion(item.code, version)} counter`, indent, options);
+            continue;
         }
+        if (item instanceof Indexer) {
+            emitLine(lines, item.qb64, `Indexer ${item.code}`, indent, options);
+            continue;
+        }
+        if (item instanceof Matter) {
+            emitLine(lines, item.qb64, matterCodeName(item.code), indent, options);
+            continue;
+        }
+        emitLine(lines, String(item), OPAQUE_TOKEN_COMMENT, indent, options);
     }
 }
 function renderAttachmentGroupRaw(lines, raw, version, indent, options) {
@@ -212,18 +178,43 @@ function renderNativeBody(lines, frame, options, version) {
     }
     const counter = parseCounterCompat(raw, version, domain);
     emitLine(lines, counter.qb64, `${counterCodeNameForVersion(counter.code, version)} count=${counter.count}`, 0, options);
-    for (const field of frame.body.native?.fields ?? []) {
-        const label = nativeLabelName(field.label);
-        const comment = label
-            ? `${label} (${matterCodeName(field.code)})`
-            : matterCodeName(field.code);
-        emitLine(lines, field.qb64, comment, options.indent, options);
+    const unit = domain === "bny" ? 3 : 4;
+    const headerSize = domain === "bny" ? counter.fullSizeB2 : counter.fullSize;
+    const payloadSize = counter.count * unit;
+    const end = Math.min(raw.length, headerSize + payloadSize);
+    let offset = headerSize;
+    while (offset < end) {
+        const slice = raw.slice(offset, end);
+        try {
+            const nestedCounter = parseCounterCompat(slice, version, domain);
+            const nestedCounterSize = domain === "bny"
+                ? nestedCounter.fullSizeB2
+                : nestedCounter.fullSize;
+            emitLine(lines, nestedCounter.qb64, `${counterCodeNameForVersion(nestedCounter.code, version)} counter`, options.indent, options);
+            offset += nestedCounterSize;
+            continue;
+        }
+        catch (error) {
+            if (!isRecoverableParseError(error)) {
+                throw error;
+            }
+        }
+        const matter = parseMatter(slice, domain);
+        const matterSize = domain === "bny" ? matter.fullSizeB2 : matter.fullSize;
+        const field = frame.body.native?.fields.find((candidate) => candidate.primitive.qb64 === matter.qb64);
+        const label = field ? nativeLabelName(field.label) : null;
+        const primitiveComment = matter instanceof Indexer
+            ? `Indexer ${matter.code}`
+            : matterCodeName(matter.code);
+        const comment = label ? `${label} (${primitiveComment})` : primitiveComment;
+        emitLine(lines, matter.qb64, comment, options.indent, options);
+        offset += matterSize;
     }
 }
 function renderMessageBody(lines, frame, options) {
     const rawBody = TEXT_DECODER.decode(frame.body.raw);
-    const isOpaqueCesrBody = frame.body.kind === "CESR" &&
-        frame.body.ked === null;
+    const isOpaqueCesrBody = frame.body.kind === "CESR"
+        && frame.body.ked === null;
     if (isOpaqueCesrBody) {
         emitLine(lines, rawBody, `OPAQUE CESR body (non-serder fallback, hex=${toHex(frame.body.raw)})`, 0, options);
         return;

package/esm/src/core/bytes.js

@@ -56,6 +56,10 @@ export function decodeB64(text) {
     }
     return out;
 }
+/**
+ * Symmetric ceiling function
+ * @param value
+ */
 export function sceil(value) {
     return Math.ceil(value);
 }
@@ -74,3 +78,46 @@ export function codeB2ToB64(bytes, sextets) {
 export function nabSextets(bytes, sextets) {
     return codeB64ToB2(codeB2ToB64(bytes, sextets));
 }
+/** UTF-8 string -> bytes helper. */
+export const b = (t) => encoder.encode(t);
+/** UTF-8 bytes -> string helper. */
+export const t = (b) => decoder.decode(b);
+/**
+ * Normalize lmdb-js key/value payloads to `Uint8Array`.
+ * Example: converts Node `Buffer`-like values from `getRange()`.
+ */
+export function toBytes(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    return new Uint8Array(value);
+}
+/**
+ * Format number as 32-char hex string, zero padded.
+ * @param num
+ */
+export const to32CharHex = (num) => {
+    return num
+        .toString(16)
+        .padStart(32, "0");
+};
+/** Constant-time-ish byte equality for small DB keys/values. */
+export function bytesEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let i = 0; i < left.length; i++) {
+        if (left[i] !== right[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Stable hex fingerprint used for set-membership dedupe of binary values. */
+export function bytesHex(value) {
+    // deno-fmt-ignore
+    return Array.from(value)
+        .map((byte) => byte.toString(16)
+        .padStart(2, "0"))
+        .join("");
+}

package/esm/src/core/cbor.js

@@ -0,0 +1,122 @@
+import { Decoder } from "cbor-x/decode";
+import { Encoder } from "cbor-x/encode";
+/**
+ * Normalize encoder output to a plain `Uint8Array`.
+ *
+ * `cbor-x` may return subclasses or reused backing buffers depending on the
+ * runtime and code path. The shared KERI codec deliberately copies the result
+ * so callers see a stable, plain `Uint8Array` contract that is safe to compare,
+ * persist, and hand across package boundaries without inheriting library
+ * implementation details.
+ */
+function normalizeEncodedBytes(bytes) {
+    return new Uint8Array(bytes);
+}
+/**
+ * Reject JavaScript `Map` values anywhere in the payload graph.
+ *
+ * This is not a statement about CBOR in general. CBOR absolutely supports map
+ * values. The narrower rule here is about KERI/ACDC parity: KERIpy serializes
+ * the same semantic payloads through JSON, MGPK, and CBOR, and the CBOR paths
+ * we are mirroring are dict/list shaped rather than "generic CBOR" shaped.
+ *
+ * In TypeScript, allowing `Map` values would silently widen the contract past
+ * what the JSON and MGPK paths can represent and past what KERIpy currently
+ * exercises in the mirrored protocol/storage serializers. This guard fails
+ * early so parity drift becomes an explicit decision instead of an accidental
+ * convenience.
+ *
+ * The walk is cycle-safe because this function is defensive validation, not a
+ * serializer in its own right. Cycles would fail later in the encoder anyway,
+ * but we avoid infinite recursion here while still checking the reachable graph
+ * for `Map` instances.
+ */
+function assertNoMapValues(value, seen = new Set()) {
+    if (value === null || typeof value !== "object") {
+        return;
+    }
+    if (value instanceof Map) {
+        throw new TypeError("KERI/ACDC CBOR payloads must use JSON-compatible plain objects/arrays, not JavaScript Map.");
+    }
+    if (seen.has(value)) {
+        return;
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertNoMapValues(item, seen);
+        }
+        return;
+    }
+    for (const item of Object.values(value)) {
+        assertNoMapValues(item, seen);
+    }
+}
+/**
+ * Canonical KERI/ACDC CBOR encoder configuration.
+ *
+ * Two choices matter for parity:
+ * - `useRecords: false` disables `cbor-x` record extensions so plain objects
+ *   stay plain maps on the wire, matching KERIpy's `cbor2` behavior.
+ * - `variableMapSize: true` forces preferred-size map headers, avoiding the
+ *   default `map16` preallocation strategy that broke exact byte parity.
+ *
+ * We import `Encoder` from `cbor-x/encode` rather than the package root because
+ * the root Node entrypoint probes `process.env` during module evaluation. That
+ * widened Deno test permissions for no KERI value, so the shared codec avoids
+ * that entrypoint on purpose.
+ */
+const keriCborEncoder = new Encoder({
+    useRecords: false,
+    variableMapSize: true,
+});
+/**
+ * Canonical KERI/ACDC CBOR decoder configuration.
+ *
+ * `mapsAsObjects: true` keeps decoded values aligned with the JSON-compatible
+ * object/list contract enforced by `encodeKeriCbor()`. This prevents the decode
+ * side from reintroducing `Map`-typed semantics that the encode side forbids
+ * and keeps protocol/storage callers working with the same value shapes they
+ * would see from JSON or MGPK decoding.
+ *
+ * Like the encoder, this uses the `cbor-x/decode` subpath to avoid the package
+ * root's Node-oriented environment probe.
+ */
+const keriCborDecoder = new Decoder({
+    useRecords: false,
+    mapsAsObjects: true,
+});
+/**
+ * Encode KERI/ACDC CBOR with the same preferred map-size choices as KERIpy's
+ * `cbor2.dumps`.
+ *
+ * This is a protocol/storage codec for KERI/ACDC payloads, not a generic CBOR
+ * helper. KERIpy's corresponding emitters serialize dict/list-shaped data
+ * through `cbor2.dumps`, for example:
+ * - `keri.core.coring.dumps`
+ * - `keri.core.serdering.Serder.dumps`
+ * - `keri.db.koming.Komer.__serializeCBOR`
+ *
+ * The same semantic payloads also serialize as JSON and MGPK in KERIpy, so the
+ * intended cross-format contract is JSON-compatible plain objects and arrays.
+ * The default `cbor-x` encoder intentionally uses fixed-width `map16` headers
+ * for plain JS objects so it can preallocate and patch in the size later. That
+ * is valid CBOR but not byte-identical to KERIpy. This helper enables
+ * `variableMapSize` so small maps use the same compact headers that `cbor2`
+ * emits and rejects `Map` values so we do not silently drift into a broader
+ * CBOR type contract than KERIpy currently uses.
+ */
+export function encodeKeriCbor(value) {
+    assertNoMapValues(value);
+    return normalizeEncodedBytes(keriCborEncoder.encode(value));
+}
+/**
+ * Decode KERI/ACDC CBOR into plain JS objects/arrays.
+ *
+ * This keeps the decoder aligned with the encoder policy surface and avoids
+ * record-extension or `Map`-typed decode behavior on KERI/ACDC protocol and
+ * storage paths.
+ */
+export function decodeKeriCbor(raw) {
+    return keriCborDecoder.decode(raw);
+}

package/esm/src/core/errors.js

@@ -1,3 +1,10 @@
+/**
+ * Base parser failure carrying optional offset/context for maintainer
+ * diagnostics.
+ *
+ * Subclasses identify which parser phase rejected the input so callers can
+ * decide whether to recover, retry, or fail hard.
+ */
 export class ParserError extends Error {
     constructor(message, offset, context) {
         super(message);
@@ -16,6 +23,7 @@ export class ParserError extends Error {
         this.name = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).name;
     }
 }
+/** Input ended before the parser had enough bytes to complete the current unit. */
 export class ShortageError extends ParserError {
     constructor(needed, available, offset) {
         super(`Need ${needed} bytes but only ${available} available`, offset);
@@ -33,14 +41,19 @@ export class ShortageError extends ParserError {
         });
     }
 }
+/** Parser encountered an invalid cold-start selector. */
 export class ColdStartError extends ParserError {
 }
+/** Version framing or version-table selection failed. */
 export class VersionError extends ParserError {
 }
+/** A CESR code selector was not recognized in the active codex. */
 export class UnknownCodeError extends ParserError {
 }
+/** Group/count metadata could not describe a valid parse shape. */
 export class GroupSizeError extends ParserError {
 }
+/** Qualified input could not be deserialized into a valid CESR payload. */
 export class DeserializeError extends ParserError {
 }
 /** Failure while constructing syntax artifacts from token bytes. */

package/esm/src/core/parser-attachment-collector.js

@@ -34,8 +34,7 @@ export class AttachmentCollector {
             value: void 0
         });
         this.frameBoundaryPolicy = options.frameBoundaryPolicy;
-        this.attachmentVersionFallbackPolicy =
-            options.attachmentVersionFallbackPolicy;
+        this.attachmentVersionFallbackPolicy = options.attachmentVersionFallbackPolicy;
         this.recoveryDiagnosticObserver = options.recoveryDiagnosticObserver;
         this.isFrameBoundaryAhead = options.isFrameBoundaryAhead;
     }

package/esm/src/core/parser-engine.js

@@ -1,11 +1,11 @@
 import { createAttachmentVersionFallbackPolicy, } from "../parser/group-dispatch.js";
 import { ParserError, ShortageError } from "./errors.js";
+import { AttachmentCollector } from "./parser-attachment-collector.js";
 import { DEFAULT_VERSION } from "./parser-constants.js";
-import { ParserStreamState } from "./parser-stream-state.js";
 import { DeferredFrameLifecycle } from "./parser-deferred-frames.js";
 import { FrameParser } from "./parser-frame-parser.js";
-import { AttachmentCollector } from "./parser-attachment-collector.js";
-import { createFrameBoundaryPolicy, } from "./parser-policy.js";
+import { createFrameBoundaryPolicy } from "./parser-policy.js";
+import { ParserStreamState } from "./parser-stream-state.js";
 import { composeRecoveryDiagnosticObserver, } from "./recovery-diagnostics.js";
 /**
  * Streaming CESR parser for message-domain and CESR-native body-group streams.
@@ -60,16 +60,16 @@ export class CesrParser {
             writable: true,
             value: void 0
         });
-        this.frameBoundaryPolicy = options.frameBoundaryPolicy ??
-            createFrameBoundaryPolicy(options.framed ?? false);
+        this.frameBoundaryPolicy = options.frameBoundaryPolicy
+            ?? createFrameBoundaryPolicy(options.framed ?? false);
         this.recoveryDiagnosticObserver = composeRecoveryDiagnosticObserver({
             onRecoveryDiagnostic: options.onRecoveryDiagnostic,
             onAttachmentVersionFallback: options.attachmentVersionFallbackPolicy
                 ? undefined
                 : options.onAttachmentVersionFallback,
         });
-        const attachmentVersionFallbackPolicy = options.attachmentVersionFallbackPolicy ??
-            createAttachmentVersionFallbackPolicy({
+        const attachmentVersionFallbackPolicy = options.attachmentVersionFallbackPolicy
+            ?? createAttachmentVersionFallbackPolicy({
                 mode: options.attachmentDispatchMode,
             });
         this.stream = new ParserStreamState(DEFAULT_VERSION);

package/esm/src/core/parser-frame-parser.js

@@ -3,8 +3,8 @@ import { sniff } from "../parser/cold-start.js";
 import { parseCounter } from "../primitives/counter.js";
 import { parseIlker } from "../primitives/ilker.js";
 import { isLabelerCode, parseLabeler } from "../primitives/labeler.js";
-import { parseMatter } from "../primitives/matter.js";
 import { interpretMapperBodySyntax, parseMapperBodySyntax, } from "../primitives/mapper.js";
+import { parseMatter } from "../primitives/matter.js";
 import { parseVerser } from "../primitives/verser.js";
 import { reapSerder } from "../serder/serdery.js";
 import { Kinds, Protocols } from "../tables/versions.js";
@@ -46,8 +46,7 @@ export class FrameParser {
             value: void 0
         });
         this.frameBoundaryPolicy = options.frameBoundaryPolicy;
-        this.attachmentVersionFallbackPolicy =
-            options.attachmentVersionFallbackPolicy;
+        this.attachmentVersionFallbackPolicy = options.attachmentVersionFallbackPolicy;
         this.onEnclosedFrames = options.onEnclosedFrames;
         this.recoveryDiagnosticObserver = options.recoveryDiagnosticObserver;
     }
@@ -432,9 +431,9 @@ export class FrameParser {
             };
         }
         catch (error) {
-            if (error instanceof ShortageError ||
-                error instanceof UnknownCodeError ||
-                error instanceof DeserializeError) {
+            if (error instanceof ShortageError
+                || error instanceof UnknownCodeError
+                || error instanceof DeserializeError) {
                 throw new SyntaxParseError(`Native body syntax parse failed: ${error.message}`, error);
             }
             throw error;
@@ -499,8 +498,7 @@ export class FrameParser {
                 const size = tokenSize(ctr, cold);
                 entries.push({
                     kind: "value",
-                    code: ctr.code,
-                    qb64: ctr.qb64,
+                    primitive: ctr,
                 });
                 offset += size;
                 continue;
@@ -512,15 +510,13 @@ export class FrameParser {
                 entries.push({
                     kind: "label",
                     label: parseLabeler(at, cold).label,
-                    code: token.code,
-                    qb64: token.qb64,
+                    primitive: token,
                 });
                 continue;
             }
             entries.push({
                 kind: "value",
-                code: token.code,
-                qb64: token.qb64,
+                primitive: token,
             });
         }
         if (offset !== end) {
@@ -534,8 +530,7 @@ export class FrameParser {
             try {
                 return interpretMapperBodySyntax(syntax.mapper).map((field) => ({
                     label: field.label,
-                    code: field.code,
-                    qb64: field.qb64,
+                    primitive: field.primitive,
                 }));
             }
             catch (error) {
@@ -554,8 +549,7 @@ export class FrameParser {
             }
             out.push({
                 label: pendingLabel,
-                code: entry.code,
-                qb64: entry.qb64,
+                primitive: entry.primitive,
             });
             pendingLabel = null;
         }
@@ -591,8 +585,8 @@ export class FrameParser {
                 if (error instanceof ShortageError) {
                     throw error;
                 }
-                if (error instanceof UnknownCodeError ||
-                    error instanceof DeserializeError) {
+                if (error instanceof UnknownCodeError
+                    || error instanceof DeserializeError) {
                     continue;
                 }
                 throw error;
@@ -622,8 +616,8 @@ export class FrameParser {
                 if (error instanceof ShortageError) {
                     throw error;
                 }
-                if (error instanceof UnknownCodeError ||
-                    error instanceof DeserializeError) {
+                if (error instanceof UnknownCodeError
+                    || error instanceof DeserializeError) {
                     if (!firstError) {
                         firstError = error;
                     }