cesr-ts 0.3.0 → 0.4.0

package/esm/src/primitives/codex.js

@@ -0,0 +1,74 @@
+import { codexValues, invertCodex } from "../tables/codex-utils.js";
+import { IdrDex, IdxBthSigDex, IdxCrtSigDex, IdxSigDex, } from "../tables/indexer.codex.generated.js";
+import { BexDex, CiXAllQB64Dex, CiXDex, CiXFixQB64Dex, CiXVarDex, CiXVarQB2Dex, CiXVarQB64Dex, CiXVarStrmDex, DecDex, DigDex, EscapeDex, LabelDex, MtrDex, NonceDex, NonTransDex, NumDex, PreDex, PreNonDigDex, TagDex, TexDex, } from "../tables/matter.codex.generated.js";
+import { TraitDex } from "../tables/trait.codex.generated.js";
+import { Protocols } from "../tables/versions.js";
+/**
+ * Derived readability layer over the generated KERIpy-parity codex objects.
+ *
+ * Canonical names such as `MtrDex`, `PreDex`, `DigDex`, and `IdrDex` are the
+ * primary source of truth. The sets exported here are convenience views for
+ * primitive-family validation and TS ergonomics.
+ */
+export { BexDex, CiXAllQB64Dex, CiXDex, CiXFixQB64Dex, CiXVarDex, CiXVarQB2Dex, CiXVarQB64Dex, CiXVarStrmDex, DecDex, DigDex, EscapeDex, IdrDex, IdxBthSigDex, IdxCrtSigDex, IdxSigDex, LabelDex, MtrDex, NonceDex, NonTransDex, NumDex, PreDex, PreNonDigDex, TagDex, TexDex, TraitDex, };
+export const BEXTER_CODES = codexValues(BexDex);
+export const TEXTER_CODES = codexValues(TexDex);
+export const DECIMAL_CODES = codexValues(DecDex);
+export const DIGEST_CODES = codexValues(DigDex);
+export const NONCE_CODES = codexValues(NonceDex);
+export const NUMBER_CODES = codexValues(NumDex);
+export const TAG_CODES = codexValues(TagDex);
+export const LABELER_CODES = codexValues(LabelDex);
+export const PREFIX_CODES = codexValues(PreDex);
+export const NON_TRANSFERABLE_PREFIX_CODES = codexValues(NonTransDex);
+export const NON_DIGEST_PREFIX_CODES = codexValues(PreNonDigDex);
+export const ESCAPE_CODES = codexValues(EscapeDex);
+export const CIPHER_X25519_VARIABLE_STREAM_CODES = codexValues(CiXVarStrmDex);
+export const CIPHER_X25519_QB64_VARIABLE_CODES = codexValues(CiXVarQB64Dex);
+export const CIPHER_X25519_FIXED_QB64_CODES = codexValues(CiXFixQB64Dex);
+export const CIPHER_X25519_ALL_QB64_CODES = codexValues(CiXAllQB64Dex);
+export const CIPHER_X25519_ALL_VARIABLE_CODES = codexValues(CiXVarDex);
+export const CIPHER_X25519_QB2_VARIABLE_CODES = codexValues(CiXVarQB2Dex);
+export const CIPHER_X25519_ALL_CODES = codexValues(CiXDex);
+export const INDEXER_CODES = codexValues(IdrDex);
+export const INDEXED_SIG_CODES = codexValues(IdxSigDex);
+export const INDEXED_CURRENT_SIG_CODES = codexValues(IdxCrtSigDex);
+export const INDEXED_BOTH_SIG_CODES = codexValues(IdxBthSigDex);
+export const VERFER_CODES = NON_DIGEST_PREFIX_CODES;
+export const SIGER_CODES = INDEXED_SIG_CODES;
+export const DATER_CODES = new Set([MtrDex.DateTime]);
+export const SEQNER_CODES = new Set([MtrDex.Salt_128]);
+export const ILKER_CODES = new Set([MtrDex.Tag3]);
+export const THOLDER_WEIGHTED_CODES = BEXTER_CODES;
+export const THOLDER_NUMERIC_CODES = NUMBER_CODES;
+export const THOLDER_CODES = new Set([
+    ...THOLDER_NUMERIC_CODES,
+    ...THOLDER_WEIGHTED_CODES,
+]);
+export const SIGNER_CODES = new Set([
+    MtrDex.Ed25519_Seed,
+    MtrDex.ECDSA_256k1_Seed,
+    MtrDex.ECDSA_256r1_Seed,
+]);
+export const SALTER_CODES = new Set([MtrDex.Salt_128]);
+export const ENCRYPTER_CODES = new Set([MtrDex.X25519]);
+export const DECRYPTER_CODES = new Set([MtrDex.X25519_Private]);
+export const CIGAR_CODES = new Set([
+    MtrDex.Ed25519_Sig,
+    MtrDex.ECDSA_256k1_Sig,
+    MtrDex.ECDSA_256r1_Sig,
+    MtrDex.Ed448_Sig,
+]);
+export const TRAIT_TAGS = new Set([
+    ...codexValues(TraitDex),
+]);
+export const VERSER_CODES = new Set([MtrDex.Tag7, MtrDex.Tag10]);
+export const VERSER_PROTOCOLS = new Set(Object.values(Protocols));
+const MATTER_CODEX_NAMES = invertCodex(MtrDex);
+export function matterCodexName(code) {
+    return MATTER_CODEX_NAMES.get(code);
+}
+/** KERI attribute-name validator used by Labeler semantic projection. */
+export function isAttLabel(value) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}

