cesr-ts 0.4.0 → 0.6.0

package/esm/src/primitives/structor.js

@@ -1,3 +1,18 @@
+/**
+ * Counted-group transport wrappers for CESR tuple/list families.
+ *
+ * This file ports the transport/enclosure half of KERIpy `Structor`.
+ *
+ * Boundary rule:
+ * - `Structor` owns counted-group framing, grouped serialization, and parser
+ *   reconstruction of enclosed payload items
+ * - `structing.ts` owns semantic fixed-field seal/blind/media records
+ * - `disclosure.ts` owns blind/unblind/commit workflow verbs
+ *
+ * If you are looking for the meaning of fields like `d`, `u`, `td`, or `mt`,
+ * this is the wrong file. `Structor` only knows how many items are in a group
+ * and how that enclosed group serializes.
+ */
 import { b, codeB64ToB2, encodeB64, t } from "../core/bytes.js";
 import { UnknownCodeError } from "../core/errors.js";
 import { parseAttachmentDispatch } from "../parser/group-dispatch.js";
@@ -24,6 +39,11 @@ function inferSerialized(group, sourceDomain) {
  *
  * KERIpy substance: `Structor` models one counted-group unit where tuple/list
  * members are hydrated CESR primitives and serialization remains deterministic.
+ *
+ * TypeScript boundary:
+ * - subclasses like `Sealer`, `Blinder`, and `Mediar` specialize transport
+ *   families
+ * - semantic fixed-field values remain plain records outside this class
  */
 export class Structor extends CounterGroup {
     constructor(init) {

package/esm/src/primitives/tagger.js

@@ -27,8 +27,7 @@ export function isTaggerCode(code) {
  */
 export class Tagger extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!isTaggerCode(this.code)) {
             throw new UnknownCodeError(`Expected tag code, got ${this.code}`);
         }

package/esm/src/primitives/texter.js

@@ -13,8 +13,7 @@ function isTexterCode(code) {
  */
 export class Texter extends Matter {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!isTexterCode(this.code)) {
             throw new UnknownCodeError(`Expected texter bytes code, got ${this.code}`);
         }

package/esm/src/primitives/tholder.js

@@ -1,31 +1,573 @@
-import { t } from "../core/bytes.js";
 import { UnknownCodeError } from "../core/errors.js";
+import { Bexter } from "./bexter.js";
+import { LabelDex } from "./codex.js";
 import { THOLDER_NUMERIC_CODES, THOLDER_WEIGHTED_CODES } from "./codex.js";
 import { Matter, parseMatter } from "./matter.js";
+import { NumberPrimitive } from "./number.js";
+/**
+ * Numeric tholder codex capacities keyed by the code used for a given raw width.
+ *
+ * This is the bridge between bigint numeric thresholds and the compact CESR
+ * numeric codex family that `Tholder` reuses.
+ */
+const NUMERIC_CAPACITIES = [
+    { code: "M", rawSize: 2 },
+    { code: "0H", rawSize: 4 },
+    { code: "R", rawSize: 5 },
+    { code: "N", rawSize: 8 },
+    { code: "S", rawSize: 11 },
+    { code: "T", rawSize: 14 },
+    { code: "0A", rawSize: 16 },
+    { code: "U", rawSize: 17 },
+];
+/** Largest bigint that can be mirrored into a lossless JS `number`. */
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+/** Narrow `unknown` into a plain object map rather than an array-like value. */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Recognize constructor inputs that already describe a `Matter`/`MatterInit`
+ * wire representation rather than a semantic threshold expression.
+ */
+function isMatterInitLike(value) {
+    return value instanceof Matter || (isRecord(value)
+        && ("raw" in value || "qb64" in value || "qb64b" in value || "qb2" in value
+            || "code" in value));
+}
+/** Euclidean greatest-common-divisor helper for rational normalization. */
+function gcd(a, b) {
+    let left = a < 0n ? -a : a;
+    let right = b < 0n ? -b : b;
+    while (right !== 0n) {
+        const next = left % right;
+        left = right;
+        right = next;
+    }
+    return left === 0n ? 1n : left;
+}
+/**
+ * Reduce a rational to canonical sign/lowest-terms form.
+ *
+ * Invariant: denominator is always positive on return.
+ */
+function normalizeRational(numerator, denominator) {
+    if (denominator === 0n) {
+        throw new Error("Invalid threshold weight denominator=0.");
+    }
+    if (denominator < 0n) {
+        numerator = -numerator;
+        denominator = -denominator;
+    }
+    const divisor = gcd(numerator, denominator);
+    return {
+        numerator: numerator / divisor,
+        denominator: denominator / divisor,
+    };
+}
+/** Add two exact rationals without passing through floating-point math. */
+function addRationals(left, right) {
+    return normalizeRational(left.numerator * right.denominator + right.numerator * left.denominator, left.denominator * right.denominator);
+}
+/** Compare two exact rationals using cross-multiplication. */
+function compareRationals(left, right) {
+    const lhs = left.numerator * right.denominator;
+    const rhs = right.numerator * left.denominator;
+    if (lhs === rhs)
+        return 0;
+    return lhs > rhs ? 1 : -1;
+}
+/** True when a rational meets the KERI weighted-threshold satisfaction floor of `1`. */
+function atLeastOne(value) {
+    return compareRationals(value, { numerator: 1n, denominator: 1n }) >= 0;
+}
+/** Shared zero rational constant constructor. */
+function rationalZero() {
+    return { numerator: 0n, denominator: 1n };
+}
+/** Shared one rational constant constructor. */
+function rationalOne() {
+    return { numerator: 1n, denominator: 1n };
+}
+/** Convert a normalized rational back into the SAD-facing textual weight form. */
+function formatWeight(weight) {
+    if (weight.denominator === 1n
+        || weight.numerator === 0n
+        || weight.numerator === weight.denominator) {
+        return weight.numerator.toString(10);
+    }
+    return `${weight.numerator.toString(10)}/${weight.denominator.toString(10)}`;
+}
+/** Encode one rational into the compact bext token form used inside weighted limens. */
+function encodeBextWeight(weight) {
+    if (weight.denominator === 1n
+        || weight.numerator === 0n
+        || weight.numerator === weight.denominator) {
+        return weight.numerator.toString(10);
+    }
+    return `${weight.numerator.toString(10)}s${weight.denominator.toString(10)}`;
+}
+/**
+ * Parse and validate one SAD-facing weight token.
+ *
+ * Boundary contract:
+ * - accepts only integer `0`/`1` or fractional `n/d` forms
+ * - rejects values outside the inclusive range `[0, 1]`
+ * - normalizes equivalent forms such as `2/4` into exact reduced rationals
+ */
+function parseWeight(input) {
+    const text = input.trim();
+    if (text.length === 0) {
+        throw new Error("Empty threshold weight.");
+    }
+    if (/^-?\d+$/.test(text)) {
+        const value = BigInt(text);
+        if (value < 0n || value > 1n) {
+            throw new Error(`Invalid threshold weight not 0 <= ${text} <= 1.`);
+        }
+        return { numerator: value, denominator: 1n };
+    }
+    const match = text.match(/^(-?\d+)\/(\d+)$/);
+    if (!match) {
+        throw new Error(`Invalid threshold weight ${text}.`);
+    }
+    const numerator = BigInt(match[1]);
+    const denominator = BigInt(match[2]);
+    const normalized = normalizeRational(numerator, denominator);
+    if (compareRationals(normalized, rationalZero()) < 0
+        || compareRationals(normalized, rationalOne()) > 0) {
+        throw new Error(`Invalid threshold weight not 0 <= ${text} <= 1.`);
+    }
+    return normalized;
+}
+/** Deep-clone the public semantic threshold shape before returning it outward. */
+function cloneThresholdSith(sith) {
+    if (typeof sith === "string") {
+        return sith;
+    }
+    return sith.map((clauseOrEntry) => {
+        if (typeof clauseOrEntry === "string") {
+            return clauseOrEntry;
+        }
+        if (Array.isArray(clauseOrEntry)) {
+            return clauseOrEntry.map((entry) => typeof entry === "string" ? entry : Object.fromEntries(Object.entries(entry).map(([k, values]) => [k, [...values]])));
+        }
+        return Object.fromEntries(Object.entries(clauseOrEntry).map(([k, values]) => [k, [...values]]));
+    });
+}
+/**
+ * Choose the StrB64/Bexter code family variant for a weighted threshold limen.
+ *
+ * The selection depends on raw byte length, not bext text length, because
+ * StrB64 lead-size semantics are defined over the underlying CESR raw payload.
+ */
+function chooseBexterCode(rawLength) {
+    const leadSize = (3 - (rawLength % 3)) % 3;
+    return leadSize === 0
+        ? LabelDex.StrB64_L0
+        : leadSize === 1
+            ? LabelDex.StrB64_L1
+            : LabelDex.StrB64_L2;
+}
+/** Resolve the smallest numeric-threshold codex entry that can carry `rawSize` bytes. */
+function chooseNumberCode(rawSize) {
+    const entry = NUMERIC_CAPACITIES.find(({ rawSize: max }) => rawSize <= max);
+    if (!entry) {
+        throw new Error(`Unsupported threshold width=${rawSize}.`);
+    }
+    return entry.code;
+}
+/** Convert a non-negative bigint threshold into big-endian raw bytes. */
+function bigintToBytes(value) {
+    if (value < 0n) {
+        throw new Error(`Negative threshold number=${value}.`);
+    }
+    if (value === 0n) {
+        return new Uint8Array([0]);
+    }
+    const bytes = [];
+    let working = value;
+    while (working > 0n) {
+        bytes.unshift(Number(working & 0xffn));
+        working >>= 8n;
+    }
+    return new Uint8Array(bytes);
+}
+/** Build the `MatterInit` used to serialize a numeric threshold into CESR. */
+function makeNumberMatterInit(value) {
+    const raw = bigintToBytes(value);
+    const code = chooseNumberCode(raw.length);
+    const entry = NUMERIC_CAPACITIES.find(({ code: current }) => current === code);
+    if (!entry) {
+        throw new Error(`Unsupported threshold number code=${code}.`);
+    }
+    const padded = new Uint8Array(entry.rawSize);
+    padded.set(raw, entry.rawSize - raw.length);
+    return { code, raw: padded };
+}
+/**
+ * Normalize a public weighted threshold expression into exact arithmetic form.
+ *
+ * Responsibilities:
+ * - validate clause/group shape and KERIpy-style invariants
+ * - compute the internal rational AST used by `satisfy(indices)`
+ * - return a canonical semantic clone suitable for `sith` exposure
+ */
+function normalizeWeightedInput(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("Empty weighted threshold expression.");
+    }
+    const wrapSingleClause = value.some((entry) => !Array.isArray(entry));
+    const sourceClauses = wrapSingleClause
+        ? [value]
+        : value;
+    const clauses = [];
+    for (const clause of sourceClauses) {
+        if (!Array.isArray(clause) || clause.length === 0) {
+            throw new Error("Empty weighted threshold clause.");
+        }
+        let topWeight = rationalZero();
+        const normalizedClause = [];
+        for (const entry of clause) {
+            if (typeof entry === "string") {
+                const weight = parseWeight(entry);
+                normalizedClause.push(weight);
+                topWeight = addRationals(topWeight, weight);
+                continue;
+            }
+            if (!isRecord(entry)) {
+                throw new Error("Invalid weighted threshold clause entry.");
+            }
+            const keys = Object.keys(entry);
+            if (keys.length !== 1) {
+                throw new Error("Nested weighted threshold groups must have exactly one key.");
+            }
+            const groupKey = keys[0];
+            const nested = entry[groupKey];
+            if (!Array.isArray(nested) || nested.length === 0) {
+                throw new Error("Nested weighted threshold groups must contain member weights.");
+            }
+            const groupWeight = parseWeight(groupKey);
+            const members = nested.map((member) => {
+                if (typeof member !== "string") {
+                    throw new Error("Nested threshold member weights must be strings.");
+                }
+                return parseWeight(member);
+            });
+            let memberSum = rationalZero();
+            for (const member of members) {
+                memberSum = addRationals(memberSum, member);
+            }
+            if (!atLeastOne(memberSum)) {
+                throw new Error("All nested weighted threshold sums must be at least 1.");
+            }
+            normalizedClause.push({ weight: groupWeight, members });
+            topWeight = addRationals(topWeight, groupWeight);
+        }
+        if (!atLeastOne(topWeight)) {
+            throw new Error("All weighted threshold clause sums must be at least 1.");
+        }
+        clauses.push(normalizedClause);
+    }
+    const semanticClauses = clauses.map((clause) => clause.map((entry) => "numerator" in entry
+        ? formatWeight(entry)
+        : { [formatWeight(entry.weight)]: entry.members.map(formatWeight) }));
+    return {
+        clauses,
+        semantic: semanticClauses.length === 1
+            ? semanticClauses[0]
+            : semanticClauses,
+    };
+}
+/** Parse a JSON threshold literal supplied through string-only config or CLI seams. */
+function parseWeightedJson(text) {
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed)) {
+        throw new Error("Weighted threshold JSON must decode to an array.");
+    }
+    return parsed;
+}
+/**
+ * Normalize any semantic threshold input into one constructor-ready bundle.
+ *
+ * This is the central semantic funnel for `{ sith }`/numeric/weighted inputs:
+ * callers receive CESR serialization material plus the precomputed state needed
+ * for `weighted`, `size`, `num`, `thold`, and `sith`.
+ */
+function normalizeThresholdInput(value) {
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`Invalid numeric threshold=${value}.`);
+        }
+        return normalizeThresholdInput(BigInt(value));
+    }
+    if (typeof value === "bigint") {
+        const matterInit = makeNumberMatterInit(value);
+        const size = value > MAX_SAFE_BIGINT
+            ? Number.MAX_SAFE_INTEGER
+            : Number(value);
+        return {
+            matterInit,
+            weighted: false,
+            numeric: value,
+            size,
+            thold: value,
+            semantic: value.toString(16),
+        };
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            throw new Error("Empty threshold expression.");
+        }
+        if (trimmed.startsWith("[")) {
+            return normalizeThresholdInput(parseWeightedJson(trimmed));
+        }
+        if (!/^[0-9a-f]+$/i.test(trimmed)) {
+            throw new Error(`Invalid numeric threshold ${trimmed}.`);
+        }
+        return normalizeThresholdInput(BigInt(`0x${trimmed}`));
+    }
+    const weighted = normalizeWeightedInput(value);
+    const bext = weighted.clauses.map((clause) => clause.map((entry) => "numerator" in entry
+        ? encodeBextWeight(entry)
+        : `${encodeBextWeight(entry.weight)}k${entry.members.map(encodeBextWeight).join("v")}`).join("c")).join("a");
+    const raw = Bexter.rawify(bext);
+    const code = chooseBexterCode(raw.length);
+    return {
+        matterInit: { code, raw },
+        weighted: true,
+        numeric: null,
+        size: weighted.clauses.reduce((count, clause) => count
+            + clause.reduce((clauseCount, entry) => clauseCount + ("numerator" in entry ? 1 : entry.members.length), 0), 0),
+        thold: weighted.clauses,
+        semantic: weighted.semantic,
+    };
+}
+/**
+ * Decode an already-qualified CESR threshold primitive back into semantic form.
+ *
+ * Numeric and weighted codex families intentionally converge here so reload,
+ * parser hydration, and `limen` construction all share one interpretation path.
+ */
+function decodeThresholdMatter(matter) {
+    if (THOLDER_NUMERIC_CODES.has(matter.code)) {
+        const number = new NumberPrimitive(matter);
+        const value = number.num;
+        return {
+            weighted: false,
+            numeric: value,
+            size: value > MAX_SAFE_BIGINT ? Number.MAX_SAFE_INTEGER : Number(value),
+            thold: value,
+            semantic: value.toString(16),
+        };
+    }
+    if (THOLDER_WEIGHTED_CODES.has(matter.code)) {
+        const bexter = new Bexter(matter);
+        const clauses = bexter.bext.replaceAll("s", "/").split("a").map((clause) => clause.split("c").map((entry) => {
+            const at = entry.indexOf("k");
+            if (at < 0) {
+                return entry;
+            }
+            const weight = entry.slice(0, at);
+            const members = entry.slice(at + 1).split("v");
+            return { [weight]: members };
+        }));
+        const normalized = normalizeWeightedInput(clauses.length === 1 ? clauses[0] : clauses);
+        return {
+            weighted: true,
+            numeric: null,
+            size: normalized.clauses.reduce((count, clause) => count
+                + clause.reduce((clauseCount, entry) => clauseCount + ("numerator" in entry ? 1 : entry.members.length), 0), 0),
+            thold: normalized.clauses,
+            semantic: normalized.semantic,
+        };
+    }
+    throw new UnknownCodeError(`Expected threshold code, got ${matter.code}`);
+}
+/**
+ * Accept the full constructor surface supported by `Tholder`.
+ *
+ * Order matters here:
+ * 1. explicit `Matter`/`MatterInit`
+ * 2. explicit `limen`
+ * 3. semantic `sith` or direct numeric/weighted input
+ */
+function normalizeConstructorInput(init) {
+    if (isMatterInitLike(init)) {
+        const matter = init instanceof Matter ? init : new Matter(init);
+        return { matterInit: init, ...decodeThresholdMatter(matter) };
+    }
+    if (isRecord(init) && "limen" in init && init.limen !== undefined) {
+        const matterInit = typeof init.limen === "string"
+            ? { qb64: init.limen }
+            : { qb64b: init.limen };
+        const matter = new Matter(matterInit);
+        return { matterInit, ...decodeThresholdMatter(matter) };
+    }
+    const semantic = isRecord(init) && "sith" in init ? init.sith : init;
+    return normalizeThresholdInput(semantic);
+}
 /**
  * Threshold expression primitive.
  *
- * KERIpy substance: `Tholder` supports both numeric thresholds and weighted
- * threshold expressions encoded as StrB64 payloads.
+ * KERIpy substance:
+ * - `Tholder` supports both numeric thresholds and weighted threshold
+ *   expressions encoded as StrB64 payloads
+ * - `satisfy(indices)` is the semantic contract upper layers rely on when
+ *   validating current and prior-next threshold satisfaction
+ * - `limen` reuses the CESR `Number` family for numeric thresholds and the
+ *   `Bexter` bext encoding for weighted thresholds
  */
 export class Tholder extends Matter {
+    /**
+     * Construct from wire material (`Matter`, `MatterInit`, `limen`) or semantic
+     * threshold input (`sith`, bigint, number, hex string, weighted arrays).
+     */
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        const normalized = normalizeConstructorInput(init);
+        super(normalized.matterInit);
+        Object.defineProperty(this, "_weighted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_num", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_thold", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_sith", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (!THOLDER_NUMERIC_CODES.has(this.code)
             && !THOLDER_WEIGHTED_CODES.has(this.code)) {
             throw new UnknownCodeError(`Expected threshold code, got ${this.code}`);
         }
+        this._weighted = normalized.weighted;
+        this._num = normalized.numeric;
+        this._size = normalized.size;
+        this._thold = normalized.thold;
+        this._sith = cloneThresholdSith(normalized.semantic);
     }
+    /** True when this instance represents a weighted threshold rather than a numeric count. */
+    get weighted() {
+        return this._weighted;
+    }
+    /**
+     * Number of signer slots consumed by this threshold expression.
+     *
+     * For nested groups this counts nested members, because those are the real
+     * contiguous signer slots upper layers index into.
+     */
+    get size() {
+        return this._size;
+    }
+    /** Internal normalized threshold semantics exposed for maintainer debugging and tests. */
+    get thold() {
+        return this._weighted
+            ? this._thold.map((clause) => clause.map((entry) => "numerator" in entry ? { ...entry } : {
+                weight: { ...entry.weight },
+                members: entry.members.map((member) => ({ ...member })),
+            }))
+            : this._thold;
+    }
+    /** Numeric threshold value when `weighted === false`, otherwise `null`. */
+    get num() {
+        return this._num;
+    }
+    /**
+     * Qualified CESR threshold representation used in event bodies and state.
+     *
+     * Numeric thresholds are encoded through the numeric matter family; weighted
+     * thresholds are encoded through the compact bext/limen form KERIpy uses.
+     */
+    get limen() {
+        return this.qb64;
+    }
+    /** Public semantic threshold expression cloned back into SAD-facing shape. */
     get sith() {
-        if (THOLDER_NUMERIC_CODES.has(this.code)) {
-            return [...this.raw].reduce((acc, b) => (acc << 8n) | BigInt(b), 0n)
-                .toString(16);
+        return cloneThresholdSith(this._sith);
+    }
+    /**
+     * Test whether the provided signer indices satisfy this threshold.
+     *
+     * Maintainer model:
+     * - numeric thresholds are pure cardinality checks after deduplication is
+     *   handled by the caller or irrelevant to the count
+     * - weighted thresholds project indices onto consecutive signer slots from
+     *   left to right across clauses and nested-group members
+     * - each clause must accumulate at least weight `1`
+     */
+    satisfy(indices) {
+        if (!this._weighted) {
+            return this._num !== null
+                && this._num > 0n
+                && BigInt(indices.length) >= this._num;
         }
-        return t(this.raw);
+        if (indices.length === 0) {
+            return false;
+        }
+        const ordered = [...new Set(indices)].sort((a, b) => a - b);
+        const sats = new Array(this._size).fill(false);
+        for (const index of ordered) {
+            if (index >= 0 && index < sats.length) {
+                sats[index] = true;
+            }
+        }
+        let offset = 0;
+        for (const clause of this._thold) {
+            let clauseWeight = rationalZero();
+            for (const entry of clause) {
+                if ("numerator" in entry) {
+                    if (sats[offset]) {
+                        clauseWeight = addRationals(clauseWeight, entry);
+                    }
+                    offset += 1;
+                    continue;
+                }
+                let memberWeight = rationalZero();
+                for (const member of entry.members) {
+                    if (sats[offset]) {
+                        memberWeight = addRationals(memberWeight, member);
+                    }
+                    offset += 1;
+                }
+                if (atLeastOne(memberWeight)) {
+                    clauseWeight = addRationals(clauseWeight, entry.weight);
+                }
+            }
+            if (!atLeastOne(clauseWeight)) {
+                return false;
+            }
+        }
+        return true;
     }
 }
-/** Parse and hydrate `Tholder` from txt/qb2 bytes. */
+/**
+ * Parse and hydrate `Tholder` from txt/qb2 bytes.
+ *
+ * Boundary contract: stream parsing decides whether the next token is text or
+ * binary CESR, while `Tholder` owns threshold-codex validation and semantic
+ * hydration after the underlying `Matter` is parsed.
+ */
 export function parseTholder(input, cold) {
     return new Tholder(parseMatter(input, cold));
 }

package/esm/src/primitives/traitor.js

@@ -1,6 +1,6 @@
 import { UnknownCodeError } from "../core/errors.js";
 import { TRAIT_TAGS } from "./codex.js";
-import { Matter, parseMatter } from "./matter.js";
+import { parseMatter } from "./matter.js";
 import { Tagger } from "./tagger.js";
 /**
  * Configuration-trait primitive for key-event trait tags.
@@ -10,8 +10,7 @@ import { Tagger } from "./tagger.js";
  */
 export class Traitor extends Tagger {
     constructor(init) {
-        const matter = init instanceof Matter ? init : new Matter(init);
-        super(matter);
+        super(init);
         if (!TRAIT_TAGS.has(this.tag)) {
             throw new UnknownCodeError(`Invalid trait tag for Traitor: ${this.tag}`);
         }