cesr-ts 0.3.0 → 0.4.0

package/esm/src/primitives/mediar.js

@@ -1,21 +1,30 @@
 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}`);
+import { MEDIAR_CODES } from "../tables/counter-groups.js";
+import { parseStructor, Structor } from "./structor.js";
+/** True when counter code belongs to typed-media tuple families. */
+export function isMediarCode(code) {
+    return MEDIAR_CODES.has(code);
+}
+/**
+ * Typed-media structor primitive.
+ *
+ * KERIpy substance: `Mediar` materializes media metadata/value tuple groups
+ * used in blinded media attachments and related CESR payload envelopes.
+ */
+export class Mediar extends Structor {
+    constructor(init) {
+        const structor = init instanceof Structor ? init : new Structor(init);
+        super(structor);
+        if (!isMediarCode(this.code)) {
+            throw new UnknownCodeError(`Expected mediar group code, got ${this.code}`);
+        }
+    }
+    /** Hydrate a `Mediar` from an already parsed counter-group node. */
+    static fromGroup(group, sourceDomain = "txt") {
+        return new Mediar({ group, sourceDomain });
     }
-    return {
-        code: parsed.group.code,
-        name: parsed.group.name,
-        count: parsed.group.count,
-        items: parsed.group.items,
-        raw: parsed.group.raw,
-        consumed: parsed.consumed,
-    };
+}
+/** Parse and validate typed-media attachment groups. */
+export function parseMediar(input, version, cold) {
+    return new Mediar(parseStructor(input, version, cold, MEDIAR_CODES, "mediar"));
 }

package/esm/src/primitives/noncer.js

@@ -1,18 +1,36 @@
 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}`);
+import { NONCE_CODES, NonceDex } from "./codex.js";
+import { Diger } from "./diger.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Nonce primitive for UUID/salt-or-digest nonce representations.
+ *
+ * KERIpy semantics: `Noncer` subclasses `Diger` with relaxed digest-code
+ * enforcement and validates membership in `NonceCodex` (including `Empty`).
+ */
+export class Noncer extends Diger {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter, { strict: false });
+        if (!NONCE_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected nonce code, got ${this.code}`);
+        }
+    }
+    /**
+     * Roundtrippable nonce text.
+     *
+     * Mirrors KERIpy behavior: empty nonce is represented as empty string when
+     * code is `Empty`; otherwise returns qualified qb64 nonce token.
+     */
+    get nonce() {
+        return this.code === NonceDex.Empty ? "" : this.qb64;
+    }
+    /** Binary companion to `.nonce` with empty-bytes behavior for `Empty` code. */
+    get nonceb() {
+        return this.code === NonceDex.Empty ? new Uint8Array() : this.qb64b;
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        nonce: matter.raw,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `Noncer` from txt/qb2 bytes. */
+export function parseNoncer(input, cold) {
+    return new Noncer(parseMatter(input, cold));
 }

package/esm/src/primitives/number.js

@@ -1,31 +1,32 @@
 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}`);
