cesr-ts 0.2.3 → 0.3.1

package/esm/src/primitives/counter.js

@@ -1,16 +1,15 @@
 import { b64ToInt, codeB2ToB64, codeB64ToB2, nabSextets, sceil, } from "../core/bytes.js";
 import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
-import { COUNTER_CODE_NAMES_V1, COUNTER_CODE_NAMES_V2, COUNTER_HARDS, COUNTER_SIZES_V1, COUNTER_SIZES_V2, } from "../tables/counter.tables.generated.js";
+import { COUNTER_HARDS } from "../tables/counter.tables.generated.js";
+import { resolveCounterCodeNameTable, resolveCounterSizeTable, } from "../tables/counter-version-registry.js";
 const COUNTER_BARDS = new Map([...COUNTER_HARDS.entries()].map(([code, hs]) => [
     String.fromCharCode(codeB64ToB2(code)[0]) +
         String.fromCharCode(codeB64ToB2(code)[1] ?? 0),
     hs,
 ]));
 function getTables(version) {
-    const sizeTable = version.major >= 2 ? COUNTER_SIZES_V2 : COUNTER_SIZES_V1;
-    const nameTable = version.major >= 2
-        ? COUNTER_CODE_NAMES_V2
-        : COUNTER_CODE_NAMES_V1;
+    const sizeTable = resolveCounterSizeTable(version);
+    const nameTable = resolveCounterCodeNameTable(version);
     return { sizeTable, nameTable };
 }
 export function parseCounterFromText(input, version) {

package/esm/src/primitives/mapper.js

@@ -1,5 +1,5 @@
 import { encodeB64 } from "../core/bytes.js";
-import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
+import { DeserializeError, SemanticInterpretationError, ShortageError, SyntaxParseError, UnknownCodeError, } from "../core/errors.js";
 import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
 import { CtrDexV2 } from "../tables/counter-codex.js";
 import { parseCounter } from "./counter.js";
@@ -27,6 +27,10 @@ function asQb64(raw, domain) {
     return domain === "txt" ? String.fromCharCode(...raw) : encodeB64(raw);
 }
 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 = [
@@ -52,6 +56,7 @@ function parseCounterProbe(input, version, domain) {
     return null;
 }
 function parseLabelProbe(input, domain) {
+    /** Label probe only; non-label parse failures are treated as "not a label". */
     try {
         return parseLabeler(input, domain);
     }
@@ -66,89 +71,165 @@ function parseLabelProbe(input, domain) {
         throw error;
     }
 }
-function parseMapperValue(input, version, 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`.
+     */
     const counter = parseCounterProbe(input, version, domain);
     if (counter) {
         const dispatch = parseAttachmentDispatch(input, version, domain);
         const raw = input.slice(0, dispatch.consumed);
-        const field = {
+        const value = {
+            kind: "value",
             code: dispatch.group.code,
             qb64: asQb64(raw, domain),
             isCounter: true,
+            consumed: dispatch.consumed,
         };
         if (isMapGroupCode(dispatch.group.code)) {
-            const nested = parseMapperBody(input, version, domain);
-            field.children = nested.fields;
+            value.children = parseMapperBodySyntax(input, version, domain);
         }
-        return { field, consumed: dispatch.consumed };
+        return value;
     }
     const matter = parseMatter(input, domain);
     return {
-        field: {
-            code: matter.code,
-            qb64: matter.qb64,
-            isCounter: false,
-        },
+        kind: "value",
+        code: matter.code,
+        qb64: matter.qb64,
+        isCounter: false,
         consumed: tokenSize(matter, domain),
     };
 }
-function parseMapPayload(input, version, domain, start, end) {
-    const fields = [];
+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`.
+     */
+    const entries = [];
     let offset = start;
-    let pendingLabel = null;
     while (offset < end) {
         const at = input.slice(offset, end);
         const maybeLabel = parseLabelProbe(at, domain);
         if (maybeLabel) {
-            pendingLabel = maybeLabel.label;
-            offset += tokenSize(maybeLabel, domain);
+            const consumed = tokenSize(maybeLabel, domain);
+            entries.push({
+                kind: "label",
+                code: maybeLabel.code,
+                qb64: maybeLabel.token,
+                label: maybeLabel.label,
+                consumed,
+            });
+            offset += consumed;
+            continue;
+        }
+        const value = parseMapperValueSyntax(at, version, domain);
+        entries.push(value);
+        offset += value.consumed;
+    }
+    if (offset !== end) {
+        throw new ShortageError(end, offset);
+    }
+    return entries;
+}
+/** Convert syntax entries into labeled semantic map fields. */
+export function interpretMapperBodySyntax(syntax) {
+    const fields = [];
+    let pendingLabel = null;
+    for (const entry of syntax.entries) {
+        if (entry.kind === "label") {
+            pendingLabel = entry.label;
             continue;
         }
-        const { field, consumed } = parseMapperValue(at, version, domain);
         fields.push({
             label: pendingLabel,
-            code: field.code,
-            qb64: field.qb64,
-            isCounter: field.isCounter,
-            children: field.children,
+            code: entry.code,
+            qb64: entry.qb64,
+            isCounter: entry.isCounter,
+            children: entry.children
+                ? interpretMapperBodySyntax(entry.children)
+                : undefined,
         });
         pendingLabel = null;
-        offset += consumed;
-    }
-    if (offset !== end) {
-        throw new ShortageError(end, offset);
     }
     if (pendingLabel !== null) {
-        throw new UnknownCodeError("Dangling map label without value");
+        throw new SemanticInterpretationError("Dangling map label without value");
     }
     return fields;
 }
+/**
+ * Parse map-style native bodies/counters into syntax artifacts.
+ * Parsing is strict: payload boundaries must be exact.
+ */
+export function parseMapperBodySyntax(input, version, domain) {
+    try {
+        const counter = parseCounter(input, version, domain);
+        if (!isMapGroupCode(counter.code)) {
+            throw new UnknownCodeError(`Expected map-body/group counter, got ${counter.code}`);
+        }
+        const unit = domain === "bny" ? 3 : 4;
+        const header = tokenSize(counter, domain);
+        const payload = counter.count * unit;
+        const total = header + payload;
+        if (input.length < total) {
+            throw new ShortageError(total, input.length);
+        }
+        const entries = parseMapPayloadSyntax(input, version, domain, header, total);
+        return {
+            code: counter.code,
+            count: counter.count,
+            fullSize: counter.fullSize,
+            fullSizeB2: counter.fullSizeB2,
+            totalSize: domain === "txt" ? total : Math.ceil(total * 4 / 3),
+            totalSizeB2: domain === "bny" ? total : Math.ceil(total * 3 / 4),
+            entries,
+        };
+    }
+    catch (error) {
+        if (error instanceof ShortageError ||
+            error instanceof UnknownCodeError ||
+            error instanceof DeserializeError) {
+            throw new SyntaxParseError(`Map-body syntax parse failed: ${error.message}`, error);
+        }
+        throw error;
+    }
+}
 /**
  * Parse map-style native bodies/counters into labeled semantic fields.
- * Parsing is strict: payload boundaries and label/value pairing must be exact.
+ * Compatibility wrapper over syntax parsing + semantic interpretation phases.
  */
 export function parseMapperBody(input, version, domain) {
-    // Mapper is intentionally strict: payload boundaries must be exact and
-    // labels cannot be left dangling without a value.
-    const counter = parseCounter(input, version, domain);
-    if (!isMapGroupCode(counter.code)) {
-        throw new UnknownCodeError(`Expected map-body/group counter, got ${counter.code}`);
+    let syntax;
+    try {
+        syntax = parseMapperBodySyntax(input, version, domain);
     }
-    const unit = domain === "bny" ? 3 : 4;
-    const header = tokenSize(counter, domain);
-    const payload = counter.count * unit;
-    const total = header + payload;
-    if (input.length < total) {
-        throw new ShortageError(total, input.length);
+    catch (error) {
+        if (error instanceof SyntaxParseError && error.cause) {
+            throw error.cause;
+        }
+        throw error;
+    }
+    let fields;
+    try {
+        fields = interpretMapperBodySyntax(syntax);
+    }
+    catch (error) {
+        if (error instanceof SemanticInterpretationError) {
+            throw new UnknownCodeError(error.message);
+        }
+        throw error;
     }
-    const fields = parseMapPayload(input, version, domain, header, total);
     return {
-        code: counter.code,
-        count: counter.count,
-        fullSize: counter.fullSize,
-        fullSizeB2: counter.fullSizeB2,
-        totalSize: domain === "txt" ? total : Math.ceil(total * 4 / 3),
-        totalSizeB2: domain === "bny" ? total : Math.ceil(total * 3 / 4),
+        code: syntax.code,
+        count: syntax.count,
+        fullSize: syntax.fullSize,
+        fullSizeB2: syntax.fullSizeB2,
+        totalSize: syntax.totalSize,
+        totalSizeB2: syntax.totalSizeB2,
         fields,
     };
 }

package/esm/src/primitives/matter.js

@@ -26,7 +26,7 @@ function parseMatterCodeFromText(txt) {
 export function parseMatterFromText(input) {
     const txt = String.fromCharCode(...input);
     if (txt.length === 0) {
-        throw new DeserializeError("Empty matter input");
+        throw new ShortageError(1, 0);
     }
     const { code } = parseMatterCodeFromText(txt);
     const sizage = MATTER_SIZES.get(code);

package/esm/src/router/router-stub.js

@@ -1,16 +1,16 @@
 export function createRouterStub(handlers = {}) {
     return {
-        async route(frame) {
-            if (frame.serder.proto === "KERI" && handlers.onKeri) {
-                await handlers.onKeri(frame);
+        async route(message) {
+            if (message.body.proto === "KERI" && handlers.onKeri) {
+                await handlers.onKeri(message);
                 return;
             }
-            if (frame.serder.proto === "ACDC" && handlers.onAcdc) {
-                await handlers.onAcdc(frame);
+            if (message.body.proto === "ACDC" && handlers.onAcdc) {
+                await handlers.onAcdc(message);
                 return;
             }
             if (handlers.onUnknown) {
-                await handlers.onUnknown(frame);
+                await handlers.onUnknown(message);
             }
         },
     };

package/esm/src/serder/serder.js

@@ -1,22 +1,59 @@
 import { DeserializeError } from "../core/errors.js";
+import { decode as decodeMsgpack } from "@msgpack/msgpack";
+import { decode as decodeCbor } from "cbor-x/decode";
+function normalizeDecodedMap(value, kind) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        if (value instanceof Map) {
+            const out = {};
+            for (const [k, v] of value.entries()) {
+                if (typeof k !== "string") {
+                    throw new DeserializeError(`${kind} map key must be a string`);
+                }
+                out[k] = v;
+            }
+            return out;
+        }
+        return value;
+    }
+    throw new DeserializeError(`${kind} root must be a map/object`);
+}
+// TODO should this be called parseBody?
+//   If we're going to say parseSerder then it should doo a full deserialization
+//   and the CesrBody should be a Serder with subclasses for SerderKERI and SerderACDC
 export function parseSerder(raw, smellage) {
     const { proto, kind, pvrsn, gvrsn, size } = smellage;
     let ked = null;
     let ilk = null;
     let said = null;
-    if (kind === "JSON") {
-        const text = new TextDecoder().decode(raw);
-        try {
+    try {
+        if (kind === "JSON") {
+            const text = new TextDecoder().decode(raw);
             ked = JSON.parse(text);
+        }
+        else if (kind === "MGPK") {
+            ked = normalizeDecodedMap(decodeMsgpack(raw), kind);
+        }
+        else if (kind === "CBOR") {
+            ked = normalizeDecodedMap(decodeCbor(raw), kind);
+        }
+        if (ked) {
             ilk = typeof ked.t === "string" ? ked.t : null;
             said = typeof ked.d === "string" ? ked.d : null;
         }
-        catch (error) {
-            if (!(error instanceof SyntaxError)) {
-                throw error;
-            }
+    }
+    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)}`);
         }
+        if (kind === "MGPK" || kind === "CBOR") {
+            throw new DeserializeError(`Failed to decode ${kind} Serder: ${String(error)}`);
+        }
+        throw error;
     }
+    // TODO support SerderKERI and SerderACDC.
+    //   Is that done at this level or the next level up?
     return { raw, ked, proto, kind, size, pvrsn, gvrsn, ilk, said };
 }

package/esm/src/serder/smell.js

@@ -1,6 +1,7 @@
 import { b64ToInt } from "../core/bytes.js";
 import { ShortageError, VersionError } from "../core/errors.js";
-const MAXVSOFFSET = 8;
+// KERIpy parity: allow version token to begin within the first 12 bytes.
+const MAXVSOFFSET = 12;
 const VER1 = /(?<proto1>[A-Z]{4})(?<major1>[0-9a-f])(?<minor1>[0-9a-f])(?<kind1>[A-Z]{4})(?<size1>[0-9a-f]{6})_/;
 const VER2 = /(?<proto2>[A-Z]{4})(?<pmajor2>[A-Za-z0-9_-])(?<pminor2>[A-Za-z0-9_-]{2})(?<gmajor2>[A-Za-z0-9_-])(?<gminor2>[A-Za-z0-9_-]{2})(?<kind2>[A-Z]{4})(?<size2>[A-Za-z0-9_-]{4})\./;
 function byteWindowToText(raw) {

package/esm/src/tables/counter-version-registry.js

@@ -0,0 +1,201 @@
+import { VersionError } from "../core/errors.js";
+import { COUNTER_CODE_NAMES_V1, COUNTER_CODE_NAMES_V2, COUNTER_SIZES_V1, COUNTER_SIZES_V2, } from "./counter.tables.generated.js";
+import { CtrDexV1, CtrDexV2 } from "./counter-codex.js";
+/** Immutable helper for selecting only named codex entries. */
+function pickCodexEntries(codex, names) {
+    const out = {};
+    for (const name of names) {
+        const code = codex[name];
+        if (!code) {
+            throw new Error(`Missing codex entry ${name}`);
+        }
+        out[name] = code;
+    }
+    return Object.freeze(out);
+}
+/** Immutable helper for dropping named codex entries from a codex projection. */
+function omitCodexEntries(codex, omittedNames) {
+    const omitted = new Set(omittedNames);
+    const out = {};
+    for (const [name, code] of Object.entries(codex)) {
+        if (!omitted.has(name)) {
+            out[name] = code;
+        }
+    }
+    return Object.freeze(out);
+}
+/** Return sorted supported minors for one major registry branch. */
+function supportedMinors(registry) {
+    return Object.keys(registry) // minor versions
+        .map((minor) => Number(minor))
+        .sort((a, b) => a - b);
+}
+/**
+ * Resolve a major/minor request to the latest supported compatible minor.
+ *
+ * Semantics match KERIpy parser/codex selection:
+ * - major must be supported
+ * - requested minor must not exceed latest supported minor for that major
+ * - selected value binds to latest supported minor for the major
+ */
+export function resolveVersionedRegistryValue(registry, version, label = "versioned registry") {
+    const byMinor = registry[version.major];
+    if (!byMinor) {
+        throw new VersionError(`Unsupported ${label} major version ${version.major}`);
+    }
+    const minors = supportedMinors(byMinor);
+    if (minors.length === 0) {
+        throw new VersionError(`No supported minors configured for ${label} major ${version.major}`);
+    }
+    const latestMinor = minors[minors.length - 1] ?? 0;
+    if (version.minor > latestMinor) {
+        throw new VersionError(`Unsupported ${label} minor version ${version.major}.${version.minor}; latest supported is ${version.major}.${latestMinor}`);
+    }
+    const value = byMinor[latestMinor];
+    if (!value) {
+        throw new VersionError(`Missing ${label} value for ${version.major}.${latestMinor}`);
+    }
+    return {
+        value,
+        resolvedMajor: version.major,
+        resolvedMinor: latestMinor,
+        latestMinor,
+    };
+}
+const CtrDex_1_0 = omitCodexEntries(CtrDexV1, [
+    "SadPathSig",
+    "SadPathSigGroup",
+]);
+const CtrDex_2_0 = Object.freeze({ ...CtrDexV2 });
+const UniDex_1_0 = pickCodexEntries(CtrDex_1_0, [
+    "GenericGroup",
+    "BigGenericGroup",
+    "BodyWithAttachmentGroup",
+    "BigBodyWithAttachmentGroup",
+    "AttachmentGroup",
+    "BigAttachmentGroup",
+    "NonNativeBodyGroup",
+    "BigNonNativeBodyGroup",
+    "KERIACDCGenusVersion",
+]);
+const UniDex_2_0 = pickCodexEntries(CtrDex_2_0, [
+    "GenericGroup",
+    "BigGenericGroup",
+    "BodyWithAttachmentGroup",
+    "BigBodyWithAttachmentGroup",
+    "AttachmentGroup",
+    "BigAttachmentGroup",
+    "DatagramSegmentGroup",
+    "BigDatagramSegmentGroup",
+    "ESSRWrapperGroup",
+    "BigESSRWrapperGroup",
+    "FixBodyGroup",
+    "BigFixBodyGroup",
+    "MapBodyGroup",
+    "BigMapBodyGroup",
+    "NonNativeBodyGroup",
+    "BigNonNativeBodyGroup",
+    "GenericMapGroup",
+    "BigGenericMapGroup",
+    "GenericListGroup",
+    "BigGenericListGroup",
+    "KERIACDCGenusVersion",
+]);
+const SUDex_1_0 = pickCodexEntries(UniDex_1_0, [
+    "GenericGroup",
+    "BigGenericGroup",
+    "BodyWithAttachmentGroup",
+    "BigBodyWithAttachmentGroup",
+    "AttachmentGroup",
+    "BigAttachmentGroup",
+]);
+const SUDex_2_0 = pickCodexEntries(UniDex_2_0, [
+    "GenericGroup",
+    "BigGenericGroup",
+    "BodyWithAttachmentGroup",
+    "BigBodyWithAttachmentGroup",
+    "AttachmentGroup",
+    "BigAttachmentGroup",
+]);
+const MUDex_1_0 = pickCodexEntries(UniDex_1_0, [
+    "NonNativeBodyGroup",
+    "BigNonNativeBodyGroup",
+]);
+const MUDex_2_0 = pickCodexEntries(UniDex_2_0, [
+    "DatagramSegmentGroup",
+    "BigDatagramSegmentGroup",
+    "ESSRWrapperGroup",
+    "BigESSRWrapperGroup",
+    "FixBodyGroup",
+    "BigFixBodyGroup",
+    "MapBodyGroup",
+    "BigMapBodyGroup",
+    "NonNativeBodyGroup",
+    "BigNonNativeBodyGroup",
+]);
+/** Versioned counter codex registry analogous to KERIpy `Codes`. */
+export const CtrDexByVersion = Object.freeze({
+    1: Object.freeze({ 0: CtrDex_1_0 }),
+    2: Object.freeze({ 0: CtrDex_2_0 }),
+});
+/** Versioned universal codex registry analogous to KERIpy `UniDex`. */
+export const UniDexByVersion = Object.freeze({
+    1: Object.freeze({ 0: UniDex_1_0 }),
+    2: Object.freeze({ 0: UniDex_2_0 }),
+});
+/** Versioned special-universal codex registry analogous to KERIpy `SUDex`. */
+export const SUDexByVersion = Object.freeze({
+    1: Object.freeze({ 0: SUDex_1_0 }),
+    2: Object.freeze({ 0: SUDex_2_0 }),
+});
+/** Versioned message-universal codex registry analogous to KERIpy `MUDex`. */
+export const MUDexByVersion = Object.freeze({
+    1: Object.freeze({ 0: MUDex_1_0 }),
+    2: Object.freeze({ 0: MUDex_2_0 }),
+});
+/** Generated counter size tables indexed by major/minor for parser primitives. */
+export const COUNTER_SIZE_TABLES_BY_VERSION = Object.freeze({
+    1: Object.freeze({ 0: COUNTER_SIZES_V1 }),
+    2: Object.freeze({ 0: COUNTER_SIZES_V2 }),
+});
+/** Generated code-name tables indexed by major/minor for annotation/comments. */
+export const COUNTER_CODE_NAMES_BY_VERSION = Object.freeze({
+    1: Object.freeze({ 0: COUNTER_CODE_NAMES_V1 }),
+    2: Object.freeze({ 0: COUNTER_CODE_NAMES_V2 }),
+});
+/** Explicit compatibility-only alias codes retained for interop continuity. */
+export const LEGACY_COMPAT_COUNTER_CODES_BY_VERSION = Object.freeze({
+    1: Object.freeze({
+        0: new Set([
+            CtrDexV1.SadPathSig,
+            CtrDexV1.SadPathSigGroup,
+        ]),
+    }),
+    2: Object.freeze({
+        0: new Set(),
+    }),
+});
+/** Resolve counter codex for a stream version using latest compatible minor. */
+export function resolveCtrDex(version) {
+    return resolveVersionedRegistryValue(CtrDexByVersion, version, "counter codex").value;
+}
+/** Resolve universal codex for a stream version using latest compatible minor. */
+export function resolveUniDex(version) {
+    return resolveVersionedRegistryValue(UniDexByVersion, version, "universal codex").value;
+}
+/** Resolve special-universal codex for a stream version. */
+export function resolveSUDex(version) {
+    return resolveVersionedRegistryValue(SUDexByVersion, version, "special-universal codex").value;
+}
+/** Resolve message-universal codex for a stream version. */
+export function resolveMUDex(version) {
+    return resolveVersionedRegistryValue(MUDexByVersion, version, "message-universal codex").value;
+}
+/** Resolve generated counter size table for a stream version. */
+export function resolveCounterSizeTable(version) {
+    return resolveVersionedRegistryValue(COUNTER_SIZE_TABLES_BY_VERSION, version, "counter size table").value;
+}
+/** Resolve generated counter name table for a stream version. */
+export function resolveCounterCodeNameTable(version) {
+    return resolveVersionedRegistryValue(COUNTER_CODE_NAMES_BY_VERSION, version, "counter code-name table").value;
+}

package/esm/src/version.js

@@ -2,8 +2,8 @@
  * Generated by scripts/generate_versions.ts.
  * Do not edit by hand.
  */
-export const PACKAGE_VERSION = "0.2.3";
-export const BUILD_METADATA = "build.1.6ec6de39";
+export const PACKAGE_VERSION = "0.3.1";
+export const BUILD_METADATA = "build.3.f47c821b";
 export const DISPLAY_VERSION = BUILD_METADATA
     ? `${PACKAGE_VERSION}+${BUILD_METADATA}`
     : PACKAGE_VERSION;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cesr-ts",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "CESR parser, primitives, and annotation tooling for TypeScript/JavaScript",
   "homepage": "https://github.com/kentbull/keri-ts/tree/main/packages/cesr",
   "repository": {
@@ -46,6 +46,8 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@msgpack/msgpack": "^3.1.2",
+    "cbor-x": "^1.6.0",
     "effection": "^3.6.0"
   },
   "_generatedBy": "dnt@dev"

package/types/_dnt.polyfills.d.ts

@@ -97,5 +97,10 @@ interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyf
 export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
 export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
 export declare let import_meta_ponyfill: ImportMetaPonyfill;
+declare global {
+    interface Error {
+        cause?: unknown;
+    }
+}
 export {};
 //# sourceMappingURL=_dnt.polyfills.d.ts.map

package/types/_dnt.polyfills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC"}
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAgC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,UAAU;QAClB;;;;;;;;;;;;;;WAcG;QACH,GAAG,EAAE,MAAM,CAAC;QACZ;;;;;;;;;;;;WAYG;QACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,CAAC;QACtE;;;;;;;;WAQG;QACH,IAAI,EAAE,OAAO,CAAC;QAEd;;;;;;;;;;;;WAYG;QACH,QAAQ,EAAE,MAAM,CAAC;QAEjB;;;;;;;;;;;;WAYG;QACH,OAAO,EAAE,MAAM,CAAC;KACjB;CACF;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;AACnD,UAAU,0BAA0B;IAClC,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACxD;AACD,UAAU,0BAA0B;IAClC,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;CACtC;AACD,UAAU,kBACR,SAAQ,0BAA0B,EAAE,0BAA0B;CAC/D;AAiBD,eAAO,IAAI,6BAA6B,EA2BnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,6BAA6B,EA4DnC,0BAA0B,CAAC;AAMhC,eAAO,IAAI,oBAAoB,EAoB1B,kBAAkB,CAAC;AACxB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,KAAK;QACb,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CACF;AAED,OAAO,EAAE,CAAC"}

package/types/src/adapters/async-iterable.d.ts

@@ -1,4 +1,4 @@
-import type { CesrFrame } from "../core/types.js";
+import type { CesrMessage } from "../core/types.js";
 import { type ParserOptions } from "../core/parser-engine.js";
-export declare function toAsyncFrames(source: AsyncIterable<Uint8Array>, options?: ParserOptions): AsyncGenerator<CesrFrame>;
+export declare function toAsyncFrames(source: AsyncIterable<Uint8Array>, options?: ParserOptions): AsyncGenerator<CesrMessage>;
 //# sourceMappingURL=async-iterable.d.ts.map

package/types/src/adapters/async-iterable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-iterable.d.ts","sourceRoot":"","sources":["../../../src/src/adapters/async-iterable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE5E,wBAAuB,aAAa,CAClC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,OAAO,GAAE,aAAkB,GAC1B,cAAc,CAAC,SAAS,CAAC,CAe3B"}
+{"version":3,"file":"async-iterable.d.ts","sourceRoot":"","sources":["../../../src/src/adapters/async-iterable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE5E,wBAAuB,aAAa,CAClC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,OAAO,GAAE,aAAkB,GAC1B,cAAc,CAAC,WAAW,CAAC,CAe7B"}

package/types/src/adapters/effection.d.ts

@@ -1,8 +1,8 @@
 import { type Operation } from "effection";
-import type { CesrFrame } from "../core/types.js";
+import type { CesrMessage } from "../core/types.js";
 import type { ParserOptions } from "../core/parser-engine.js";
 export interface FrameChannel {
-    readonly frames: AsyncIterable<CesrFrame>;
+    readonly frames: AsyncIterable<CesrMessage>;
 }
 export declare function toEffectionFrames(source: AsyncIterable<Uint8Array>, options?: ParserOptions): Operation<FrameChannel>;
 //# sourceMappingURL=effection.d.ts.map

package/types/src/adapters/effection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"effection.d.ts","sourceRoot":"","sources":["../../../src/src/adapters/effection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;CAC3C;AAED,wBAAiB,iBAAiB,CAChC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,YAAY,CAAC,CAOzB"}
+{"version":3,"file":"effection.d.ts","sourceRoot":"","sources":["../../../src/src/adapters/effection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;CAC7C;AAED,wBAAiB,iBAAiB,CAChC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,OAAO,GAAE,aAAkB,GAC1B,SAAS,CAAC,YAAY,CAAC,CAOzB"}

package/types/src/annotate/annotator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotator.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/annotator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA6BlE,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,EAAE,CAOlB;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,MAAM,CAGR"}
+{"version":3,"file":"annotator.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/annotator.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA6BlE,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,EAAE,CAOlB;AAED,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,MAAM,CAWR"}

package/types/src/annotate/comments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/comments.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAmB3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,GAClB,MAAM,CAOR;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAGnE"}
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../../../src/src/annotate/comments.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAoB3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,GAClB,MAAM,CAGR;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAGnE"}