cesr-ts 0.1.0

package/esm/src/primitives/ilker.js

@@ -0,0 +1,15 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+export function parseIlker(input, cold) {
+    const matter = parseMatter(input, cold);
+    if (matter.code !== "X") {
+        throw new UnknownCodeError(`Expected ilker code X, got ${matter.code}`);
+    }
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+        ilk: matter.qb64.slice(matter.code.length),
+    };
+}

package/esm/src/primitives/indexer.js

@@ -0,0 +1,84 @@
+import { b64ToInt, codeB2ToB64, codeB64ToB2, decodeB64, nabSextets, sceil, } from "../core/bytes.js";
+import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
+import { INDEXER_HARDS, INDEXER_SIZES } from "../tables/indexer.tables.js";
+const INDEXER_BARDS = new Map([...INDEXER_HARDS.entries()].map(([code, hs]) => [
+    String.fromCharCode(codeB64ToB2(code)[0]),
+    hs,
+]));
+function parseIndexerCodeFromText(txt) {
+    const hs = INDEXER_HARDS.get(txt[0]);
+    if (!hs) {
+        throw new UnknownCodeError(`Unknown indexer hard selector ${txt[0]}`);
+    }
+    const code = txt.slice(0, hs);
+    if (!INDEXER_SIZES.has(code)) {
+        throw new UnknownCodeError(`Unknown indexer code ${code}`);
+    }
+    return { code };
+}
+export function parseIndexerFromText(input) {
+    const txt = String.fromCharCode(...input);
+    if (txt.length === 0) {
+        throw new DeserializeError("Empty indexer input");
+    }
+    const { code } = parseIndexerCodeFromText(txt);
+    const sizage = INDEXER_SIZES.get(code);
+    const cs = sizage.hs + sizage.ss;
+    const soft = txt.slice(sizage.hs, cs);
+    const fullSize = sizage.fs ?? (cs + b64ToInt(soft) * 4);
+    if (txt.length < fullSize) {
+        throw new ShortageError(fullSize, txt.length);
+    }
+    const raw = decodeB64(txt.slice(cs, fullSize)).slice(sizage.ls);
+    return {
+        code,
+        raw,
+        qb64: txt.slice(0, fullSize),
+        fullSize,
+        fullSizeB2: sceil((fullSize * 3) / 4),
+    };
+}
+export function parseIndexerFromBinary(input) {
+    if (input.length === 0) {
+        throw new ShortageError(1, 0);
+    }
+    const first = nabSextets(input, 1);
+    const hs = INDEXER_BARDS.get(String.fromCharCode(first[0]));
+    if (!hs) {
+        throw new UnknownCodeError(`Unsupported qb2 indexer start sextet=0x${first[0].toString(16)}`);
+    }
+    const bhs = sceil((hs * 3) / 4);
+    if (input.length < bhs) {
+        throw new ShortageError(bhs, input.length);
+    }
+    const hard = codeB2ToB64(input, hs);
+    const sizage = INDEXER_SIZES.get(hard);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown indexer code ${hard}`);
+    }
+    const cs = sizage.hs + sizage.ss;
+    const bcs = sceil((cs * 3) / 4);
+    if (input.length < bcs) {
+        throw new ShortageError(bcs, input.length);
+    }
+    const qb64cs = codeB2ToB64(input, cs);
+    const soft = qb64cs.slice(sizage.hs, cs);
+    const fs = sizage.fs ?? ((b64ToInt(soft) * 4) + cs);
+    const bfs = sceil((fs * 3) / 4);
+    if (input.length < bfs) {
+        throw new ShortageError(bfs, input.length);
+    }
+    const qb2 = input.slice(0, bfs);
+    const qb64 = codeB2ToB64(qb2, fs);
+    const raw = decodeB64(qb64.slice(cs)).slice(sizage.ls);
+    return {
+        code: hard,
+        raw,
+        qb64,
+        fullSize: fs,
+        fullSizeB2: bfs,
+    };
+}
+export function parseIndexer(input, cold) {
+    return cold === "bny" ? parseIndexerFromBinary(input) : parseIndexerFromText(input);
+}

package/esm/src/primitives/labeler.js

@@ -0,0 +1,31 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+const TEXT_DECODER = new TextDecoder();
+const LABELER_CODES = new Set(["V", "W"]);
+export function isLabelerCode(code) {
+    return LABELER_CODES.has(code);
+}
+/** Parse a V/W label primitive into decoded map-label metadata. */
+export function parseLabeler(input, cold) {
+    // Labelers are fixed-size matter primitives used as map field keys.
+    const matter = parseMatter(input, cold);
+    if (!isLabelerCode(matter.code)) {
+        throw new UnknownCodeError(`Expected labeler code (V/W), got ${matter.code}`);
+    }
+    let index = 0;
+    for (const b of matter.raw) {
+        index = (index << 8) | b;
+    }
+    const text = TEXT_DECODER.decode(matter.raw).replace(/\u0000/g, "");
+    const label = text.length > 0 ? text : matter.qb64.slice(matter.code.length);
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+        token: matter.qb64,
+        label,
+        index,
+        bytes: matter.raw,
+    };
+}

package/esm/src/primitives/mapper.js

@@ -0,0 +1,158 @@
+import { encodeB64 } from "../core/bytes.js";
+import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
+import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
+import { CtrDexV2 } from "../tables/counter-codex.js";
+import { parseCounter } from "./counter.js";
+import { parseLabeler } from "./labeler.js";
+import { parseMatter } from "./matter.js";
+const MAP_GROUP_CODES = new Set([
+    CtrDexV2.MapBodyGroup,
+    CtrDexV2.BigMapBodyGroup,
+    CtrDexV2.GenericMapGroup,
+    CtrDexV2.BigGenericMapGroup,
+]);
+const LIST_GROUP_CODES = new Set([
+    CtrDexV2.GenericGroup,
+    CtrDexV2.BigGenericGroup,
+    CtrDexV2.GenericListGroup,
+    CtrDexV2.BigGenericListGroup,
+]);
+function tokenSize(token, domain) {
+    return domain === "bny" ? token.fullSizeB2 : token.fullSize;
+}
+function isMapGroupCode(code) {
+    return MAP_GROUP_CODES.has(code);
+}
+function asQb64(raw, domain) {
+    return domain === "txt" ? String.fromCharCode(...raw) : encodeB64(raw);
+}
+function parseCounterProbe(input, version, domain) {
+    // 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 },
+        { major: 1, minor: 0 },
+    ];
+    for (const attempt of attempts) {
+        try {
+            return parseCounter(input, attempt, domain);
+        }
+        catch (error) {
+            if (error instanceof ShortageError) {
+                throw error;
+            }
+            if (error instanceof UnknownCodeError ||
+                error instanceof DeserializeError) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    return null;
+}
+function parseLabelProbe(input, domain) {
+    try {
+        return parseLabeler(input, domain);
+    }
+    catch (error) {
+        if (error instanceof ShortageError) {
+            throw error;
+        }
+        if (error instanceof UnknownCodeError ||
+            error instanceof DeserializeError) {
+            return null;
+        }
+        throw error;
+    }
+}
+function parseMapperValue(input, version, domain) {
+    const counter = parseCounterProbe(input, version, domain);
+    if (counter) {
+        const dispatch = parseAttachmentDispatch(input, version, domain);
+        const raw = input.slice(0, dispatch.consumed);
+        const field = {
+            code: dispatch.group.code,
+            qb64: asQb64(raw, domain),
+            isCounter: true,
+        };
+        if (isMapGroupCode(dispatch.group.code)) {
+            const nested = parseMapperBody(input, version, domain);
+            field.children = nested.fields;
+        }
+        return { field, consumed: dispatch.consumed };
+    }
+    const matter = parseMatter(input, domain);
+    return {
+        field: {
+            code: matter.code,
+            qb64: matter.qb64,
+            isCounter: false,
+        },
+        consumed: tokenSize(matter, domain),
+    };
+}
+function parseMapPayload(input, version, domain, start, end) {
+    const fields = [];
+    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);
+            continue;
+        }
+        const { field, consumed } = parseMapperValue(at, version, domain);
+        fields.push({
+            label: pendingLabel,
+            code: field.code,
+            qb64: field.qb64,
+            isCounter: field.isCounter,
+            children: field.children,
+        });
+        pendingLabel = null;
+        offset += consumed;
+    }
+    if (offset !== end) {
+        throw new ShortageError(end, offset);
+    }
+    if (pendingLabel !== null) {
+        throw new UnknownCodeError("Dangling map label without value");
+    }
+    return fields;
+}
+/**
+ * Parse map-style native bodies/counters into labeled semantic fields.
+ * Parsing is strict: payload boundaries and label/value pairing must be exact.
+ */
+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}`);
+    }
+    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 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),
+        fields,
+    };
+}
+/** True for counter codes that represent map/list-native aggregate primitives. */
+export function isMapperCounterCode(code) {
+    return MAP_GROUP_CODES.has(code) || LIST_GROUP_CODES.has(code);
+}