package/esm/src/primitives/compactor.js

@@ -1,12 +1,6 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { CtrDexV2 } from "../tables/counter-codex.js";
+import { COMPACTOR_CODES } from "../tables/counter-groups.js";
 import { parseMapperBody } from "./mapper.js";
-const COMPACTOR_CODES = new Set([
-    CtrDexV2.MapBodyGroup,
-    CtrDexV2.BigMapBodyGroup,
-    CtrDexV2.GenericMapGroup,
-    CtrDexV2.BigGenericMapGroup,
-]);
 export function parseCompactor(input, version, cold) {
     const mapper = parseMapperBody(input, version, cold);
     if (!COMPACTOR_CODES.has(mapper.code)) {

package/esm/src/primitives/counter.js

@@ -1,18 +1,24 @@
-import { b64ToInt, codeB2ToB64, codeB64ToB2, nabSextets, sceil, } from "../core/bytes.js";
-import { DeserializeError, ShortageError, UnknownCodeError, } from "../core/errors.js";
-import { COUNTER_HARDS } from "../tables/counter.tables.generated.js";
+import { b, b64ToInt, codeB2ToB64, codeB64ToB2, intToB64, nabSextets, sceil, } from "../core/bytes.js";
+import { DeserializeError, ShortageError, UnknownCodeError } from "../core/errors.js";
 import { resolveCounterCodeNameTable, resolveCounterSizeTable, } from "../tables/counter-version-registry.js";
+import { COUNTER_HARDS } from "../tables/counter.tables.generated.js";
 const COUNTER_BARDS = new Map([...COUNTER_HARDS.entries()].map(([code, hs]) => [
-    String.fromCharCode(codeB64ToB2(code)[0]) +
-        String.fromCharCode(codeB64ToB2(code)[1] ?? 0),
+    String.fromCharCode(codeB64ToB2(code)[0])
+        + String.fromCharCode(codeB64ToB2(code)[1] ?? 0),
     hs,
 ]));
+function isCounterData(value) {
+    return typeof value === "object" && value !== null
+        && "code" in value && "count" in value && "fullSize" in value
+        && "fullSizeB2" in value && "qb64" in value && "name" in value
+        && "version" in value;
+}
 function getTables(version) {
     const sizeTable = resolveCounterSizeTable(version);
     const nameTable = resolveCounterCodeNameTable(version);
     return { sizeTable, nameTable };
 }
-export function parseCounterFromText(input, version) {
+function parseCounterFromTextData(input, version) {
     const txt = String.fromCharCode(...input);
     if (txt.length === 0) {
         throw new ShortageError(1, 0);
@@ -27,7 +33,6 @@ export function parseCounterFromText(input, version) {
     const hard2 = txt.slice(0, 2);
     const hs = COUNTER_HARDS.get(hard2);
     if (!hs && txt.length < 4) {
-        // Counter hard selectors are at most 4 chars in current codex tables.
         throw new ShortageError(4, txt.length);
     }
     if (!hs) {
@@ -46,26 +51,28 @@ export function parseCounterFromText(input, version) {
     }
     const count = b64ToInt(txt.slice(sizage.hs, sizage.hs + sizage.ss));
     const name = nameTable[code] ?? "UnknownCounter";
+    const qb64 = txt.slice(0, sizage.fs);
     return {
         code,
         count,
         fullSize: sizage.fs,
         fullSizeB2: sceil((sizage.fs * 3) / 4),
-        qb64: txt.slice(0, sizage.fs),
+        qb64,
         name,
+        version,
     };
 }
-export function parseCounterFromBinary(input, version) {
+function parseCounterFromBinaryData(input, version) {
     if (input.length < 2) {
         throw new ShortageError(2, input.length);
     }
     const { sizeTable, nameTable } = getTables(version);
     const firstTwo = nabSextets(input, 2);
-    const key = String.fromCharCode(firstTwo[0]) +
-        String.fromCharCode(firstTwo[1] ?? 0);
+    const key = String.fromCharCode(firstTwo[0])
+        + String.fromCharCode(firstTwo[1] ?? 0);
     const hs = COUNTER_BARDS.get(key);
     if (!hs) {
-        throw new UnknownCodeError(`Unsupported qb2 counter start sextets`);
+        throw new UnknownCodeError("Unsupported qb2 counter start sextets");
     }
     const bhs = sceil((hs * 3) / 4);
     if (input.length < bhs) {
@@ -81,7 +88,7 @@ export function parseCounterFromBinary(input, version) {
         throw new ShortageError(bcs, input.length);
     }
     const qb64 = codeB2ToB64(input, sizage.fs);
-    const count = b64ToInt(qb64.slice(sizage.hs, sizage.fs));
+    const count = b64ToInt(qb64.slice(sizage.hs, sizage.hs + sizage.ss));
     const name = nameTable[code] ?? "UnknownCounter";
     return {
         code,
@@ -90,8 +97,191 @@ export function parseCounterFromBinary(input, version) {
         fullSizeB2: bcs,
         qb64,
         name,
+        version,
     };
 }
+function encodeCounterFromFields(code, count, version) {
+    const { sizeTable, nameTable } = getTables(version);
+    const sizage = sizeTable.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unsupported counter code for version: ${code}`);
+    }
+    if (!Number.isInteger(count) || count < 0 || count > 64 ** sizage.ss - 1) {
+        throw new DeserializeError(`Invalid count=${count} for code=${code}`);
+    }
+    const qb64 = `${code}${intToB64(count, sizage.ss)}`;
+    if (qb64.length !== sizage.fs) {
+        throw new DeserializeError(`Encoded counter size mismatch for ${code}: expected=${sizage.fs} got=${qb64.length}`);
+    }
+    return {
+        code,
+        count,
+        fullSize: sizage.fs,
+        fullSizeB2: sceil((sizage.fs * 3) / 4),
+        qb64,
+        name: nameTable[code] ?? "UnknownCounter",
+        version,
+    };
+}
+function parseCounterInit(init) {
+    const version = init.version ?? { major: 2, minor: 0 };
+    if (init.code !== undefined) {
+        const count = init.count
+            ?? (init.countB64 ? b64ToInt(init.countB64) : 0);
+        return encodeCounterFromFields(init.code, count, version);
+    }
+    if (init.qb64b) {
+        return parseCounterFromTextData(init.qb64b, version);
+    }
+    if (init.qb64) {
+        return parseCounterFromTextData(b(init.qb64), version);
+    }
+    if (init.qb2) {
+        return parseCounterFromBinaryData(init.qb2, version);
+    }
+    throw new DeserializeError("Counter requires code/count or qb64/qb64b/qb2 initialization");
+}
+/**
+ * Base CESR counter primitive.
+ *
+ * KERIpy substance: counters are first-class primitives that frame counted
+ * payload groups and carry versioned code-name semantics.
+ */
+export class Counter {
+    constructor(init) {
+        Object.defineProperty(this, "_code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_fullSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_fullSizeB2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_qb64", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const data = init instanceof Counter
+            ? init.toCounterData()
+            : isCounterData(init)
+                ? init
+                : parseCounterInit(init);
+        this._code = data.code;
+        this._count = data.count;
+        this._fullSize = data.fullSize;
+        this._fullSizeB2 = data.fullSizeB2;
+        this._qb64 = data.qb64;
+        this._name = data.name;
+        this._version = { ...data.version };
+    }
+    toCounterData() {
+        return {
+            code: this._code,
+            count: this._count,
+            fullSize: this._fullSize,
+            fullSizeB2: this._fullSizeB2,
+            qb64: this._qb64,
+            name: this._name,
+            version: { ...this._version },
+        };
+    }
+    get code() {
+        return this._code;
+    }
+    get count() {
+        return this._count;
+    }
+    get fullSize() {
+        return this._fullSize;
+    }
+    get fullSizeB2() {
+        return this._fullSizeB2;
+    }
+    get qb64() {
+        return this._qb64;
+    }
+    get qb64b() {
+        return b(this._qb64);
+    }
+    get qb2() {
+        return codeB64ToB2(this._qb64);
+    }
+    get name() {
+        return this._name;
+    }
+    get version() {
+        return { ...this._version };
+    }
+    equals(other) {
+        return this._qb64 === other.qb64;
+    }
+    toString() {
+        return this._qb64;
+    }
+}
+/**
+ * Parsed counter-group container with raw counted payload and hydrated entries.
+ *
+ * This is parser-facing structure used for primitive-graph attachment outputs.
+ */
+export class CounterGroup extends Counter {
+    constructor(counter, raw, items) {
+        super(counter);
+        Object.defineProperty(this, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "items", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.raw = raw.slice();
+        this.items = items;
+    }
+}
+/** Parse counter from text-domain CESR bytes using provided version context. */
+export function parseCounterFromText(input, version) {
+    return new Counter(parseCounterFromTextData(input, version));
+}
+/** Parse counter from binary-domain CESR bytes using provided version context. */
+export function parseCounterFromBinary(input, version) {
+    return new Counter(parseCounterFromBinaryData(input, version));
+}
+/** Parse counter using domain hint (`txt` or `bny`) and versioned codex tables. */
 export function parseCounter(input, version, cold) {
     return cold === "bny"
         ? parseCounterFromBinary(input, version)

package/esm/src/primitives/dater.js

@@ -1,22 +1,37 @@
 import { UnknownCodeError } from "../core/errors.js";
-import { parseMatter } from "./matter.js";
-import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
+import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { DATER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/** Project compact CESR datetime encoding to RFC3339/ISO-8601 text form. */
 function toIso8601(dts) {
     return dts.replaceAll("c", ":").replaceAll("d", ".").replaceAll("p", "+");
 }
-export function parseDater(input, cold) {
-    const matter = parseMatter(input, cold);
-    const name = MATTER_CODE_NAMES[matter.code];
-    if (name !== "DateTime") {
-        throw new UnknownCodeError(`Expected dater DateTime code, got ${matter.code}`);
+/**
+ * Datetime primitive for compact RFC3339/ISO-8601 representations.
+ *
+ * KERIpy substance: `Dater` encodes datetime text by substituting non-base64
+ * characters (`:`, `.`, `+`) with base64-safe symbols (`c`, `d`, `p`).
+ */
+export class Dater extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!DATER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected dater DateTime code, got ${this.code}`);
+        }
+    }
+    get dts() {
+        const sizage = MATTER_SIZES.get(this.code);
+        if (!sizage) {
+            throw new UnknownCodeError(`Unknown dater code ${this.code}`);
+        }
+        return this.qb64.slice(sizage.hs);
+    }
+    get iso8601() {
+        return toIso8601(this.dts);
     }
-    const dts = new TextDecoder().decode(matter.raw);
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        dts,
-        iso8601: toIso8601(dts),
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+}
+/** Parse and hydrate `Dater` from txt/qb2 bytes. */
+export function parseDater(input, cold) {
+    return new Dater(parseMatter(input, cold));
 }

package/esm/src/primitives/decimer.js

@@ -0,0 +1,65 @@
+import { concatBytes, decodeB64, encodeB64 } from "../core/bytes.js";
+import { UnknownCodeError } from "../core/errors.js";
+import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { DECIMAL_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/** Decode variable-sized decimal payload bytes into decimal-string form. */
+function derawifyDns(raw, code) {
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown decimer code ${code}`);
+    }
+    const body = encodeB64(concatBytes(new Uint8Array(sizage.ls), raw));
+    const ws = sizage.ls === 0 && body.startsWith("A") ? 1 : (sizage.ls + 1) % 4;
+    return body.slice(ws).replaceAll("p", ".");
+}
+/** Encode decimal-string form into CESR raw bytes for decimal codes. */
+function rawifyDns(dns) {
+    const encoded = dns.replaceAll(".", "p");
+    const ts = encoded.length % 4;
+    const ws = (4 - ts) % 4;
+    const ls = (3 - ts) % 3;
+    return decodeB64("A".repeat(ws) + encoded).slice(ls);
+}
+/**
+ * CESR decimal primitive aligned with KERIpy `Decimer`.
+ *
+ * Supports hydration from existing qualified material or direct decimal input
+ * (`dns`/`decimal`) when raw material is not provided.
+ */
+export class Decimer extends Matter {
+    constructor(init) {
+        if (!(init instanceof Matter)
+            && !init.raw
+            && !init.qb64
+            && !init.qb64b
+            && !init.qb2
+            && (init.dns !== undefined || init.decimal !== undefined)) {
+            const dns = init.dns ?? `${init.decimal}`;
+            super({
+                ...init,
+                raw: rawifyDns(dns),
+                code: init.code ?? "4H",
+            });
+        }
+        else {
+            const matter = init instanceof Matter ? init : new Matter(init);
+            super(matter);
+        }
+        if (!DECIMAL_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected decimal code, got ${this.code}`);
+        }
+    }
+    /** Decimal string form (roundtrippable CESR decimal representation). */
+    get dns() {
+        return derawifyDns(this.raw, this.code);
+    }
+    /** Convenience numeric projection of `.dns` for consumer-side arithmetic. */
+    get decimal() {
+        return Number(this.dns);
+    }
+}
+/** Parse and hydrate a `Decimer` from txt or qb2 stream bytes. */
+export function parseDecimer(input, cold) {
+    return new Decimer(parseMatter(input, cold));
+}

package/esm/src/primitives/decrypter.js

@@ -0,0 +1,18 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { DECRYPTER_CODES } from "./codex.js";
+import { Matter } from "./matter.js";
+/**
+ * Private-key decryption primitive for asymmetric envelope payloads.
+ *
+ * KERIpy substance: decrypter material is private X25519 key material used to
+ * recover plaintext from cipher envelopes (often derived from signing seeds).
+ */
+export class Decrypter extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!DECRYPTER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected decrypter key code, got ${this.code}`);
+        }
+    }
+}

package/esm/src/primitives/diger.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, matterCodexName } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+/**
+ * Digest primitive family.
+ *
+ * KERIpy substance: `Diger` encapsulates self-addressing digest material and
+ * optionally constrains codes to digest codex membership (`strict=true`).
+ */
+export class Diger extends Matter {
+    constructor(init, options = {}) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if ((options.strict ?? true) && !DIGEST_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected digest code, got ${this.code}`);
+        }
+    }
+    get digest() {
+        return this.raw;
+    }
+    get algorithm() {
+        return matterCodexName(this.code) ?? "UnknownDigest";
+    }
 }
