cesr-ts 0.3.0 → 0.4.0

package/esm/src/index.js

@@ -1,50 +1,76 @@
-export * from "./core/types.js";
+export * from "./adapters/async-iterable.js";
+export * from "./adapters/effection.js";
+export * from "./annotate/annotator.js";
+export * from "./annotate/comments.js";
+export * from "./annotate/denot.js";
+export * from "./annotate/render.js";
+export * from "./annotate/types.js";
+export * from "./bench/parser-benchmark.js";
+export * from "./core/bytes.js";
+export * from "./core/cbor.js";
 export * from "./core/errors.js";
 export * from "./core/parser-engine.js";
 export * from "./core/parser-policy.js";
 export * from "./core/recovery-diagnostics.js";
+export * from "./core/types.js";
 export * from "./parser/cold-start.js";
 export * from "./parser/group-dispatch.js";
-export * from "./serder/smell.js";
-export * from "./serder/serder.js";
-export * from "./serder/serdery.js";
-export * from "./primitives/matter.js";
+export * from "./primitives/aggor.js";
+export * from "./primitives/bexter.js";
+export * from "./primitives/blinder.js";
+export * from "./primitives/cigar.js";
+export * from "./primitives/cipher.js";
+export * from "./primitives/codex.js";
+export * from "./primitives/compactor.js";
 export * from "./primitives/counter.js";
-export * from "./primitives/indexer.js";
-export * from "./primitives/verser.js";
+export * from "./primitives/dater.js";
+export * from "./primitives/decimer.js";
+export * from "./primitives/decrypter.js";
+export * from "./primitives/diger.js";
+export * from "./primitives/encrypter.js";
 export * from "./primitives/ilker.js";
+export * from "./primitives/indexer.js";
 export * from "./primitives/labeler.js";
-export * from "./primitives/texter.js";
-export * from "./primitives/bexter.js";
-export * from "./primitives/pather.js";
 export * from "./primitives/mapper.js";
+export * from "./primitives/matter.js";
+export * from "./primitives/mediar.js";
+export * from "./primitives/noncer.js";
 export * from "./primitives/number.js";
-export * from "./primitives/seqner.js";
-export * from "./primitives/dater.js";
-export * from "./primitives/diger.js";
+export * from "./primitives/pather.js";
 export * from "./primitives/prefixer.js";
-export * from "./primitives/noncer.js";
+export * from "./primitives/primitive.js";
+export * from "./primitives/registry.js";
 export * from "./primitives/saider.js";
-export * from "./primitives/cigar.js";
-export * from "./primitives/verfer.js";
-export * from "./primitives/traitor.js";
-export * from "./primitives/tholder.js";
+export * from "./primitives/salter.js";
 export * from "./primitives/sealer.js";
-export * from "./primitives/blinder.js";
-export * from "./primitives/mediar.js";
-export * from "./primitives/compactor.js";
-export * from "./primitives/aggor.js";
-export * from "./primitives/registry.js";
-export * from "./adapters/async-iterable.js";
-export * from "./adapters/effection.js";
+export * from "./primitives/seqner.js";
+export * from "./primitives/siger.js";
+export * from "./primitives/signer.js";
+export * from "./primitives/structor.js";
+export * from "./primitives/tagger.js";
+export * from "./primitives/texter.js";
+export * from "./primitives/tholder.js";
+export * from "./primitives/traitor.js";
+export * from "./primitives/unknown.js";
+export * from "./primitives/verfer.js";
+export * from "./primitives/verser.js";
 export * from "./router/router-stub.js";
-export * from "./tables/versions.js";
-export * from "./tables/table-types.js";
+export * from "./serder/serder.js";
+export * from "./serder/serdery.js";
+export * from "./serder/smell.js";
+export * from "./tables/codex-utils.js";
 export * from "./tables/counter-codex.js";
+export * from "./tables/counter-groups.js";
 export * from "./tables/counter-version-registry.js";