package/esm/src/primitives/matter.js

@@ -0,0 +1,109 @@
+import { b64ToInt, codeB2ToB64, codeB64ToB2, decodeB64, nabSextets, sceil, } from "../core/bytes.js";
+import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
+import { MATTER_HARDS, MATTER_SIZES, } from "../tables/matter.tables.generated.js";
+const MATTER_BARDS = new Map([...MATTER_HARDS.entries()].map(([code, hs]) => [
+    String.fromCharCode(codeB64ToB2(code)[0]),
+    hs,
+]));
+function parseMatterCodeFromText(txt) {
+    const hs = MATTER_HARDS.get(txt[0]);
+    if (!hs) {
+        throw new UnknownCodeError(`Unknown matter hard selector ${txt[0]}`);
+    }
+    let code = txt.slice(0, hs);
+    let sizage = MATTER_SIZES.get(code);
+    if (!sizage && hs < txt.length) {
+        const fallback = txt.slice(0, Math.min(4, txt.length));
+        sizage = MATTER_SIZES.get(fallback);
+        if (sizage)
+            code = fallback;
+    }
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown matter code ${code}`);
+    }
+    return { code, hs: sizage.hs };
+}
+export function parseMatterFromText(input) {
+    const txt = String.fromCharCode(...input);
+    if (txt.length === 0) {
+        throw new DeserializeError("Empty matter input");
+    }
+    const { code } = parseMatterCodeFromText(txt);
+    const sizage = MATTER_SIZES.get(code);
+    const cs = sizage.hs + sizage.ss;
+    const soft = sizage.ss > 0 ? txt.slice(sizage.hs, cs).slice(sizage.xs) : "";
+    const fullSize = sizage.fs ?? (cs + b64ToInt(soft) * 4);
+    if (txt.length < fullSize) {
+        throw new ShortageError(fullSize, txt.length);
+    }
+    const ps = cs % 4;
+    const body = txt.slice(cs, fullSize);
+    const paw = decodeB64("A".repeat(ps) + body);
+    const raw = paw.slice(ps + sizage.ls);
+    return {
+        code,
+        raw,
+        qb64: txt.slice(0, fullSize),
+        fullSize,
+        fullSizeB2: sceil((fullSize * 3) / 4),
+    };
+}
+export function parseMatterFromBinary(input) {
+    if (input.length === 0) {
+        throw new ShortageError(1, 0);
+    }
+    const first = nabSextets(input, 1);
+    const hs = MATTER_BARDS.get(String.fromCharCode(first[0]));
+    if (!hs) {
+        throw new UnknownCodeError(`Unsupported qb2 code start sextet=0x${first[0].toString(16)}`);
+    }
+    const bhs = sceil((hs * 3) / 4);
+    if (input.length < bhs) {
+        throw new ShortageError(bhs, input.length);
+    }
+    const hard = codeB2ToB64(input, hs);
+    const sizage = MATTER_SIZES.get(hard);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown matter code ${hard}`);
+    }
+    const cs = sizage.hs + sizage.ss;
+    const bcs = sceil((cs * 3) / 4);
+    if (input.length < bcs) {
+        throw new ShortageError(bcs, input.length);
+    }
+    const both = codeB2ToB64(input, cs);
+    const softWithXtra = both.slice(sizage.hs, sizage.hs + sizage.ss);
+    const xtra = softWithXtra.slice(0, sizage.xs);
+    if (xtra !== "_".repeat(sizage.xs)) {
+        throw new UnknownCodeError(`Invalid prepad xtra=${xtra}`);
+    }
+    const soft = softWithXtra.slice(sizage.xs);
+    const fs = sizage.fs ?? ((b64ToInt(soft) * 4) + cs);
+    const bfs = sceil((fs * 3) / 4);
+    if (input.length < bfs) {
+        throw new ShortageError(bfs, input.length);
+    }
+    const qb2 = input.slice(0, bfs);
+    const ps = cs % 4;
+    const pbs = 2 * ps;
+    if (pbs > 0) {
+        const pi = qb2[bcs - 1] & ((2 ** pbs) - 1);
+        if (pi !== 0) {
+            throw new DeserializeError(`Nonzero code mid pad bits=0b${pi.toString(2).padStart(pbs, "0")}`);
+        }
+    }
+    const qb64 = codeB2ToB64(qb2, fs);
+    const raw = decodeB64(qb64.slice(cs)).slice(sizage.ls);
+    return {
+        code: hard,
+        raw,
+        qb64,
+        fullSize: fs,
+        fullSizeB2: bfs,
+    };
+}
+export function parseMatter(input, cold) {
+    return cold === "bny"
+        ? parseMatterFromBinary(input)
+        : parseMatterFromText(input);
+}