+/** Parse and hydrate `Diger` from txt/qb2 bytes. */
 export function parseDiger(input, cold) {
-    const matter = parseMatter(input, cold);
-    const name = MATTER_CODE_NAMES[matter.code] ?? "";
-    if (!isDigestName(name)) {
-        throw new UnknownCodeError(`Expected digest code, got ${matter.code}`);
-    }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        digest: matter.raw,
-        algorithm: name,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-    };
+    return new Diger(parseMatter(input, cold));
 }

package/esm/src/primitives/encrypter.js

@@ -0,0 +1,19 @@
+import { UnknownCodeError } from "../core/errors.js";
+import { ENCRYPTER_CODES } from "./codex.js";
+import { Matter } from "./matter.js";
+/**
+ * Public-key encryption primitive for asymmetric envelope encryption.
+ *
+ * KERIpy substance: Encrypter uses public key material (typically X25519,
+ * optionally derived from verifier keys) to produce ciphertext envelopes.
+ * This TS class validates material type; encryption ops live in crypto layers.
+ */
+export class Encrypter extends Matter {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!ENCRYPTER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected encrypter key code, got ${this.code}`);
+        }
+    }
+}

package/esm/src/primitives/ilker.js

@@ -1,15 +1,27 @@
 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}`);
+import { ILKER_CODES } from "./codex.js";
+import { Matter, parseMatter } from "./matter.js";
+import { Tagger } from "./tagger.js";
+/**
+ * Message-type primitive (`ilk`) encoded via Tagger compact tag semantics.
+ *
+ * KERIpy semantics: `Ilker` is restricted to Tag3 (`X`) values that carry
+ * compact Base64 ilk identifiers.
+ */
+export class Ilker extends Tagger {
+    constructor(init) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        super(matter);
+        if (!ILKER_CODES.has(this.code)) {
+            throw new UnknownCodeError(`Expected ilker Tag3 code, got ${this.code}`);
+        }
+    }
+    /** Decoded ilk value (alias of tag payload for this subclass). */
+    get ilk() {
+        return this.tag;
     }
-    return {
-        code: matter.code,
-        qb64: matter.qb64,
-        fullSize: matter.fullSize,
-        fullSizeB2: matter.fullSizeB2,
-        ilk: matter.qb64.slice(matter.code.length),
-    };
+}
+/** Parse and hydrate `Ilker` from txt/qb2 bytes. */
+export function parseIlker(input, cold) {
+    return new Ilker(parseMatter(input, cold));
 }