-export * from "./annotate/types.js";
-export * from "./annotate/comments.js";
-export * from "./annotate/render.js";
-export * from "./annotate/annotator.js";
-export * from "./annotate/denot.js";
-export * from "./bench/parser-benchmark.js";
+export * from "./tables/indexer.codex.generated.js";
+export * from "./tables/indexer.tables.generated.js";
+export * from "./tables/matter.codex.generated.js";
+export * from "./tables/matter.tables.generated.js";
+export * from "./tables/table-types.js";
+export * from "./tables/trait.codex.generated.js";
+export * from "./tables/versions.js";
+export { bytesHex } from "./core/bytes.js";
+export { bytesEqual } from "./core/bytes.js";
+export { toBytes } from "./core/bytes.js";
+export { t } from "./core/bytes.js";
+export { b } from "./core/bytes.js";

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

@@ -1,4 +1,4 @@
-import { parseAttachmentDispatchCompat, } from "./group-dispatch.js";
+import { parseAttachmentDispatchCompat } from "./group-dispatch.js";
 export function parseAttachmentGroup(input, version, domain, options = {}) {
     return parseAttachmentDispatchCompat(input, version, domain, options);
 }

package/esm/src/parser/group-dispatch.js

@@ -1,24 +1,16 @@
-import { parseCounter } from "../primitives/counter.js";
-import { parseMatter } from "../primitives/matter.js";
+import { b, b64ToInt, intToB64 } from "../core/bytes.js";
+import { GroupSizeError, ShortageError, UnknownCodeError } from "../core/errors.js";
+import { composeRecoveryDiagnosticObserver, } from "../core/recovery-diagnostics.js";
+import { CounterGroup, parseCounter } from "../primitives/counter.js";
 import { parseIndexer } from "../primitives/indexer.js";