+import { NUMBER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Ordinal number primitive.
+ *
+ * KERIpy substance: `Number` encodes non-negative integer values using compact
+ * numeric codex families while preserving deterministic serialization.
+ */
+export class NumberPrimitive extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!NUMBER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected number code, got ${this.code}`);
+        }
+    }
+    get num() {
+        let value = 0n;
+        for (const b of this.raw) {
+            value = (value << 8n) | BigInt(b);
+        }
+        return value;
     }
-    let num = 0n;
-    for (const b of matter.raw) {
-        num = (num << 8n) | BigInt(b);
+    get numh() {
+        return this.num.toString(16);
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        num,
-        numh: num.toString(16),
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `NumberPrimitive` from txt/qb2 bytes. */
+export function parseNumber(input, cold) {
+    return new NumberPrimitive(parseMatter(input, cold));
 }

package/esm/src/primitives/pather.js

@@ -1,23 +1,35 @@
+import { t } from "../core/bytes.js";
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+import { Bexter } from "./bexter.js";
+import { BEXTER_CODES, TEXTER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.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_");
+    return BEXTER_CODES.has(code) || TEXTER_CODES.has(code);
 }
-export function parsePather(input, cold) {
-    const matter = parseMatter(input, cold);
-    if (!isPatherCode(matter.code)) {
-        throw new UnknownCodeError(`Expected pather-compatible code, got ${matter.code}`);
+/**
+ * CESR path primitive for SAD traversal routes.
+ *
+ * KERIpy semantics: path strings may be compactly encoded via StrB64 family
+ * (`-` separators, optional `--` escape prefix) or carried as raw bytes.
+ */
+export class Pather extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!isPatherCode(this.code)) {
+            throw new UnknownCodeError(`Expected pather-compatible code, got ${this.code}`);
+        }
+    }
+    /** Decoded `/`-separated path form regardless of underlying CESR code family. */
+    get path() {
+        if (BEXTER_CODES.has(this.code)) {
+            const bext = Bexter.derawify(this.raw, this.code).replace(/^--/, "");
+            return bext.split("-").join("/");
+        }
+        return t(this.raw);
     }
-    // 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,
-    };
+}
+/** Parse and hydrate a `Pather` from txt/qb2 bytes. */
+export function parsePather(input, cold) {
+    return new Pather(parseMatter(input, cold));
 }

package/esm/src/primitives/prefixer.js

@@ -1,23 +1,26 @@
 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}`);
+import { PREFIX_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Identifier-prefix primitive.
+ *
+ * KERIpy substance: `Prefixer` represents AID prefix material and accepts the
+ * full KERI prefix derivation codex (`PreDex`), including transferable and
+ * self-addressing derivation families.
+ */
+export class Prefixer extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!PREFIX_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected prefix code, got ${this.code}`);
+        }
+    }
+    get prefix() {
+        return this.qb64;
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        prefix: matter.qb64,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `Prefixer` from txt/qb2 bytes. */
+export function parsePrefixer(input, cold) {
+    return new Prefixer(parseMatter(input, cold));
 }

package/esm/src/primitives/primitive.js

@@ -0,0 +1,9 @@
+/** Runtime guard for tuple-shaped group entries. */
+export function isPrimitiveTuple(entry) {
+    return Array.isArray(entry);
+}
+/** Runtime guard for parsed counter-group nodes in recursive payload graphs. */
+export function isCounterGroupLike(entry) {
+    return typeof entry === "object" && entry !== null && !Array.isArray(entry)
+        && "items" in entry && "count" in entry && "code" in entry;
+}

package/esm/src/primitives/registry.js

@@ -1,9 +1,9 @@
-import { parseMatterFromText } from "./matter.js";
 import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+import { parseMatterFromText } from "./matter.js";
 export function parsePrimitiveFromText(input) {
     const matter = parseMatterFromText(input);
-    const name = MATTER_CODE_NAMES[matter.code] ??
-        "UnknownPrimitive";
+    const name = MATTER_CODE_NAMES[matter.code]
+        ?? "UnknownPrimitive";
     return {
         code: matter.code,
         name,

package/esm/src/primitives/saider.js

@@ -1,22 +1,28 @@
 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_");
+import { DIGEST_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Self-addressing identifier digest primitive.
+ *
+ * KERIpy substance: `Saider` is digest-qualified material used as SAD SAID
+ * values; this class validates digest-family code semantics.
+ */
+export class Saider extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!DIGEST_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected said digest code, got ${this.code}`);
+        }
+    }
+    get said() {
+        return this.qb64;
+    }
+    get digest() {
+        return this.raw;
+    }
 }
+/** Parse and hydrate `Saider` from txt/qb2 bytes. */
 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,
-    };
+    return new Saider(parseMatter(input, cold));
 }

package/esm/src/primitives/salter.js

@@ -0,0 +1,22 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { SALTER_CODES } from "./codex.js";
+import { Matter } from "./matter.js";
+/**
+ * Salt primitive for deterministic secret/signer derivation workflows.
+ *
+ * KERIpy substance: Salter stores random or fixed salt bytes and is used as
+ * input to deterministic signer/seed generation paths.
+ */
+export class Salter extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!SALTER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected salt code, got ${this.code}`);
+        }
+    }
+    /** Raw salt bytes used by key-derivation consumers. */
+    get salt() {
+        return this.raw;
+    }
+}

package/esm/src/primitives/sealer.js

@@ -1,35 +1,30 @@
 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}`);
