cesr-ts 0.4.0 → 0.6.0

package/esm/src/primitives/diger.js

@@ -1,16 +1,25 @@
+import { blake2b, blake2s } from "@noble/hashes/blake2";
+import { blake3 } from "@noble/hashes/blake3";
+import { sha256, sha512 } from "@noble/hashes/sha2";
+import { sha3_256, sha3_512 } from "@noble/hashes/sha3";
 import { UnknownCodeError } from "../core/errors.js";
-import { DIGEST_CODES, matterCodexName } from "./codex.js";
+import { DigDex, 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`).
+ *
+ * Maintainer note:
+ * `DigDex` remains the canonical namespace of supported digest codes, but this
+ * class is the runtime authority for "code -> hash implementation" dispatch.
+ * Keep new digest algorithms centralized here so `Saider`, `Serder`, and app
+ * flows do not grow their own private digest switches.
  */
 export class Diger extends Matter {
     constructor(init, options = {}) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if ((options.strict ?? true) && !DIGEST_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected digest code, got ${this.code}`);
         }
@@ -21,7 +30,52 @@ export class Diger extends Matter {
     get algorithm() {
         return matterCodexName(this.code) ?? "UnknownDigest";
     }
+    /** Compute raw digest bytes for `ser` using the digest family selected by `code`. */
+    static digest(ser, code) {
+        const digest = Diger.Digests.get(code);
+        if (!digest) {
+            throw new UnknownCodeError(`Unsupported digest code ${code}`);
+        }
+        return digest(ser);
+    }
+    verify(ser) {
+        return Diger.compare(ser, this.code, this.raw);
+    }
+    /** Compare `ser` against either the instance digest or an override digest. */
+    compare(ser, dig) {
+        return Diger.compare(ser, this.code, dig ?? this.raw);
+    }
+    /** Constant-shape byte comparison helper used by higher-level SAID/serder verification. */
+    static compare(ser, code, dig) {
+        const actual = Diger.digest(ser, code);
+        if (actual.length !== dig.length) {
+            return false;
+        }
+        for (let idx = 0; idx < actual.length; idx++) {
+            if (actual[idx] !== dig[idx]) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
+/** Shared KERIpy-style digest registry keyed by canonical `DigDex` values. */
+Object.defineProperty(Diger, "Digests", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: new Map([
+        [DigDex.Blake3_256, (ser) => blake3(ser)],
+        [DigDex.Blake3_512, (ser) => blake3(ser, { dkLen: 64 })],
+        [DigDex.Blake2b_256, (ser) => blake2b(ser, { dkLen: 32 })],
+        [DigDex.Blake2b_512, (ser) => blake2b(ser, { dkLen: 64 })],
+        [DigDex.Blake2s_256, (ser) => blake2s(ser, { dkLen: 32 })],
+        [DigDex.SHA2_256, (ser) => sha256(ser)],
+        [DigDex.SHA2_512, (ser) => sha512(ser)],
+        [DigDex.SHA3_256, (ser) => sha3_256(ser)],
+        [DigDex.SHA3_512, (ser) => sha3_512(ser)],
+    ])
+});
 /** Parse and hydrate `Diger` from txt/qb2 bytes. */
 export function parseDiger(input, cold) {
     return new Diger(parseMatter(input, cold));

package/esm/src/primitives/disclosure.js

@@ -0,0 +1,300 @@
+/**
+ * Fixed-field graduated-disclosure workflow helpers.
+ *
+ * This module is the verb layer for the fixed-field blinded disclosure records
+ * defined in `structing.ts`.
+ *
+ * Keep the boundary clear:
+ * - `structing.ts` owns the nouns and representation conversions
+ * - this file owns deterministic UUID derivation, blind/bound/media
+ *   commitment recomputation, and candidate unblinding search
+ * - `blinder.ts` / `mediar.ts` own counted-group transport framing only
+ *
+ * This is intentionally different from KERIpy's richer `Blinder` /
+ * `Mediar` classes. `keri-ts` keeps semantic records as plain data and puts
+ * workflow verbs in a dedicated module so schema and workflow can evolve
+ * independently.
+ */
+import { b } from "../core/bytes.js";
+import { DigDex, DIGEST_CODES, NonceDex } from "./codex.js";
+import { Diger } from "./diger.js";
+import { Labeler } from "./labeler.js";
+import { Noncer } from "./noncer.js";
+import { NumberPrimitive } from "./number.js";
+import { Salter } from "./salter.js";
+import { BlindState, BoundState, TypeMedia, } from "./structing.js";
+import { Texter } from "./texter.js";
+/** Normalize `Number`-like input into the KERIpy `numh` hex string projection. */
+function coerceNumh(value) {
+    if (value instanceof NumberPrimitive) {
+        return value.numh;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new TypeError(`Expected non-negative integer number, got ${value}`);
+        }
+        return BigInt(value).toString(16);
+    }
+    if (value < 0n) {
+        throw new TypeError(`Expected non-negative bigint, got ${value}`);
+    }
+    return value.toString(16);
+}
+/** Normalize nonce-like input into crew/SAD text while preserving empty placeholders. */
+function coerceNonceText(value) {
+    if (value instanceof Noncer) {
+        return value.nonce;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return "";
+}
+/** Normalize label-like input into label text while preserving empty placeholders. */
+function coerceLabelText(value) {
+    if (value instanceof Labeler) {
+        return value.text;
+    }
+    return value ?? "";
+}
+/** Normalize text-like input into plain text while preserving empty placeholders. */
+function coerceTexterText(value) {
+    if (value instanceof Texter) {
+        return value.text;
+    }
+    return value ?? "";
+}
+/**
+ * Require a non-empty disclosure UUID, deriving one when omitted.
+ *
+ * Maintainer rule:
+ * - placeholder semantics apply to blinded record fields
+ * - they do not apply to the disclosure UUID itself, because the UUID scopes
+ *   the blind/unblind computation
+ */
+function ensurePresentUuid(value, options) {
+    if (value instanceof Noncer) {
+        if (value.code === NonceDex.Empty) {
+            throw new TypeError("Disclosure UUID may not be empty.");
+        }
+        return value;
+    }
+    if (typeof value === "string") {
+        const nonce = new Noncer({ qb64: value });
+        if (nonce.code === NonceDex.Empty) {
+            throw new TypeError("Disclosure UUID may not be empty.");
+        }
+        return nonce;
+    }
+    return makeBlindUuid(options);
+}
+/** Choose the digest/noncer code used for the recomputed commitment field `d`. */
+function effectiveDisclosureCode(current, code) {
+    if (code !== undefined) {
+        return code;
+    }
+    return DIGEST_CODES.has(current.code) ? current.code : DigDex.Blake3_256;
+}
+/**
+ * Recompute the committed `d` field for one fixed-field disclosure record.
+ *
+ * Parity rule:
+ * - the commitment is computed from tuple `qb64` field serializations with a
+ *   dummied `d` slot
+ * - it is not computed from crew/SAD strings
+ *
+ * This mirrors the saidive/makify behavior KERIpy gets through `Structor`.
+ */
+function computeDisclosureNonce(descriptor, value, code) {
+    const effectiveCode = effectiveDisclosureCode(value.d, code);
+    const tuple = descriptor.toTuple(value);
+    // Fixed-field disclosure commitments work over canonical primitive tuple
+    // bytes. Crew/SAD projections are for readability and object transport, not
+    // for commitment material.
+    const ser = descriptor.fields.map((field, index) => field === "d"
+        ? "#".repeat(Noncer.fullSizeForCode(effectiveCode))
+        : tuple[index].qb64).join("");
+    return new Noncer({
+        code: effectiveCode,
+        raw: Diger.digest(b(ser), effectiveCode),
+    });
+}
+/** Rebuild the record with a freshly committed `d` field. */
+function saidifyDisclosureRecord(descriptor, value, code) {
+    const d = computeDisclosureNonce(descriptor, value, code);
+    return descriptor.fromSad({
+        ...descriptor.toSad(value),
+        d: d.nonce,
+    });
+}
+/**
+ * Derive the deterministic disclosure UUID used by blinded/bound/media
+ * commitment records.
+ *
+ * KERIpy correspondence:
+ * - mirrors `Blinder.makeUUID(...)`
+ * - sequence numbers feed the salty path through `numh`, not decimal text
+ */
+export function makeBlindUuid({ raw, salt, sn = 1, tier, } = {}) {
+    const salter = salt !== undefined || raw !== undefined || tier !== undefined
+        ? new Salter({ qb64: salt, raw, tier })
+        : new Salter({});
+    return new Noncer({
+        code: NonceDex.Salt_256,
+        raw: salter.stretch({ path: coerceNumh(sn), tier }),
+    });
+}
+/**
+ * Recompute the committed `d` field for one `BlindState`.
+ *
+ * KERIpy correspondence:
+ * - same semantic role as building `Blinder(..., makify=True)` for the
+ *   blind-state quadruple without instantiating a transport wrapper
+ */
+export function commitBlindState(value, code) {
+    return saidifyDisclosureRecord(BlindState, value, code);
+}
+/**
+ * Recompute the committed `d` field for one `BoundState`.
+ *
+ * KERIpy correspondence:
+ * - same semantic role as the bound-state branch of `Blinder.blind(...)`
+ */
+export function commitBoundState(value, code) {
+    return saidifyDisclosureRecord(BoundState, value, code);
+}
+/**
+ * Recompute the committed `d` field for one `TypeMedia`.
+ *
+ * KERIpy correspondence:
+ * - same semantic role as `Mediar(..., makify=True)` for typed-media records
+ */
+export function commitTypeMedia(value, code) {
+    return saidifyDisclosureRecord(TypeMedia, value, code);
+}
+/**
+ * Build one blinded disclosure-state record and compute its `d` commitment.
+ *
+ * KERIpy correspondence:
+ * - mirrors `Blinder.blind(..., bound=False)`
+ */
+export function makeBlindState({ uuid, raw, salt, sn = 1, tier, acdc = "", state = "", code, } = {}) {
+    return commitBlindState(BlindState.fromSad({
+        d: "",
+        u: ensurePresentUuid(uuid, { raw, salt, sn, tier }).nonce,
+        td: coerceNonceText(acdc),
+        ts: coerceLabelText(state),
+    }), code);
+}
+/**
+ * Build one bound blinded-state record and compute its `d` commitment.
+ *
+ * KERIpy correspondence:
+ * - mirrors `Blinder.blind(..., bound=True)`
+ */
+export function makeBoundState({ uuid, raw, salt, sn = 1, tier, acdc = "", state = "", bsn = 0, bd = "", code, } = {}) {
+    return commitBoundState(BoundState.fromSad({
+        d: "",
+        u: ensurePresentUuid(uuid, { raw, salt, sn, tier }).nonce,
+        td: coerceNonceText(acdc),
+        ts: coerceLabelText(state),
+        bn: coerceNumh(bsn),
+        bd: coerceNonceText(bd),
+    }), code);
+}
+/**
+ * Build one typed-media disclosure record and compute its `d` commitment.
+ *
+ * KERIpy correspondence:
+ * - matches `Mediar(..., makify=True)` without recreating a wrapper object
+ */
+export function makeTypeMedia({ uuid, raw, salt, sn = 1, tier, mt = "", mv = "", code, } = {}) {
+    return commitTypeMedia(TypeMedia.fromSad({
+        d: "",
+        u: ensurePresentUuid(uuid, { raw, salt, sn, tier }).nonce,
+        mt: coerceLabelText(mt),
+        mv: coerceTexterText(mv),
+    }), code);
+}
+/**
+ * Rebuild the matching blinded-state candidate if one exists.
+ *
+ * KERIpy correspondence:
+ * - mirrors `Blinder.unblind(..., bound=False)`
+ * - tries the placeholder combinations too, so callers do not need to add the
+ *   empty `acdc` / empty `state` cases themselves
+ *
+ * Search strategy:
+ * - derive or validate the UUID
+ * - try the candidate `acdc` plus empty placeholder
+ * - try each caller-supplied state plus empty placeholder
+ * - return the first candidate whose recomputed `d` matches `said`
+ */
+export function unblindBlindState({ said, uuid, raw, salt, sn = 1, tier, acdc = "", states = [], code, }) {
+    const resolvedUuid = ensurePresentUuid(uuid, { raw, salt, sn, tier });
+    const acdcs = [...new Set([coerceNonceText(acdc), ""])];
+    const stateTexts = [...new Set(states.map(coerceLabelText).concat(""))];
+    // KERIpy search semantics intentionally treat empty ACDC/state placeholders
+    // as real candidates, because a disclosure may reveal them later or keep
+    // them compact for the current step.
+    for (const td of acdcs) {
+        for (const ts of stateTexts) {
+            const candidate = makeBlindState({
+                uuid: resolvedUuid,
+                acdc: td,
+                state: ts,
+                code,
+            });
+            if (candidate.d.nonce === said) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Rebuild the matching bound blinded-state candidate if one exists.
+ *
+ * KERIpy correspondence:
+ * - mirrors `Blinder.unblind(..., bound=True)`
+ * - tries placeholder bound pairs automatically by including `(0, "")`
+ *
+ * Search strategy:
+ * - same placeholder search as `unblindBlindState(...)`
+ * - plus candidate `(bn, bd)` pairs, with placeholder `(0, "")` always added
+ */
+export function unblindBoundState({ said, uuid, raw, salt, sn = 1, tier, acdc = "", states = [], bounds = [], code, }) {
+    const resolvedUuid = ensurePresentUuid(uuid, { raw, salt, sn, tier });
+    const acdcs = [...new Set([coerceNonceText(acdc), ""])];
+    const stateTexts = [...new Set(states.map(coerceLabelText).concat(""))];
+    // Placeholder bound pairs matter for parity with KERIpy's partially revealed
+    // disclosure states, so the search space always includes `(0, "")`.
+    const normalizedBounds = [
+        ...bounds.map(([bsn, bd]) => [coerceNumh(bsn), coerceNonceText(bd)]),
+        ["0", ""],
+    ];
+    const uniqueBounds = [
+        ...new Map(normalizedBounds.map((bound) => [`${bound[0]}:${bound[1]}`, bound])).values(),
+    ];
+    for (const [bn, bd] of uniqueBounds) {
+        for (const td of acdcs) {
+            for (const ts of stateTexts) {
+                const candidate = makeBoundState({
+                    uuid: resolvedUuid,
+                    acdc: td,
+                    state: ts,
+                    bsn: bn,
+                    bd,
+                    code,
+                });
+                if (candidate.d.nonce === said) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    return null;
+}

package/esm/src/primitives/encrypter.js

@@ -1,19 +1,142 @@
-import { UnknownCodeError } from "../core/errors.js";
-import { ENCRYPTER_CODES } from "./codex.js";
+import { bytesEqual } from "../core/bytes.js";
+import { DeserializeError, UnknownCodeError } from "../core/errors.js";
+import { normalizeByteLike } from "./byte-like.js";
+import { Cipher } from "./cipher.js";
+import { CIPHER_X25519_ALL_QB64_CODES, CIPHER_X25519_QB2_VARIABLE_CODES, CIPHER_X25519_VARIABLE_STREAM_CODES, ENCRYPTER_CODES, MtrDex, } from "./codex.js";
 import { Matter } from "./matter.js";
+import { isQualifiedPrimitive } from "./primitive.js";
+import { Salter } from "./salter.js";
+import { boxKeyPairFromEd25519Seed, boxPublicKeyFromEd25519Verfer, sealBox } from "./sealed-box.js";
+import { Signer } from "./signer.js";
+import { Streamer } from "./streamer.js";
+import { Verfer } from "./verfer.js";
+/** Normalize direct X25519 or derived-Ed25519 constructor forms into `Matter` input. */
+function normalizeMatterInit(init) {
+    if (init instanceof Matter) {
+        return init;
+    }
+    const normalized = {
+        code: init.code ?? MtrDex.X25519,
+    };
+    if (init.raw) {
+        normalized.raw = normalizeByteLike(init.raw);
+    }
+    else if (init.verkey) {
+        const verfer = new Verfer({ qb64b: normalizeByteLike(init.verkey) });
+        if (verfer.code !== MtrDex.Ed25519
+            && verfer.code !== MtrDex.Ed25519N) {
+            throw new DeserializeError(`Unsupported verkey derivation code = ${verfer.code}.`);
+        }
+        normalized.raw = boxPublicKeyFromEd25519Verfer(verfer.raw);
+    }
+    else if (init.qb64b) {
+        normalized.qb64b = normalizeByteLike(init.qb64b);
+    }
+    else if (init.qb64) {
+        const qb64 = normalizeByteLike(init.qb64);
+        normalized.qb64b = qb64;
+    }
+    else if (init.qb2) {
+        normalized.qb2 = normalizeByteLike(init.qb2);
+    }
+    return normalized;
+}
 /**
  * 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.
+ * KERIpy substance: `Encrypter` owns the public X25519 material and can derive
+ * it from Ed25519 verifier keys used by non-transferable/basic AIDs.
  */
 export class Encrypter extends Matter {
+    /**
+     * Construct one X25519 public-key encrypter.
+     *
+     * Default code remains the KERIpy public-box family `MtrDex.X25519`.
+     */
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(normalizeMatterInit(init));
         if (!ENCRYPTER_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected encrypter key code, got ${this.code}`);
         }
     }
+    /**
+     * Confirm whether the supplied Ed25519 seed maps to this X25519 public key.
+     *
+     * Boundary contract:
+     * - only Ed25519 signer seeds are accepted here
+     * - the check proves that the seed belongs to the AEID/verkey that was used
+     *   to derive this encrypter's public box key
+     */
+    verifySeed(seed) {
+        const signer = new Signer({ qb64b: normalizeByteLike(seed) });
+        if (signer.code !== MtrDex.Ed25519_Seed) {
+            return false;
+        }
+        return bytesEqual(boxKeyPairFromEd25519Seed(signer.raw).publicKey, this.raw);
+    }
+    /**
+     * Encrypt raw or primitive plaintext into one CESR `Cipher`.
+     *
+     * KERIpy parity:
+     * - `ser` wins when supplied
+     * - otherwise one primitive is required
+     * - omitted `code` defaults to stream-family `L0` only for raw `ser` input
+     *
+     * Plaintext-family rules:
+     * - `Salter` and `Signer` may infer fixed qb64 cipher families when `code`
+     *   is omitted
+     * - other primitives require an explicit family so decrypt-time hydration
+     *   knows whether the plaintext was stored as qb64, qb2, or a sniffable
+     *   stream
+     */
+    encrypt({ ser, prim, code } = {}) {
+        let plaintext = ser
+            ? normalizeByteLike(ser)
+            : undefined;
+        let cipherCode = code;
+        if (!plaintext) {
+            if (!prim) {
+                throw new DeserializeError("Neither plaintext serialization nor primitive input was provided.");
+            }
+            if (!cipherCode) {
+                if (prim instanceof Salter) {
+                    cipherCode = MtrDex.X25519_Cipher_Salt;
+                }
+                else if (prim instanceof Signer) {
+                    cipherCode = MtrDex.X25519_Cipher_Seed;
+                }
+                else {
+                    throw new DeserializeError(`Unsupported primitive ${prim instanceof Streamer ? "streamer" : `with code = ${prim.code}`} when cipher code is missing.`);
+                }
+            }
+            if (CIPHER_X25519_ALL_QB64_CODES.has(cipherCode)) {
+                if (!isQualifiedPrimitive(prim)) {
+                    throw new DeserializeError(`Invalid primitive cipher code = ${cipherCode} for stream primitive.`);
+                }
+                plaintext = prim.qb64b;
+            }
+            else if (CIPHER_X25519_QB2_VARIABLE_CODES.has(cipherCode)) {
+                if (!isQualifiedPrimitive(prim)) {
+                    throw new DeserializeError(`Invalid primitive cipher code = ${cipherCode} for stream primitive.`);
+                }
+                plaintext = prim.qb2;
+            }
+            else if (CIPHER_X25519_VARIABLE_STREAM_CODES.has(cipherCode)) {
+                if (!(prim instanceof Streamer)) {
+                    throw new DeserializeError(`Invalid primitive cipher code = ${cipherCode} for non-stream primitive.`);
+                }
+                plaintext = prim.stream;
+            }
+            else {
+                throw new UnknownCodeError(`Invalid primitive cipher code = ${cipherCode}.`);
+            }
+        }
+        if (!plaintext) {
+            throw new DeserializeError("Missing plaintext serialization for encryption.");
+        }
+        return new Cipher({
+            code: cipherCode ?? MtrDex.X25519_Cipher_L0,
+            raw: sealBox(plaintext, this.raw),
+        });
+    }
 }

package/esm/src/primitives/hydrate.js

@@ -0,0 +1,49 @@
+import { Cigar } from "./cigar.js";
+import { CIGAR_CODES, DATER_CODES, DECIMAL_CODES, NONCE_CODES, SIGER_CODES } from "./codex.js";
+import { Dater } from "./dater.js";
+import { Decimer } from "./decimer.js";
+import { Indexer, parseIndexer } from "./indexer.js";
+import { Matter, parseMatter } from "./matter.js";
+import { Noncer } from "./noncer.js";
+import { Siger } from "./siger.js";
+/**
+ * Hydrate one low-level `Matter` into the narrowest safe primitive class.
+ *
+ * Maintainer rule:
+ * this is intentionally conservative, not aggressive. Many CESR codes are
+ * semantically overloaded across families (`0A`, `B`, `E`, tag/label codes,
+ * numeric threshold codes, etc.), so generic callers should only get an
+ * automatic narrowing when the code family is genuinely unambiguous.
+ */
+export function hydrateMatter(init) {
+    const matter = init instanceof Matter ? init : new Matter(init);
+    if (DECIMAL_CODES.has(matter.code)) {
+        return new Decimer(matter);
+    }
+    if (DATER_CODES.has(matter.code)) {
+        return new Dater(matter);
+    }
+    if (CIGAR_CODES.has(matter.code)) {
+        return new Cigar(matter);
+    }
+    if (NONCE_CODES.has(matter.code)) {
+        return new Noncer(matter);
+    }
+    return matter;
+}
+/** Parse one text/binary matter token and hydrate it through `hydrateMatter()`. */
+export function parseQualifiedMatter(input, cold) {
+    return hydrateMatter(parseMatter(input, cold));
+}
+/** Hydrate one low-level `Indexer` into the narrowest safe primitive class. */
+export function hydrateIndexer(init) {
+    const indexer = init instanceof Indexer ? init : new Indexer(init);
+    if (SIGER_CODES.has(indexer.code)) {
+        return new Siger(indexer);
+    }
+    return indexer;
+}
+/** Parse one text/binary indexer token and hydrate it through `hydrateIndexer()`. */
+export function parseQualifiedIndexer(input, cold) {
+    return hydrateIndexer(parseIndexer(input, cold));
+}

package/esm/src/primitives/ilker.js

@@ -1,6 +1,6 @@
 import { UnknownCodeError } from "../core/errors.js";
 import { ILKER_CODES } from "./codex.js";
-import { Matter, parseMatter } from "./matter.js";
+import { parseMatter } from "./matter.js";
 import { Tagger } from "./tagger.js";
 /**
  * Message-type primitive (`ilk`) encoded via Tagger compact tag semantics.
@@ -10,8 +10,7 @@ import { Tagger } from "./tagger.js";
  */
 export class Ilker extends Tagger {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!ILKER_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected ilker Tag3 code, got ${this.code}`);
         }