-import { GroupSizeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
+import { parseMatter } from "../primitives/matter.js";
+import { UnknownPrimitive } from "../primitives/unknown.js";
 import { CtrDexV1, CtrDexV2 } from "../tables/counter-codex.js";
 import { resolveVersionedRegistryValue, } from "../tables/counter-version-registry.js";
-import { b64ToInt, intToB64 } from "../core/bytes.js";
-import { composeRecoveryDiagnosticObserver, } from "../core/recovery-diagnostics.js";
 import { createAttachmentVersionFallbackPolicy, } from "./attachment-fallback-policy.js";
-export { createAttachmentVersionFallbackPolicy, } from "./attachment-fallback-policy.js";
-function qb64Item(qb64, opaque = false) {
-    return { kind: "qb64", qb64, opaque };
-}
-function qb2Item(qb2, opaque = false) {
-    return { kind: "qb2", qb2, opaque };
-}
+export { createAttachmentVersionFallbackPolicy } from "./attachment-fallback-policy.js";
 function tupleItem(items) {
-    return { kind: "tuple", items };
-}
-function nestedGroupItem(code, name, count) {
-    return { kind: "group", code, name, count };
+    return items;
 }
 /** Normalize unknown throwables to an `Error` for diagnostic emission. */
 function asError(error) {
@@ -352,7 +344,7 @@ function parseTuple(input, kinds, domain) {
         const part = kind === "indexer"
             ? parseIndexer(input.slice(offset), domain)
             : parseMatter(input.slice(offset), domain);
-        items.push(qb64Item(part.qb64));
+        items.push(part);
         offset += primitiveSize(part, domain);
     }
     return { items, consumed: offset };
@@ -369,16 +361,16 @@ function parseRepeated(input, count, kinds, domain) {
     return { items, consumed: offset };
 }
 /** Split opaque counted payload into domain units (quadlets for text, triplets for binary). */
-function splitOpaqueUnits(payload, domain, expectedCount, opaque = false) {
+function splitOpaqueUnits(payload, domain, expectedCount) {
     if (domain === "bny") {
         const count = expectedCount ?? Math.floor(payload.length / 3);
-        return Array.from({ length: count }, (_v, i) => qb2Item(payload.slice(i * 3, i * 3 + 3), opaque));
+        return Array.from({ length: count }, (_v, i) => UnknownPrimitive.fromPayload(payload.slice(i * 3, i * 3 + 3), domain));
     }
     const text = String.fromCharCode(...payload);
     if (expectedCount !== undefined) {
-        return Array.from({ length: expectedCount }, (_v, i) => qb64Item(text.slice(i * 4, i * 4 + 4), opaque));
+        return Array.from({ length: expectedCount }, (_v, i) => UnknownPrimitive.fromPayload(b(text.slice(i * 4, i * 4 + 4)), domain));
     }
-    return (text.match(/.{1,4}/g) ?? []).map((token) => qb64Item(token, opaque));
+    return (text.match(/.{1,4}/g) ?? []).map((token) => UnknownPrimitive.fromPayload(b(token), domain));
 }
 /** Parse nested siger-list group headed by a version-appropriate siger counter. */
 function parseSigerList(input, version, domain) {
@@ -391,7 +383,7 @@ function parseSigerList(input, version, domain) {
     let offset = counterHeaderSize(counter, domain);
     for (let i = 0; i < counter.count; i++) {
         const part = parseIndexer(input.slice(offset), domain);
-        items.push(qb64Item(part.qb64));
+        items.push(part);
         offset += primitiveSize(part, domain);
     }
     return { items, consumed: offset };
@@ -432,7 +424,7 @@ function parseQuadletGroup(input, counter, version, wrapperCodes, domain, contex
                 // Allow mixed-version nested groups inside wrapper payloads.
                 // Some real-world streams wrap v2 groups inside v1 wrappers.
                 payload.slice(offset), nestedVersion, domain, context);
-                items.push(nestedGroupItem(nested.group.code, nested.group.name, nested.group.count));
+                items.push(nested.group);
                 if (nested.consumed === 0) {
                     throw new GroupSizeError("Nested attachment parser consumed zero bytes");
                 }
@@ -440,8 +432,8 @@ function parseQuadletGroup(input, counter, version, wrapperCodes, domain, contex
             }
             catch (error) {
                 const normalized = asError(error);
-                if (normalized instanceof ShortageError ||
-                    normalized instanceof GroupSizeError) {
+                if (normalized instanceof ShortageError
+                    || normalized instanceof GroupSizeError) {
                     throw normalized;
                 }
                 if (!context.versionFallbackPolicy.shouldPreserveWrapperRemainder(normalized)) {
@@ -449,7 +441,7 @@ function parseQuadletGroup(input, counter, version, wrapperCodes, domain, contex
                 }
                 // Intentional recovery point: keep unread wrapper tail as opaque units.
                 const remainder = payload.slice(offset);
-                const opaque = splitOpaqueUnits(remainder, domain, undefined, true);
+                const opaque = splitOpaqueUnits(remainder, domain);
                 context.recoveryDiagnosticObserver?.({
                     type: "wrapper-opaque-tail-preserved",
                     version: nestedVersion,
@@ -519,8 +511,8 @@ function sadPathSigParser(input, counter, version, domain, context) {
         const sigGroup = parseAttachmentDispatchCompat(input.slice(offset), version, domain, context);
         offset += sigGroup.consumed;
         items.push(tupleItem([
-            qb64Item(path.qb64),
-            nestedGroupItem(sigGroup.group.code, sigGroup.group.name, sigGroup.group.count),
+            path,
+            sigGroup.group,
         ]));
     }
     return { items, consumed: offset };
@@ -531,15 +523,15 @@ function sadPathSigGroupParser(input, counter, version, domain, context) {
     let offset = counterHeaderSize(counter, domain);
     const root = parseMatter(input.slice(offset), domain);
     offset += primitiveSize(root, domain);
-    items.push(qb64Item(root.qb64));
+    items.push(root);
     for (let i = 0; i < counter.count; i++) {
         const path = parseMatter(input.slice(offset), domain);
         offset += primitiveSize(path, domain);
         const sigGroup = parseAttachmentDispatchCompat(input.slice(offset), version, domain, context);
         offset += sigGroup.consumed;
         items.push(tupleItem([
-            qb64Item(path.qb64),
-            nestedGroupItem(sigGroup.group.code, sigGroup.group.name, sigGroup.group.count),
+            path,
+            sigGroup.group,
         ]));
     }
     return { items, consumed: offset };
@@ -547,7 +539,7 @@ function sadPathSigGroupParser(input, counter, version, domain, context) {
 /** Genus-version groups carry only the counter token itself as semantic payload. */
 function genusVersionParser(_input, counter, _version, domain, _context) {
     return {
-        items: [qb64Item(counter.qb64)],
+        items: [counter],
         consumed: counterHeaderSize(counter, domain),
     };
 }
@@ -648,13 +640,7 @@ function parseAttachmentDispatchWithVersion(input, version, domain, context) {
         throw new GroupSizeError(`Parsed beyond input boundary for ${counter.code}`);
     }
     return {
-        group: {
-            code: counter.code,
-            name: counter.name,
-            count: counter.count,
-            raw: input.slice(0, parsed.consumed),
-            items: parsed.items,
-        },
+        group: new CounterGroup(counter, input.slice(0, parsed.consumed), parsed.items),
         consumed: parsed.consumed,
     };
 }
@@ -702,8 +688,8 @@ function parseAttachmentDispatchWithPolicy(input, version, domain, context) {
  * `options.versionFallbackPolicy`.
  */
 export function parseAttachmentDispatchCompat(input, version, domain, options = {}) {
-    const versionFallbackPolicy = options.versionFallbackPolicy ??
-        createAttachmentVersionFallbackPolicy({
+    const versionFallbackPolicy = options.versionFallbackPolicy
+        ?? createAttachmentVersionFallbackPolicy({
             mode: options.mode,
         });
     const recoveryDiagnosticObserver = composeRecoveryDiagnosticObserver({

package/esm/src/primitives/aggor.js

@@ -1,41 +1,84 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { CtrDexV2 } from "../tables/counter-codex.js";
-import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
+import { AGGOR_CODES, AGGOR_LIST_CODES, AGGOR_MAP_CODES } from "../tables/counter-groups.js";
 import { parseCompactor } from "./compactor.js";
 import { parseCounter } from "./counter.js";
-const AGGOR_LIST_CODES = new Set([
-    CtrDexV2.GenericGroup,
-    CtrDexV2.BigGenericGroup,
-    CtrDexV2.GenericListGroup,
-    CtrDexV2.BigGenericListGroup,
-]);
-const AGGOR_MAP_CODES = new Set([
-    CtrDexV2.MapBodyGroup,
-    CtrDexV2.BigMapBodyGroup,
-    CtrDexV2.GenericMapGroup,
-    CtrDexV2.BigGenericMapGroup,
-]);
+import { parseStructor, Structor } from "./structor.js";
+/** True when counter code belongs to aggregate-list group families. */
+export function isAggorListCode(code) {
+    return AGGOR_LIST_CODES.has(code);
+}
+/** True when counter code belongs to aggregate-map group families. */
+export function isAggorMapCode(code) {
+    return AGGOR_MAP_CODES.has(code);
+}
+/** True when counter code belongs to any aggregate list/map family. */
+export function isAggorCode(code) {
+    return AGGOR_CODES.has(code);
+}
+/**
+ * Aggregate list/map structor primitive.
+ *
+ * KERIpy substance: `Aggor` represents counted aggregate list/map payload
+ * groups and exposes either tuple/list items or semantic map fields.
+ */
+export class Aggor extends Structor {
+    constructor(init) {
+        const payload = init instanceof Structor
+            ? { structor: init }
+            : "structor" in init
+                ? init
+                : {
+                    structor: new Structor(init),
+                };
+        super(payload.structor);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mapFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (!isAggorCode(this.code)) {
+            throw new UnknownCodeError(`Expected aggregate list/map group code, got ${this.code}`);
+        }
+        this.kind = isAggorMapCode(this.code) ? "map" : "list";
+        this.mapFields = payload.mapFields;
+    }
+    /** Tuple/list payload items for aggregate-list families. */
+    get listItems() {
+        return this.kind === "list" ? this.items : undefined;
+    }
+    /** Hydrate from an already parsed counter-group node. */
+    static fromGroup(group, sourceDomain = "txt") {
+        return new Aggor({ structor: Structor.fromGroup(group, sourceDomain) });
+    }
+}
+/**
+ * Parse aggregate attachment groups as list/map semantic containers.
+ *
+ * KERIpy substance: aggregate counters can represent generic lists or map-body
+ * structures; this helper normalizes both into one discriminated result.
+ */
 export function parseAggor(input, version, cold) {
     const counter = parseCounter(input, version, cold);
-    if (AGGOR_MAP_CODES.has(counter.code)) {
+    if (!isAggorCode(counter.code)) {
+        throw new UnknownCodeError(`Expected aggregate list/map group code, got ${counter.code}`);
+    }
+    const structor = parseStructor(input, version, cold, new Set([counter.code]), "aggregate list/map");
+    if (isAggorMapCode(structor.code)) {
         const map = parseCompactor(input, version, cold);
-        return {
-            code: map.code,
-            count: map.count,
-            kind: "map",
+        return new Aggor({
+            structor,
             mapFields: map.fields,
-            consumed: cold === "bny" ? map.totalSizeB2 : map.totalSize,
-        };
+        });
     }
-    if (AGGOR_LIST_CODES.has(counter.code)) {
-        const parsed = parseAttachmentDispatch(input, version, cold);
-        return {
-            code: parsed.group.code,
-            count: parsed.group.count,
-            kind: "list",
-            listItems: parsed.group.items,
-            consumed: parsed.consumed,
-        };
+    if (isAggorListCode(structor.code)) {
+        return new Aggor(structor);
     }
-    throw new UnknownCodeError(`Expected aggregate list/map group code, got ${counter.code}`);
+    throw new UnknownCodeError(`Expected aggregate list/map group code, got ${structor.code}`);
 }

package/esm/src/primitives/bexter.js

@@ -1,20 +1,64 @@
+import { decodeB64, encodeB64 } 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";
-function isBexterCode(code) {
-    const name = MATTER_CODE_NAMES[code] ?? "";
-    return name.startsWith("StrB64_") || name.startsWith("StrB64_Big_");
+import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { BEXTER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/** Resolve lead-byte width (`ls`) used by StrB64 code family conversions. */
+function getLeadSize(code) {
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown bexter code ${code}`);
+    }
+    return sizage.ls;
 }
-export function parseBexter(input, cold) {
-    const matter = parseMatter(input, cold);
-    if (!isBexterCode(matter.code)) {
-        throw new UnknownCodeError(`Expected bexter strb64 code, got ${matter.code}`);
+/** True when code belongs to KERIpy `BextCodex`/StrB64 family. */
+export function isBexterCode(code) {
+    return BEXTER_CODES.has(code);
+}
+/**
+ * CESR Base64-text primitive (`bext`) with compact StrB64 encoding.
+ *
+ * KERIpy correspondence:
+ * - mirrors the `Bexter`/StrB64 family contract: payload text is already
+ *   restricted to Base64 URL-safe characters, so the qualified form can be more
+ *   compact than generic UTF-8 text primitives
+ *
+ * Invariant:
+ * - `code` must belong to the StrB64/Bexter codex family
+ */
+export class Bexter extends Matter {
+    /** Convert bext text into CESR raw payload bytes. */
+    static rawify(bext) {
+        const ts = bext.length % 4;
+        const ws = (4 - ts) % 4;
+        const ls = (3 - ts) % 3;
+        return decodeB64("A".repeat(ws) + bext).slice(ls);
+    }
+    /** Decode CESR raw payload bytes back into bext text. */
+    static derawify(raw, code) {
+        const ls = getLeadSize(code);
+        const bext = encodeB64(new Uint8Array([...new Uint8Array(ls), ...raw]));
+        const ws = ls === 0 && bext.startsWith("A") ? 1 : (ls + 1) % 4;
+        return bext.slice(ws);
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        bext: new TextDecoder().decode(matter.raw),
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!isBexterCode(this.code)) {
+            throw new UnknownCodeError(`Expected bexter strb64 code, got ${this.code}`);
+        }
+    }
+    /** Base64 text payload value without CESR code prefix. */
+    get bext() {
+        return Bexter.derawify(this.raw, this.code);
+    }
+}
+/**
+ * Parse and hydrate a `Bexter` from txt/qb2 bytes.
+ *
+ * Boundary contract: parser chooses domain from `cold`, while this constructor
+ * enforces codex membership and exposes semantic `bext` accessors.
+ */
+export function parseBexter(input, cold) {
+    return new Bexter(parseMatter(input, cold));
 }

package/esm/src/primitives/blinder.js

@@ -1,23 +1,30 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { CtrDexV2 } from "../tables/counter-codex.js";
-import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
-const BLINDER_CODES = new Set([
-    CtrDexV2.BlindedStateQuadruples,
-    CtrDexV2.BigBlindedStateQuadruples,
-    CtrDexV2.BoundStateSextuples,
-    CtrDexV2.BigBoundStateSextuples,
-]);
-export function parseBlinder(input, version, cold) {
-    const parsed = parseAttachmentDispatch(input, version, cold);
-    if (!BLINDER_CODES.has(parsed.group.code)) {
-        throw new UnknownCodeError(`Expected blinder group code, got ${parsed.group.code}`);
+import { BLINDER_CODES } from "../tables/counter-groups.js";
+import { parseStructor, Structor } from "./structor.js";
+/** True when counter code belongs to blinded/bound state tuple families. */
+export function isBlinderCode(code) {
+    return BLINDER_CODES.has(code);
+}
+/**
+ * Blinded-state structor primitive.
+ *
+ * KERIpy substance: `Blinder` materializes blinded/bound state tuple groups
+ * used for blindable ACDC/TEL state disclosures.
+ */
+export class Blinder extends Structor {
+    constructor(init) {
+        const structor = init instanceof Structor ? init : new Structor(init);
+        super(structor);
+        if (!isBlinderCode(this.code)) {
+            throw new UnknownCodeError(`Expected blinder group code, got ${this.code}`);
+        }
+    }
+    /** Hydrate a `Blinder` from an already parsed counter-group node. */
+    static fromGroup(group, sourceDomain = "txt") {
+        return new Blinder({ 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 blinded-state attachment groups. */
+export function parseBlinder(input, version, cold) {
+    return new Blinder(parseStructor(input, version, cold, BLINDER_CODES, "blinder"));
 }

package/esm/src/primitives/cigar.js

@@ -1,18 +1,28 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
-export function parseCigar(input, cold) {
-    const matter = parseMatter(input, cold);
-    const name = MATTER_CODE_NAMES[matter.code] ?? "";
-    if (!name.endsWith("_Sig")) {
-        throw new UnknownCodeError(`Expected non-indexed signature code, got ${matter.code}`);
+import { CIGAR_CODES, matterCodexName } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Non-indexed signature primitive.
+ *
+ * KERIpy substance: `Cigar` wraps detached signature material where code
+ * determines signature suite and payload holds raw signature bytes.
+ */
+export class Cigar extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!CIGAR_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected non-indexed signature code, got ${this.code}`);
+        }
+    }
+    get sig() {
+        return this.raw;
+    }
+    get algorithm() {
+        return matterCodexName(this.code) ?? "UnknownSig";
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        sig: matter.raw,
-        algorithm: name,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `Cigar` from txt/qb2 bytes. */
+export function parseCigar(input, cold) {
+    return new Cigar(parseMatter(input, cold));
 }

package/esm/src/primitives/cipher.js

@@ -0,0 +1,18 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { CIPHER_X25519_ALL_CODES } from "./codex.js";
+import { Matter } from "./matter.js";
+/**
+ * Ciphertext primitive for encrypted secret payloads.
+ *
+ * KERIpy substance: cipher material carries encrypted seed/salt-like plaintext
+ * while code determines ciphertext family/size semantics.
+ */
+export class Cipher extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!CIPHER_X25519_ALL_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected cipher code, got ${this.code}`);
+        }
+    }
+}