+import { SEALER_CODES } from "../tables/counter-groups.js";
+import { parseStructor, Structor } from "./structor.js";
+/** True when counter code belongs to KERI seal source/digest families. */
+export function isSealerCode(code) {
+    return SEALER_CODES.has(code);
+}
+/**
+ * Seal-group structor primitive.
+ *
+ * KERIpy substance: `Sealer` materializes counted seal tuple groups used for
+ * anchoring, seal-source references, and registrar-binding payloads.
+ */
+export class Sealer extends Structor {
+    constructor(init) {
+        const structor = init instanceof Structor ? init : new Structor(init);
+        super(structor);
+        if (!isSealerCode(this.code)) {
+            throw new UnknownCodeError(`Expected sealer group code, got ${this.code}`);
+        }
+    }
+    /** Hydrate a `Sealer` from an already parsed counter-group node. */
+    static fromGroup(group, sourceDomain = "txt") {
+        return new Sealer({ group, sourceDomain });
     }
-    return {
-        code: parsed.group.code,
-        name: parsed.group.name,
-        count: parsed.group.count,
-        items: parsed.group.items,
-        raw: parsed.group.raw,
-        consumed: parsed.consumed,
-    };
+}
+/** Parse and validate seal attachment groups across v1/v2 seal families. */
+export function parseSealer(input, version, cold) {
+    return new Sealer(parseStructor(input, version, cold, SEALER_CODES, "sealer"));
 }

package/esm/src/primitives/seqner.js

@@ -1,23 +1,32 @@
 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}`);
+import { SEQNER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Fixed-width sequence/ordinal primitive.
+ *
+ * KERIpy substance: `Seqner` forces fixed-size ordinal serialization (Salt_128
+ * family) for lexicographically stable ordering in key-value namespaces.
+ */
+export class Seqner extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!SEQNER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected seqner Salt_128 code, got ${this.code}`);
+        }
+    }
+    get sn() {
+        let sn = 0n;
+        for (const b of this.raw) {
+            sn = (sn << 8n) | BigInt(b);
+        }
+        return sn;
     }
-    let sn = 0n;
-    for (const b of matter.raw) {
-        sn = (sn << 8n) | BigInt(b);
+    get snh() {
+        return this.sn.toString(16).padStart(this.raw.length * 2, "0");
     }
-    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,
-    };
+}
+/** Parse and hydrate `Seqner` from txt/qb2 bytes. */
+export function parseSeqner(input, cold) {
+    return new Seqner(parseMatter(input, cold));
 }

package/esm/src/primitives/siger.js

@@ -0,0 +1,29 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { SIGER_CODES } from "./codex.js";
+import { Indexer, parseIndexer } from "./indexer.js";
+/**
+ * Indexed signature primitive with optional verifier association.
+ *
+ * KERIpy substance: `Siger` extends indexed signature material and carries
+ * optional `verfer` linkage so verification context can travel with signature.
+ */
+export class Siger extends Indexer {
+    constructor(init, verfer) {
+        const indexer = init instanceof Indexer ? init : new Indexer(init);
+        super(indexer);
+        Object.defineProperty(this, "verfer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!SIGER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected indexed signature code, got ${this.code}`);
+        }
+        this.verfer = verfer;
+    }
+}
+/** Parse and hydrate `Siger` from txt or qb2 encoded bytes. */
+export function parseSiger(input, cold) {
+    return new Siger(parseIndexer(input, cold));
+}

package/esm/src/primitives/signer.js

