cesr-ts 0.4.0 → 0.6.0

package/esm/src/primitives/matter.js

@@ -1,6 +1,11 @@
-import { b, b64ToInt, codeB2ToB64, codeB64ToB2, concatBytes, decodeB64, encodeB64, intToB64, nabSextets, sceil, } from "../core/bytes.js";
+import { b, b64ToInt, bytesEqual, codeB2ToB64, codeB64ToB2, concatBytes, decodeB64, encodeB64, intToB64, nabSextets, sceil, } from "../core/bytes.js";
 import { DeserializeError, ShortageError, UnknownCodeError } from "../core/errors.js";
-import { MATTER_HARDS, MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { MATTER_CODE_NAMES, MATTER_HARDS, MATTER_SIZES } from "../tables/matter.tables.generated.js";
+import { DIGEST_CODES, NON_TRANSFERABLE_CODES, PREFIX_CODES } from "./codex.js";
+const SMALL_VAR_SELECTORS = ["4", "5", "6"];
+const LARGE_VAR_SELECTORS = ["7", "8", "9"];
+const MATTER_PAD = "_";
+const MATTER_CODE_NAMES_BY_CODE = MATTER_CODE_NAMES;
 const MATTER_BARDS = new Map([...MATTER_HARDS.entries()].map(([code, hs]) => [
     String.fromCharCode(codeB64ToB2(code)[0]),
     hs,
@@ -14,6 +19,54 @@ function isMatterData(value) {
         && "fullSize" in value
         && "fullSizeB2" in value;
 }
+function rawSizeForCode(code) {
+    const sizage = sizageForCode(code);
+    if (sizage.fs === null) {
+        throw new DeserializeError(`Non-fixed raw size for code ${code}.`);
+    }
+    const cs = sizage.hs + sizage.ss;
+    return Math.floor(((sizage.fs - cs) * 3) / 4) - sizage.ls;
+}
+function sizageForCode(code) {
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage) {
+        throw new UnknownCodeError(`Unknown matter code ${code}`);
+    }
+    return sizage;
+}
+function matterNameForCode(code) {
+    const name = MATTER_CODE_NAMES_BY_CODE[code];
+    if (!name) {
+        throw new UnknownCodeError(`Unknown matter code ${code}`);
+    }
+    return name;
+}
+function normalizeVariableMatterCode(code, raw) {
+    const sizage = MATTER_SIZES.get(code);
+    if (!sizage || sizage.fs !== null) {
+        return code;
+    }
+    const selector = code[0];
+    const leadSize = (3 - (raw.length % 3)) % 3;
+    const size = (raw.length + leadSize) / 3;
+    if (SMALL_VAR_SELECTORS.includes(selector)) {
+        if (size <= (64 ** 2) - 1) {
+            return `${SMALL_VAR_SELECTORS[leadSize]}${code.slice(1, 2)}`;
+        }
+        if (size <= (64 ** 4) - 1) {
+            return `${LARGE_VAR_SELECTORS[leadSize]}AA${code.slice(1, 2)}`;
+        }
+        throw new DeserializeError(`Unsupported variable raw size for ${code}: ${raw.length}.`);
+    }
+    if (LARGE_VAR_SELECTORS.includes(selector)) {
+        if (size <= (64 ** 4) - 1) {
+            return `${LARGE_VAR_SELECTORS[leadSize]}${code.slice(1, 4)}`;
+        }
+        throw new DeserializeError(`Unsupported variable raw size for large ${code}: ${raw.length}.`);
+    }
+    throw new DeserializeError(`Unsupported variable raw-size family for ${code}.`);
+}
+/** Resolve the effective matter code from the text-domain hard-selector prefix. */
 function parseMatterCodeFromText(txt) {
     const hs = MATTER_HARDS.get(txt[0]);
     if (!hs) {
@@ -32,6 +85,7 @@ function parseMatterCodeFromText(txt) {
     }
     return { code, hs: sizage.hs };
 }
+/** Inhale one text-domain CESR primitive into normalized matter data fields. */
 function parseMatterFromTextData(input) {
     const txt = String.fromCharCode(...input);
     if (txt.length === 0) {
@@ -57,6 +111,7 @@ function parseMatterFromTextData(input) {
         fullSizeB2: sceil((fullSize * 3) / 4),
     };
 }
+/** Inhale one qb2 CESR primitive into the canonical text-oriented matter shape. */
 function parseMatterFromBinaryData(input) {
     if (input.length === 0) {
         throw new ShortageError(1, 0);
@@ -112,7 +167,9 @@ function parseMatterFromBinaryData(input) {
         fullSizeB2: bfs,
     };
 }
+/** Exhale raw bytes plus code into fully qualified CESR matter encodings. */
 function encodeMatterFromRaw(code, raw) {
+    code = normalizeVariableMatterCode(code, raw);
     const sizage = MATTER_SIZES.get(code);
     if (!sizage) {
         throw new UnknownCodeError(`Unknown matter code ${code}`);
@@ -146,6 +203,7 @@ function encodeMatterFromRaw(code, raw) {
         fullSizeB2: sceil((fullSize * 3) / 4),
     };
 }
+/** Normalize the supported constructor variants into one shared matter payload. */
 function parseMatterInit(init) {
     if (init.raw && init.code) {
         return encodeMatterFromRaw(init.code, init.raw);
@@ -165,7 +223,8 @@ function parseMatterInit(init) {
  * Base CESR primitive carrying qualified matter material.
  *
  * KERIpy substance: `Matter` is the foundational primitive abstraction that
- * handles exfil/infil between raw bytes and qualified CESR encodings.
+ * handles exfil/infil between raw bytes and qualified CESR encodings and owns
+ * the base derivation-code semantic projections shared by semantic subclasses.
  */
 export class Matter {
     constructor(init) {
@@ -222,6 +281,36 @@ export class Matter {
     get code() {
         return this._code;
     }
+    /** KERIpy parity alias: codex member name for this derivation code. */
+    get name() {
+        return matterNameForCode(this._code);
+    }
+    /** KERIpy parity alias: hard code portion of the qualified text code. */
+    get hard() {
+        return this._code;
+    }
+    /** Soft code portion exclusive of any prepad xtra characters. */
+    get soft() {
+        const sizage = sizageForCode(this._code);
+        if (sizage.ss === 0) {
+            return "";
+        }
+        return this._qb64.slice(sizage.hs + sizage.xs, sizage.hs + sizage.ss);
+    }
+    /**
+     * KERIpy parity size projection.
+     *
+     * This follows KERIpy's generic `Matter.size` rule: decode the soft sextets
+     * when present, otherwise return `null`.
+     */
+    get size() {
+        return this.soft ? b64ToInt(this.soft) : null;
+    }
+    /** Hard + padded-soft view of the full text code. */
+    get both() {
+        const sizage = sizageForCode(this._code);
+        return `${this._code}${MATTER_PAD.repeat(sizage.xs)}${this.soft}`;
+    }
     get raw() {
         return this._raw;
     }
@@ -240,12 +329,53 @@ export class Matter {
     get fullSizeB2() {
         return this._fullSizeB2;
     }
+    /** Generic KERIpy derivation-code transferability rule. */
+    get transferable() {
+        return !NON_TRANSFERABLE_CODES.has(this._code);
+    }
+    /** Generic KERIpy digest-family semantic projection. */
+    get digestive() {
+        return DIGEST_CODES.has(this._code);
+    }
+    /** Generic KERIpy identifier-prefix semantic projection. */
+    get prefixive() {
+        return PREFIX_CODES.has(this._code);
+    }
+    /** True when the code family carries fixed-size soft text metadata. */
+    get special() {
+        const sizage = sizageForCode(this._code);
+        return sizage.fs !== null && sizage.ss > 0;
+    }
+    /** True when both qb64 and qb2 are 24-bit aligned and round-trip exactly. */
+    get composable() {
+        const qb2 = this.qb2;
+        return this.qb64b.length % 4 === 0
+            && qb2.length % 3 === 0
+            && encodeB64(qb2) === this.qb64
+            && bytesEqual(decodeB64(this.qb64), qb2);
+    }
     equals(other) {
         return this._qb64 === other.qb64;
     }
     toString() {
         return this._qb64;
     }
+    /** KERIpy parity helper: fixed raw size for one code. */
+    static rawSizeForCode(code) {
+        return rawSizeForCode(code);
+    }
+    /** KERIpy parity helper: fixed full qb64 size for one code. */
+    static fullSizeForCode(code) {
+        const sizage = sizageForCode(code);
+        if (sizage.fs === null) {
+            throw new DeserializeError(`Non-fixed full size for code ${code}.`);
+        }
+        return sizage.fs;
+    }
+    /** KERIpy parity helper: lead-byte size for one code. */
+    static leadSizeForCode(code) {
+        return sizageForCode(code).ls;
+    }
 }
 /** Parse matter from text-domain CESR bytes. */
 export function parseMatterFromText(input) {

package/esm/src/primitives/mediar.js

@@ -10,6 +10,12 @@ export function isMediarCode(code) {
  *
  * KERIpy substance: `Mediar` materializes media metadata/value tuple groups
  * used in blinded media attachments and related CESR payload envelopes.
+ *
+ * Maintainer note:
+ * - this class owns counted-group transport framing only
+ * - semantic disclosure helpers live in `disclosure.ts`
+ * - the semantic fixed-field record carried by these groups is `TypeMedia`
+ *   from `structing.ts`
  */
 export class Mediar extends Structor {
     constructor(init) {

package/esm/src/primitives/noncer.js

@@ -1,7 +1,7 @@
 import { UnknownCodeError } from "../core/errors.js";
 import { NONCE_CODES, NonceDex } from "./codex.js";
 import { Diger } from "./diger.js";
-import { Matter, parseMatter } from "./matter.js";
+import { parseMatter } from "./matter.js";
 /**
  * Nonce primitive for UUID/salt-or-digest nonce representations.
  *
@@ -10,8 +10,7 @@ import { Matter, parseMatter } from "./matter.js";
  */
 export class Noncer extends Diger {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter, { strict: false });
+        super(init, { strict: false });
         if (!NONCE_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected nonce code, got ${this.code}`);
         }

package/esm/src/primitives/number.js

@@ -9,8 +9,7 @@ import { Matter, parseMatter } from "./matter.js";
  */
 export class NumberPrimitive extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!NUMBER_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected number code, got ${this.code}`);
         }

package/esm/src/primitives/pather.js

@@ -1,11 +1,109 @@
-import { t } from "../core/bytes.js";
-import { UnknownCodeError } from "../core/errors.js";
+import { b, t } from "../core/bytes.js";
+import { DeserializeError, UnknownCodeError } from "../core/errors.js";
 import { Bexter } from "./bexter.js";
-import { BEXTER_CODES, TEXTER_CODES } from "./codex.js";
+import { BEXTER_CODES, MtrDex, TEXTER_CODES } from "./codex.js";
 import { Matter, parseMatter } from "./matter.js";
 function isPatherCode(code) {
     return BEXTER_CODES.has(code) || TEXTER_CODES.has(code);
 }
+function normalizeParts(path) {
+    if (typeof path !== "string") {
+        return [...path];
+    }
+    if (path.includes("/")) {
+        return path.split("/");
+    }
+    return path.split("-");
+}
+const RE_PATH_PART = /^[A-Za-z0-9_]*$/;
+function strB64CodeForText(bext) {
+    const ts = bext.length % 4;
+    const ls = (3 - ts) % 3;
+    switch (ls) {
+        case 0:
+            return MtrDex.StrB64_L0;
+        case 1:
+            return MtrDex.StrB64_L1;
+        case 2:
+            return MtrDex.StrB64_L2;
+        default:
+            throw new DeserializeError(`Unsupported StrB64 leader size=${ls}`);
+    }
+}
+function bytesCodeForRaw(raw) {
+    const ls = (3 - (raw.length % 3)) % 3;
+    switch (ls) {
+        case 0:
+            return MtrDex.Bytes_L0;
+        case 1:
+            return MtrDex.Bytes_L1;
+        case 2:
+            return MtrDex.Bytes_L2;
+        default:
+            throw new DeserializeError(`Unsupported bytes leader size=${ls}`);
+    }
+}
+/**
+ * Build a Pather from semantic route/path text.
+ *
+ * This mirrors the KERIpy `Pather(path=..., relative=..., pathive=...)`
+ * constructor path:
+ * - "pathive" base64-safe segments use compact StrB64 encoding with `-`
+ *   separators
+ * - non-pathive routes fall back to byte/text encoding when they contain
+ *   characters like `/`
+ * - relative routes keep the first segment as-is, while absolute paths are
+ *   forced to start with an empty root segment
+ *
+ * Examples:
+ * - `makePather("ksn", { relative: true, pathive: false }).qb64 === "4AABAksn"`
+ * - `makePather("reply", { relative: true, pathive: false }).qb64 === "6AACAAAreply"`
+ * - `makePather("credential/issue", { relative: true, pathive: false }).qb64 === "4AAEcredential-issue"`
+ */
+export function makePather(path, opts = {}) {
+    const relative = opts.relative ?? false;
+    const pathive = opts.pathive ?? true;
+    const parts = normalizeParts(path);
+    let bextable = true;
+    for (const part of parts) {
+        if (!RE_PATH_PART.test(part)) {
+            if (pathive) {
+                throw new DeserializeError(`Invalid pathive path part=${part}`);
+            }
+            bextable = false;
+        }
+    }
+    if (!relative) {
+        if (parts.length > 0 && parts[0] !== "") {
+            parts.unshift("");
+        }
+        else if (parts.length === 0) {
+            parts.push("", "");
+        }
+    }
+    if (bextable) {
+        let bext = parts.join("-");
+        if (bext.includes("--")) {
+            throw new DeserializeError(`Non-unitary path separators for path=${bext}`);
+        }
+        const ws = (4 - (bext.length % 4)) % 4;
+        if (bext.startsWith("A") && (ws === 0 || ws === 1)) {
+            // KERIpy reserves `--` as an escape prefix when the compact path would
+            // otherwise start with an ambiguous leading `A`.
+            bext = `--${bext}`;
+        }
+        return new Pather({
+            raw: Bexter.rawify(bext),
+            code: strB64CodeForText(bext),
+        });
+    }
+    const text = parts.join("/");
+    if (text.includes("//")) {
+        throw new DeserializeError(`Non-unitary path separators for path=${text}`);
+    }
+    const raw = b(text);
+    return new Pather({ raw, code: bytesCodeForRaw(raw) });
+}
 /**
  * CESR path primitive for SAD traversal routes.
  *
@@ -14,8 +112,7 @@ function isPatherCode(code) {
  */
 export class Pather extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!isPatherCode(this.code)) {
             throw new UnknownCodeError(`Expected pather-compatible code, got ${this.code}`);
         }

package/esm/src/primitives/prefixer.js

@@ -10,8 +10,7 @@ import { Matter, parseMatter } from "./matter.js";
  */
 export class Prefixer extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!PREFIX_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected prefix code, got ${this.code}`);
         }

package/esm/src/primitives/primitive.js

@@ -7,3 +7,17 @@ export function isCounterGroupLike(entry) {
     return typeof entry === "object" && entry !== null && !Array.isArray(entry)
         && "items" in entry && "count" in entry && "code" in entry;
 }
+/**
+ * Runtime guard for one rehydratable qualified primitive in a parsed group graph.
+ *
+ * This intentionally means "real CESR primitive with `qb64b`" rather than
+ * "any parser primitive union member", so tuples, nested counter groups, and
+ * `UnknownPrimitive` placeholders are all excluded.
+ */
+export function isQualifiedPrimitive(entry) {
+    return typeof entry === "object"
+        && entry !== null
+        && !Array.isArray(entry)
+        && !isCounterGroupLike(entry)
+        && "qb64b" in entry;
+}

package/esm/src/primitives/registry.js

@@ -1,5 +1,6 @@
 import { MATTER_CODE_NAMES } from "../tables/matter.tables.generated.js";
 import { parseMatterFromText } from "./matter.js";
+/** Parse one text-domain primitive token and include its generated code name. */
 export function parsePrimitiveFromText(input) {
     const matter = parseMatterFromText(input);
     const name = MATTER_CODE_NAMES[matter.code]
@@ -12,6 +13,7 @@ export function parsePrimitiveFromText(input) {
         fullSize: matter.fullSize,
     };
 }
+/** Return all known generated matter codes sorted for deterministic scans. */
 export function supportedPrimitiveCodes() {
     return Object.keys(MATTER_CODE_NAMES).sort();
 }

package/esm/src/primitives/saider.js

@@ -1,5 +1,9 @@
-import { UnknownCodeError } from "../core/errors.js";
+import { SerializeError, UnknownCodeError } from "../core/errors.js";
+import { dumps, sizeify } from "../serder/serder.js";
+import { smell } from "../serder/smell.js";
+import { MATTER_SIZES } from "../tables/matter.tables.generated.js";
 import { DIGEST_CODES } from "./codex.js";
+import { Diger } from "./diger.js";
 import { Matter, parseMatter } from "./matter.js";
 /**
  * Self-addressing identifier digest primitive.
@@ -9,8 +13,7 @@ import { Matter, parseMatter } from "./matter.js";
  */
 export class Saider extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!DIGEST_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected said digest code, got ${this.code}`);
         }
@@ -21,6 +24,80 @@ export class Saider extends Matter {
     get digest() {
         return this.raw;
     }
+    /**
+     * Derive one SAID from a SAD, inject it at `label`, and return the updated SAD.
+     *
+     * KERIpy places `saidify` on `Saider`, not `Serder`: the responsibility here
+     * is digest derivation for one saidive field, while event-specific policies
+     * such as mirrored `i == d` handling belong in higher layers.
+     */
+    static saidify(sad, { code = "E", kind, label = "d", ignore, digest = Diger.digest, }) {
+        const working = { ...sad };
+        if (ignore) {
+            for (const field of ignore) {
+                delete working[field];
+            }
+        }
+        const { sad: saidified, saiders } = Saider.saidifyFields(working, {
+            kind,
+            saids: { [label]: code },
+            digest,
+        });
+        const saider = saiders[label];
+        if (!saider) {
+            throw new SerializeError(`Expected digestive SAID result for ${label}`);
+        }
+        return { saider, sad: saidified };
+    }
+    /**
+     * Compute all digestive saidive fields from the same sized-dummied SAD bytes.
+     *
+     * This mirrors the KERIpy `makify/_compute` model for top-level saidive
+     * fields: resolve effective field codes first, dummy only digestive fields,
+     * size the version string once, hash once, then fill all digestive fields
+     * from that same raw serialization.
+     */
+    static saidifyFields(sad, { kind, saids, digest = Diger.digest, }) {
+        const working = { ...sad };
+        const actualKind = kind ?? inferKind(working);
+        for (const [label, code] of Object.entries(saids)) {
+            if (!(label in working)) {
+                throw new SerializeError(`Missing SAID field labeled ${label}`);
+            }
+            if (!DIGEST_CODES.has(code)) {
+                continue;
+            }
+            const sizage = MATTER_SIZES.get(code);
+            if (!sizage || sizage.fs === null) {
+                throw new SerializeError(`Unsupported fixed-size SAID code ${code}`);
+            }
+            working[label] = "#".repeat(sizage.fs);
+        }
+        if ("v" in working) {
+            sizeify(working, actualKind);
+        }
+        const digestRaw = dumps(working, actualKind);
+        const saiders = {};
+        for (const [label, code] of Object.entries(saids)) {
+            if (!DIGEST_CODES.has(code)) {
+                continue;
+            }
+            const saider = new Saider({
+                code,
+                raw: digest(digestRaw, code),
+            });
+            working[label] = saider.qb64;
+            saiders[label] = saider;
+        }
+        const raw = dumps(working, actualKind);
+        return { sad: working, raw, saiders };
+    }
+}
+function inferKind(sad) {
+    if (typeof sad.v !== "string") {
+        return "JSON";
+    }
+    return smell(new TextEncoder().encode(sad.v)).smellage.kind;
 }
 /** Parse and hydrate `Saider` from txt/qb2 bytes. */
 export function parseSaider(input, cold) {

package/esm/src/primitives/salter.js

@@ -1,22 +1,116 @@
+import { argon2id } from "@noble/hashes/argon2";
 import { UnknownCodeError } from "../core/errors.js";
+import { Tiers } from "../core/vocabulary.js";
+import { MtrDex } from "./codex.js";
 import { SALTER_CODES } from "./codex.js";
 import { Matter } from "./matter.js";
+import { Signer } from "./signer.js";
+/** Encode one KERI salty-derivation path string into bytes for Argon2id input. */
+function pathToBytes(path) {
+    return new TextEncoder().encode(path);
+}
+/**
+ * Map KERI tier/temp policy to Argon2id work factors.
+ *
+ * `temp=true` keeps the KERIpy testing rule: intentionally cheap stretching
+ * for test-only paths, never for normal persisted key derivation.
+ */
+function tierParams(tier, temp) {
+    if (temp) {
+        return { t: 1, m: 8 };
+    }
+    if (tier === Tiers.low)
+        return { t: 2, m: 65536 };
+    if (tier === Tiers.med)
+        return { t: 3, m: 262144 };
+    if (tier === Tiers.high)
+        return { t: 4, m: 1048576 };
+    throw new Error(`Unsupported security tier=${tier}`);
+}
 /**
  * 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.
+ *
+ * Maintainer model:
+ * - `tier` is the default stretch policy carried with the salt instance
+ * - individual `stretch()` / `signer()` calls may still override it
  */
 export class Salter extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
+        Object.defineProperty(this, "tier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (!SALTER_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected salt code, got ${this.code}`);
         }
+        this.tier = init instanceof Salter
+            ? init.tier
+            : init.tier ?? Tiers.low;
     }
     /** Raw salt bytes used by key-derivation consumers. */
     get salt() {
         return this.raw;
     }
+    /**
+     * Derive deterministic secret bytes from this salt and one derivation path.
+     *
+     * KERIpy correspondence:
+     * - mirrors `Salter.stretch(...)` using Argon2id and tier/temp policy
+     *
+     * Path rule:
+     * - callers supply the fully formed KERI salty path string
+     * - `Salter` does not impose `pidx/ridx/kidx` structure itself; that remains
+     *   a higher-layer manager/creator responsibility
+     */
+    stretch({ size = 32, path = "", tier = this.tier, temp = false, } = {}) {
+        const params = tierParams(tier, temp);
+        return argon2id(pathToBytes(path), this.raw, {
+            p: 1,
+            t: params.t,
+            m: params.m,
+            dkLen: size,
+            version: 0x13,
+        });
+    }
+    /**
+     * Derive one deterministic executable signer from this salt and one path.
+     *
+     * The signer suite controls seed width; `Salter` only owns the deterministic
+     * seed derivation.
+     */
+    signer({ code = MtrDex.Ed25519_Seed, transferable = true, path = "", tier, temp = false, } = {}) {
+        return new Signer({
+            code,
+            raw: this.stretch({
+                size: Signer.seedSizeForCode(code),
+                path,
+                tier,
+                temp,
+            }),
+            transferable,
+        });
+    }
+    /**
+     * Derive an ordered signer list from one path prefix plus hex suffix range.
+     *
+     * KERIpy correspondence:
+     * - successive signers append lowercase-hex offsets to the supplied path
+     *   prefix
+     */
+    signers({ count = 1, start = 0, path = "", code = MtrDex.Ed25519_Seed, codes, transferable = true, tier, temp = false, } = {}) {
+        const effectiveCodes = codes ?? Array.from({ length: count }, () => code);
+        return effectiveCodes.map((suite, offset) => this.signer({
+            code: suite,
+            transferable,
+            path: `${path}${(start + offset).toString(16)}`,
+            tier,
+            temp,
+        }));
+    }
 }

package/esm/src/primitives/sealed-box.js

@@ -0,0 +1,41 @@
+import sodium from "libsodium-wrappers";
+await sodium.ready;
+/**
+ * Internal libsodium-backed sealed-box seam for KERIpy cipher parity.
+ *
+ * Boundary rule:
+ * - CESR primitives own sealed-box behavior
+ * - higher layers consume `Cipher`/`Encrypter`/`Decrypter`, not sodium calls
+ * - this module returns only raw key/plaintext/cipher bytes; derivation codes
+ *   and primitive hydration stay outside at the CESR primitive layer
+ */
+/** Derive X25519 public key material from one Ed25519 verifier key. */
+export function boxPublicKeyFromEd25519Verfer(verferRaw) {
+    return new Uint8Array(sodium.crypto_sign_ed25519_pk_to_curve25519(verferRaw));
+}
+/**
+ * Derive the X25519 box keypair corresponding to one Ed25519 signing seed.
+ *
+ * KERIpy parity:
+ * - derive the Ed25519 signing keypair first
+ * - then convert both sides to the associated X25519 box keys
+ */
+export function boxKeyPairFromEd25519Seed(seedRaw) {
+    const keyPair = sodium.crypto_sign_seed_keypair(seedRaw);
+    return {
+        publicKey: new Uint8Array(sodium.crypto_sign_ed25519_pk_to_curve25519(keyPair.publicKey)),
+        privateKey: new Uint8Array(sodium.crypto_sign_ed25519_sk_to_curve25519(keyPair.privateKey)),
+    };
+}
+/** Recover the X25519 public key corresponding to one raw X25519 private key. */
+export function boxPublicKeyFromPrivateKey(privateKey) {
+    return new Uint8Array(sodium.crypto_scalarmult_base(privateKey));
+}
+/** Encrypt one plaintext using libsodium's X25519 sealed-box primitive. */
+export function sealBox(plaintext, publicKey) {
+    return new Uint8Array(sodium.crypto_box_seal(plaintext, publicKey));
+}
+/** Open one libsodium X25519 sealed-box ciphertext back to raw plaintext bytes. */
+export function openSealedBox(cipher, publicKey, privateKey) {
+    return new Uint8Array(sodium.crypto_box_seal_open(cipher, publicKey, privateKey));
+}

package/esm/src/primitives/seqner.js

@@ -9,8 +9,7 @@ import { Matter, parseMatter } from "./matter.js";
  */
 export class Seqner extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!SEQNER_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected seqner Salt_128 code, got ${this.code}`);
         }