package/esm/src/primitives/mediar.js

@@ -0,0 +1,21 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { CtrDexV2 } from "../tables/counter-codex.js";
+import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
+const MEDIAR_CODES = new Set([
+    CtrDexV2.TypedMediaQuadruples,
+    CtrDexV2.BigTypedMediaQuadruples,
+]);
+export function parseMediar(input, version, cold) {
+    const parsed = parseAttachmentDispatch(input, version, cold);
+    if (!MEDIAR_CODES.has(parsed.group.code)) {
+        throw new UnknownCodeError(`Expected mediar group code, got ${parsed.group.code}`);
+    }
+    return {
+        code: parsed.group.code,
+        name: parsed.group.name,
+        count: parsed.group.count,
+        items: parsed.group.items,
+        raw: parsed.group.raw,
+        consumed: parsed.consumed,
+    };
+}

package/esm/src/primitives/noncer.js

@@ -0,0 +1,18 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+const NONCE_CODE_NAMES = new Set(["Salt_128", "Salt_256"]);
+export function parseNoncer(input, cold) {
+    const matter = parseMatter(input, cold);
+    const name = MATTER_CODE_NAMES[matter.code] ?? "";
+    if (!NONCE_CODE_NAMES.has(name)) {
+        throw new UnknownCodeError(`Expected nonce code, got ${matter.code}`);
+    }
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        nonce: matter.raw,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/number.js

@@ -0,0 +1,31 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+const NUMBER_CODE_NAMES = new Set([
+    "Short",
+    "Long",
+    "Big",
+    "Tall",
+    "Large",
+    "Great",
+    "Vast",
+]);
+export function parseNumber(input, cold) {
+    const matter = parseMatter(input, cold);
+    const name = MATTER_CODE_NAMES[matter.code];
+    if (!name || !NUMBER_CODE_NAMES.has(name)) {
+        throw new UnknownCodeError(`Expected number code, got ${matter.code}`);
+    }
+    let num = 0n;
+    for (const b of matter.raw) {
+        num = (num << 8n) | BigInt(b);
+    }
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        num,
+        numh: num.toString(16),
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/pather.js

@@ -0,0 +1,23 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+function isPatherCode(code) {
+    const name = MATTER_CODE_NAMES[code] ?? "";
+    return name.startsWith("StrB64_") || name.startsWith("StrB64_Big_") ||
+        name.startsWith("Bytes_") || name.startsWith("Bytes_Big_");
+}
+export function parsePather(input, cold) {
+    const matter = parseMatter(input, cold);
+    if (!isPatherCode(matter.code)) {
+        throw new UnknownCodeError(`Expected pather-compatible code, got ${matter.code}`);
+    }
+    // For parser-level fidelity we preserve encoded path token text.
+    const path = matter.qb64.slice(matter.code.length);
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        path,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/prefixer.js

@@ -0,0 +1,23 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+const PREFIX_CODE_NAMES = new Set([
+    "Ed25519N",
+    "ECDSA_256k1N",
+    "ECDSA_256r1N",
+    "Ed448N",
+]);
+export function parsePrefixer(input, cold) {
+    const matter = parseMatter(input, cold);
+    const name = MATTER_CODE_NAMES[matter.code] ?? "";
+    if (!PREFIX_CODE_NAMES.has(name)) {
+        throw new UnknownCodeError(`Expected prefix code, got ${matter.code}`);
+    }
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        prefix: matter.qb64,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/registry.js

@@ -0,0 +1,17 @@
+import { parseMatterFromText } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+export function parsePrimitiveFromText(input) {
+    const matter = parseMatterFromText(input);
+    const name = MATTER_CODE_NAMES[matter.code] ??
+        "UnknownPrimitive";
+    return {
+        code: matter.code,
+        name,
+        qb64: matter.qb64,
+        raw: matter.raw,
+        fullSize: matter.fullSize,
+    };
+}
+export function supportedPrimitiveCodes() {
+    return Object.keys(MATTER_CODE_NAMES).sort();
+}

package/esm/src/primitives/saider.js

@@ -0,0 +1,22 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+function isDigestName(name) {
+    return name.startsWith("Blake") || name.startsWith("SHA2_") ||
+        name.startsWith("SHA3_");
+}
+export function parseSaider(input, cold) {
+    const matter = parseMatter(input, cold);
+    const name = MATTER_CODE_NAMES[matter.code] ?? "";
+    if (!isDigestName(name)) {
+        throw new UnknownCodeError(`Expected said digest code, got ${matter.code}`);
+    }
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        said: matter.qb64,
+        digest: matter.raw,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/sealer.js

@@ -0,0 +1,35 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { CtrDexV1, CtrDexV2 } from "../tables/counter-codex.js";
+import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
+const SEALER_CODES = new Set([
+    CtrDexV1.SealSourceCouples,
+    CtrDexV1.SealSourceTriples,
+    CtrDexV2.SealSourceCouples,
+    CtrDexV2.BigSealSourceCouples,
+    CtrDexV2.SealSourceTriples,
+    CtrDexV2.BigSealSourceTriples,
+    CtrDexV2.SealSourceLastSingles,
+    CtrDexV2.BigSealSourceLastSingles,
+    CtrDexV2.DigestSealSingles,
+    CtrDexV2.BigDigestSealSingles,
+    CtrDexV2.MerkleRootSealSingles,
+    CtrDexV2.BigMerkleRootSealSingles,
+    CtrDexV2.BackerRegistrarSealCouples,
+    CtrDexV2.BigBackerRegistrarSealCouples,
+    CtrDexV2.TypedDigestSealCouples,
+    CtrDexV2.BigTypedDigestSealCouples,
+]);
+export function parseSealer(input, version, cold) {
+    const parsed = parseAttachmentDispatch(input, version, cold);
+    if (!SEALER_CODES.has(parsed.group.code)) {
+        throw new UnknownCodeError(`Expected sealer group code, got ${parsed.group.code}`);
+    }
+    return {
+        code: parsed.group.code,
+        name: parsed.group.name,
+        count: parsed.group.count,
+        items: parsed.group.items,
+        raw: parsed.group.raw,
+        consumed: parsed.consumed,
+    };
+}

package/esm/src/primitives/seqner.js

@@ -0,0 +1,23 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+export function parseSeqner(input, cold) {
+    const matter = parseMatter(input, cold);
+    const name = MATTER_CODE_NAMES[matter.code];
+    if (name !== "Salt_128") {
+        throw new UnknownCodeError(`Expected seqner Salt_128 code, got ${matter.code}`);
+    }
+    let sn = 0n;
+    for (const b of matter.raw) {
+        sn = (sn << 8n) | BigInt(b);
+    }
+    const snh = sn.toString(16).padStart(matter.raw.length * 2, "0");
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        sn,
+        snh,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/texter.js

@@ -0,0 +1,20 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+function isTexterCode(code) {
+    const name = MATTER_CODE_NAMES[code] ?? "";
+    return name.startsWith("Bytes_") || name.startsWith("Bytes_Big_");
+}
+export function parseTexter(input, cold) {
+    const matter = parseMatter(input, cold);
+    if (!isTexterCode(matter.code)) {
+        throw new UnknownCodeError(`Expected texter bytes code, got ${matter.code}`);
+    }
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        text: new TextDecoder().decode(matter.raw),
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}

package/esm/src/primitives/tholder.js

@@ -0,0 +1,27 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { parseMatter } from "./matter.js";
+import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+function isNumericName(name) {
+    return name === "Short" || name === "Long" || name === "Big" || name === "Tall" ||
+        name === "Large" || name === "Great" || name === "Vast";
+}
+function isWeightedName(name) {
+    return name.startsWith("StrB64_") || name.startsWith("StrB64_Big_");
+}
+export function parseTholder(input, cold) {
+    const matter = parseMatter(input, cold);
+    const name = MATTER_CODE_NAMES[matter.code] ?? "";
+    if (!isNumericName(name) && !isWeightedName(name)) {
+        throw new UnknownCodeError(`Expected threshold code, got ${matter.code}`);
+    }
+    const sith = isNumericName(name)
+        ? [...matter.raw].reduce((acc, b) => (acc << 8n) | BigInt(b), 0n).toString(16)
+        : new TextDecoder().decode(matter.raw);
+    return {
+        code: matter.code,
+        qb64: matter.qb64,
+        sith,
+        fullSize: matter.fullSize,
+        fullSizeB2: matter.fullSizeB2,
+    };
+}