@@ -0,0 +1,23 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { SIGNER_CODES } from "./codex.js";
+import { Matter } from "./matter.js";
+/**
+ * Signing-seed primitive.
+ *
+ * KERIpy substance: Signer wraps private seed material that is used to derive
+ * signing key pairs and associated verifier material; this TS layer constrains
+ * codex validity while higher crypto layers perform key derivation/signing.
+ */
+export class Signer extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!SIGNER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected signer seed code, got ${this.code}`);
+        }
+    }
+    /** Raw seed bytes for signer key-derivation/instantiation. */
+    get seed() {
+        return this.raw;
+    }
+}

package/esm/src/primitives/structor.js

@@ -0,0 +1,104 @@
+import { b, codeB64ToB2, encodeB64, t } from "../core/bytes.js";
+import { UnknownCodeError } from "../core/errors.js";
+import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
+import { CounterGroup } from "./counter.js";
+import { isCounterGroupLike, isPrimitiveTuple } from "./primitive.js";
+function toText(input) {
+    return t(input);
+}
+function serializeEntryQb64(entry) {
+    if (isPrimitiveTuple(entry)) {
+        return entry.map((item) => serializeEntryQb64(item)).join("");
+    }
+    if (isCounterGroupLike(entry)) {
+        return `${entry.qb64}${entry.items.map((item) => serializeEntryQb64(item)).join("")}`;
+    }
+    return entry.qb64;
+}
+function inferSerialized(group, sourceDomain) {
+    const qb64 = `${group.qb64}${group.items.map((item) => serializeEntryQb64(item)).join("")}`;
+    return sourceDomain === "txt" ? b(qb64) : codeB64ToB2(qb64);
+}
+/**
+ * Group primitive base class for counted CESR tuple/list attachment structures.
+ *
+ * KERIpy substance: `Structor` models one counted-group unit where tuple/list
+ * members are hydrated CESR primitives and serialization remains deterministic.
+ */
+export class Structor extends CounterGroup {
+    constructor(init) {
+        if (init instanceof Structor) {
+            super(init, init.raw, init.items);
+            this.sourceDomain = init.sourceDomain;
+            this.serialized = init.serialized.slice();
+            this.consumed = init.consumed;
+            return;
+        }
+        const group = init.group;
+        super(group, group.raw, group.items);
+        Object.defineProperty(this, "sourceDomain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "consumed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "serialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.sourceDomain = init.sourceDomain ?? "txt";
+        this.serialized = init.serialized?.slice()
+            ?? inferSerialized(group, this.sourceDomain);
+        this.consumed = init.consumed ?? this.serialized.length;
+    }
+    /** Semantic clan/tag alias for KERIpy parity terminology (`name` in TS). */
+    get clan() {
+        return this.name;
+    }
+    /** Fully enclosed group serialization in text domain (`counter + payload`). */
+    get qb64g() {
+        return this.sourceDomain === "txt"
+            ? toText(this.serialized)
+            : encodeB64(this.serialized);
+    }
+    /** Fully enclosed group serialization in binary domain (`counter + payload`). */
+    get qb2g() {
+        return this.sourceDomain === "bny"
+            ? this.serialized.slice()
+            : codeB64ToB2(this.qb64g);
+    }
+    /** Deterministic value-equivalence over full enclosed qb64 text form. */
+    equalsStructor(other) {
+        return this.qb64g === other.qb64g;
+    }
+    /** Hydrate a generic structor from an already parsed counter group. */
+    static fromGroup(group, sourceDomain = "txt") {
+        return new Structor({ group, sourceDomain });
+    }
+}
+/**
+ * Parse one counted attachment group and hydrate it as `Structor`.
+ *
+ * Optional `allowedCodes` guard narrows acceptable group families for
+ * subclass parsers (`Sealer`, `Blinder`, `Mediar`, `Aggor`).
+ */
+export function parseStructor(input, version, cold, allowedCodes, expectedFamily = "structor") {
+    const parsed = parseAttachmentDispatch(input, version, cold);
+    if (allowedCodes && !allowedCodes.has(parsed.group.code)) {
+        throw new UnknownCodeError(`Expected ${expectedFamily} group code, got ${parsed.group.code}`);
+    }
+    return new Structor({
+        group: parsed.group,
+        sourceDomain: cold,
+        consumed: parsed.consumed,
+        serialized: input.slice(0, parsed.consumed),
+    });
+}