cesr-ts 0.4.0 → 0.6.0

package/esm/src/primitives/structing.js

@@ -0,0 +1,727 @@
+/**
+ * Fixed-field structing descriptors and plain record values.
+ *
+ * This file is the TypeScript correlate of the fixed-field portion of KERIpy
+ * `structing.py`.
+ *
+ * The important mental model is a representation ladder:
+ * - semantic record: plain frozen object with real CESR primitives
+ * - crew / SAD object: same field names, projected to string properties named
+ *   by the cast metadata (`ipn`)
+ * - CESR tuple body: concatenated primitive serializations in field order
+ * - counted-group transport: attachment framing owned elsewhere by
+ *   `Structor`, `Sealer`, `Blinder`, and `Mediar`
+ *
+ * This module owns the first three layers for fixed-field seal, blind-state,
+ * and typed-media values. It does not own workflow verbs such as blind,
+ * unblind, or commitment recomputation; those live in `disclosure.ts`.
+ */
+import { b, concatBytes } from "../core/bytes.js";
+import { Bexter } from "./bexter.js";
+import { LabelDex, 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 { Prefixer } from "./prefixer.js";
+import { Texter } from "./texter.js";
+import { Verser } from "./verser.js";
+/**
+ * Build one immutable cast entry.
+ *
+ * KERIpy substance:
+ * - mirrors `Castage(kls=..., ipn=...)`
+ *
+ * `ipn` is the string projection name used in crew/SAD form. For example:
+ * - `NumberPrimitive` uses `numh`
+ * - `Noncer` uses `nonce`
+ * - `Labeler` / `Texter` use `text`
+ * - `null` falls back to canonical `qb64`
+ */
+export function castage(kls, ipn = null) {
+    return Object.freeze({ kls, ipn });
+}
+const NUMBER_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 },
+];
+function freezeRecord(value) {
+    return Object.freeze(value);
+}
+function bigintToBytes(value) {
+    if (value < 0n) {
+        throw new TypeError(`Negative CESR 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);
+}
+function hydrateNumber(numh) {
+    const bigint = BigInt(`0x${numh || "0"}`);
+    const raw = bigintToBytes(bigint);
+    const entry = NUMBER_CAPACITIES.find(({ rawSize }) => raw.length <= rawSize);
+    if (!entry) {
+        throw new TypeError(`Unsupported CESR number width=${raw.length}`);
+    }
+    const padded = new Uint8Array(entry.rawSize);
+    padded.set(raw, entry.rawSize - raw.length);
+    return new NumberPrimitive({ code: entry.code, raw: padded });
+}
+function encodeTag(text) {
+    const code = new Map([
+        [1, LabelDex.Tag1],
+        [2, LabelDex.Tag2],
+        [3, LabelDex.Tag3],
+        [4, LabelDex.Tag4],
+        [5, LabelDex.Tag5],
+        [6, LabelDex.Tag6],
+        [7, LabelDex.Tag7],
+        [8, LabelDex.Tag8],
+        [9, LabelDex.Tag9],
+        [10, LabelDex.Tag10],
+        [11, LabelDex.Tag11],
+    ]).get(text.length);
+    if (!code) {
+        throw new TypeError(`Unsupported label text length=${text.length}`);
+    }
+    const pad = code === LabelDex.Tag1 || code === LabelDex.Tag5
+        || code === LabelDex.Tag9
+        ? "_"
+        : "";
+    return `${code}${pad}${text}`;
+}
+function encodeBext(text) {
+    const rem = text.length % 4;
+    const code = rem === 0
+        ? LabelDex.StrB64_L0
+        : rem === 1
+            ? LabelDex.StrB64_L1
+            : LabelDex.StrB64_L2;
+    return new Bexter({ code, raw: Bexter.rawify(text) }).qb64;
+}
+function encodeBytes(text) {
+    const raw = b(text);
+    const rem = raw.length % 3;
+    const code = rem === 0
+        ? LabelDex.Bytes_L0
+        : rem === 1
+            ? LabelDex.Bytes_L1
+            : LabelDex.Bytes_L2;
+    return new Texter({ code, raw }).qb64;
+}
+function encodeLabelText(text) {
+    if (text.length === 0) {
+        return LabelDex.Empty;
+    }
+    if (/^[A-Za-z0-9_-]{1,11}$/.test(text)) {
+        return encodeTag(text);
+    }
+    if (/^[A-Za-z0-9_-]+$/.test(text)) {
+        return encodeBext(text);
+    }
+    return encodeBytes(text);
+}
+/**
+ * Inverse of crew/SAD projection for one field.
+ *
+ * Maintainer rule:
+ * - `fromSad()` does not blindly assume `qb64`
+ * - it must rebuild the primitive from the same string property selected by
+ *   the field's cast metadata
+ *
+ * This is why `BlindState.ts` and friends can round-trip placeholders and
+ * human-readable labels without losing parity with KERIpy.
+ */
+function hydrateStructingField(spec, value) {
+    if (spec.kls === NumberPrimitive) {
+        return hydrateNumber(value);
+    }
+    if (spec.kls === Noncer) {
+        return value === ""
+            ? new Noncer({ code: NonceDex.Empty, raw: new Uint8Array() })
+            : new Noncer({ qb64: value });
+    }
+    if (spec.kls === Labeler) {
+        return new Labeler({ qb64: encodeLabelText(value) });
+    }
+    if (spec.kls === Texter) {
+        return new Texter({ qb64: encodeBytes(value) });
+    }
+    return new spec.kls({ qb64: value });
+}
+/**
+ * Project one semantic primitive field into crew/SAD string form.
+ *
+ * `crew` means "same field names, but string values selected by cast
+ * metadata," not "stringify everything as `qb64`".
+ */
+function serializeCrewField(field, spec) {
+    const prop = spec.ipn ?? "qb64";
+    const value = Reflect.get(field, prop);
+    if (typeof value !== "string") {
+        throw new TypeError(`Structing field ${field.constructor.name} does not expose string property ${prop}.`);
+    }
+    return value;
+}
+/** Build the crew/SAD object for one fixed-field semantic record. */
+function buildCrew(fields, cast, value) {
+    const out = {};
+    for (const field of fields) {
+        const key = field;
+        out[key] = serializeCrewField(value[key], cast[key]);
+    }
+    return Object.freeze(out);
+}
+function serializeTupleQb64(tuple) {
+    return tuple.map((field) => field.qb64).join("");
+}
+function serializeTupleQb64b(tuple) {
+    return b(serializeTupleQb64(tuple));
+}
+function serializeTupleQb2(tuple) {
+    return concatBytes(...tuple.map((field) => field.qb2));
+}
+function invertClanCodens(map) {
+    const out = {};
+    for (const [clan, coden] of Object.entries(map)) {
+        out[coden] = clan;
+    }
+    return Object.freeze(out);
+}
+function isSadShape(fields, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    const keys = Object.keys(candidate);
+    if (keys.length !== fields.length) {
+        return false;
+    }
+    for (const field of fields) {
+        if (typeof candidate[field] !== "string") {
+            return false;
+        }
+    }
+    return keys.every((key) => fields.includes(key));
+}
+/**
+ * Attach raw-SAD helpers to one plain descriptor object.
+ *
+ * TypeScript divergence from KERIpy:
+ * - KERIpy wraps these behaviors inside richer `Structor` descendants
+ * - `keri-ts` keeps the values as plain records and exposes schema/conversion
+ *   helpers directly on frozen descriptor companions
+ */
+function withSadProjection(descriptor) {
+    return Object.freeze({
+        ...descriptor,
+        isSad(value) {
+            return isSadShape(descriptor.fields, value);
+        },
+        fromSad(value) {
+            const tuple = descriptor.fields.map((field) => {
+                const key = field;
+                return hydrateStructingField(descriptor.cast[key], value[key]);
+            });
+            return descriptor.fromTuple(tuple);
+        },
+        toSad(value) {
+            return descriptor.toCrew(value);
+        },
+    });
+}
+const SEAL_DIGEST_FIELDS = Object.freeze(["d"]);
+const SEAL_DIGEST_CAST = Object.freeze({ d: castage(Diger) });
+export const SealDigest = withSadProjection({
+    name: "SealDigest",
+    fields: SEAL_DIGEST_FIELDS,
+    cast: SEAL_DIGEST_CAST,
+    coden: "DigestSealSingles",
+    fromTuple([d]) {
+        return freezeRecord({ d });
+    },
+    fromQb64bTuple([d]) {
+        return freezeRecord({ d: new Diger({ qb64b: d }) });
+    },
+    toTuple(value) {
+        return [value.d];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_DIGEST_FIELDS, SEAL_DIGEST_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.d]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.d]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.d]);
+    },
+});
+const SEAL_ROOT_FIELDS = Object.freeze(["rd"]);
+const SEAL_ROOT_CAST = Object.freeze({ rd: castage(Diger) });
+export const SealRoot = withSadProjection({
+    name: "SealRoot",
+    fields: SEAL_ROOT_FIELDS,
+    cast: SEAL_ROOT_CAST,
+    coden: "MerkleRootSealSingles",
+    fromTuple([rd]) {
+        return freezeRecord({ rd });
+    },
+    fromQb64bTuple([rd]) {
+        return freezeRecord({ rd: new Diger({ qb64b: rd }) });
+    },
+    toTuple(value) {
+        return [value.rd];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_ROOT_FIELDS, SEAL_ROOT_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.rd]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.rd]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.rd]);
+    },
+});
+const SEAL_SOURCE_FIELDS = Object.freeze(["s", "d"]);
+const SEAL_SOURCE_CAST = Object.freeze({
+    s: castage(NumberPrimitive, "numh"),
+    d: castage(Diger),
+});
+export const SealSource = withSadProjection({
+    name: "SealSource",
+    fields: SEAL_SOURCE_FIELDS,
+    cast: SEAL_SOURCE_CAST,
+    coden: "SealSourceCouples",
+    fromTuple([s, d]) {
+        return freezeRecord({ s, d });
+    },
+    fromQb64bTuple([s, d]) {
+        return freezeRecord({
+            s: new NumberPrimitive({ qb64b: s }),
+            d: new Diger({ qb64b: d }),
+        });
+    },
+    toTuple(value) {
+        return [value.s, value.d];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_SOURCE_FIELDS, SEAL_SOURCE_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.s, value.d]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.s, value.d]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.s, value.d]);
+    },
+});
+const SEAL_EVENT_FIELDS = Object.freeze(["i", "s", "d"]);
+const SEAL_EVENT_CAST = Object.freeze({
+    i: castage(Prefixer),
+    s: castage(NumberPrimitive, "numh"),
+    d: castage(Diger),
+});
+export const SealEvent = withSadProjection({
+    name: "SealEvent",
+    fields: SEAL_EVENT_FIELDS,
+    cast: SEAL_EVENT_CAST,
+    coden: "SealSourceTriples",
+    fromTuple([i, s, d]) {
+        return freezeRecord({ i, s, d });
+    },
+    fromQb64bTuple([i, s, d]) {
+        return freezeRecord({
+            i: new Prefixer({ qb64b: i }),
+            s: new NumberPrimitive({ qb64b: s }),
+            d: new Diger({ qb64b: d }),
+        });
+    },
+    toTuple(value) {
+        return [value.i, value.s, value.d];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_EVENT_FIELDS, SEAL_EVENT_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.i, value.s, value.d]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.i, value.s, value.d]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.i, value.s, value.d]);
+    },
+});
+const SEAL_LAST_FIELDS = Object.freeze(["i"]);
+const SEAL_LAST_CAST = Object.freeze({ i: castage(Prefixer) });
+export const SealLast = withSadProjection({
+    name: "SealLast",
+    fields: SEAL_LAST_FIELDS,
+    cast: SEAL_LAST_CAST,
+    coden: "SealSourceLastSingles",
+    fromTuple([i]) {
+        return freezeRecord({ i });
+    },
+    fromQb64bTuple([i]) {
+        return freezeRecord({ i: new Prefixer({ qb64b: i }) });
+    },
+    toTuple(value) {
+        return [value.i];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_LAST_FIELDS, SEAL_LAST_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.i]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.i]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.i]);
+    },
+});
+const SEAL_BACK_FIELDS = Object.freeze(["bi", "d"]);
+const SEAL_BACK_CAST = Object.freeze({
+    bi: castage(Prefixer),
+    d: castage(Diger),
+});
+export const SealBack = withSadProjection({
+    name: "SealBack",
+    fields: SEAL_BACK_FIELDS,
+    cast: SEAL_BACK_CAST,
+    coden: "BackerRegistrarSealCouples",
+    fromTuple([bi, d]) {
+        return freezeRecord({ bi, d });
+    },
+    fromQb64bTuple([bi, d]) {
+        return freezeRecord({
+            bi: new Prefixer({ qb64b: bi }),
+            d: new Diger({ qb64b: d }),
+        });
+    },
+    toTuple(value) {
+        return [value.bi, value.d];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_BACK_FIELDS, SEAL_BACK_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.bi, value.d]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.bi, value.d]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.bi, value.d]);
+    },
+});
+const SEAL_KIND_FIELDS = Object.freeze(["t", "d"]);
+const SEAL_KIND_CAST = Object.freeze({
+    t: castage(Verser),
+    d: castage(Diger),
+});
+export const SealKind = withSadProjection({
+    name: "SealKind",
+    fields: SEAL_KIND_FIELDS,
+    cast: SEAL_KIND_CAST,
+    coden: "TypedDigestSealCouples",
+    fromTuple([t, d]) {
+        return freezeRecord({ t, d });
+    },
+    fromQb64bTuple([t, d]) {
+        return freezeRecord({
+            t: new Verser({ qb64b: t }),
+            d: new Diger({ qb64b: d }),
+        });
+    },
+    toTuple(value) {
+        return [value.t, value.d];
+    },
+    toCrew(value) {
+        return buildCrew(SEAL_KIND_FIELDS, SEAL_KIND_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.t, value.d]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.t, value.d]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.t, value.d]);
+    },
+});
+const BLIND_STATE_FIELDS = Object.freeze(["d", "u", "td", "ts"]);
+const BLIND_STATE_CAST = Object.freeze({
+    d: castage(Noncer, "nonce"),
+    u: castage(Noncer, "nonce"),
+    td: castage(Noncer, "nonce"),
+    ts: castage(Labeler, "text"),
+});
+export const BlindState = withSadProjection({
+    name: "BlindState",
+    fields: BLIND_STATE_FIELDS,
+    cast: BLIND_STATE_CAST,
+    coden: "BlindedStateQuadruples",
+    fromTuple([d, u, td, ts]) {
+        return freezeRecord({ d, u, td, ts });
+    },
+    fromQb64bTuple([d, u, td, ts]) {
+        return freezeRecord({
+            d: new Noncer({ qb64b: d }),
+            u: new Noncer({ qb64b: u }),
+            td: new Noncer({ qb64b: td }),
+            ts: new Labeler({ qb64b: ts }),
+        });
+    },
+    toTuple(value) {
+        return [value.d, value.u, value.td, value.ts];
+    },
+    toCrew(value) {
+        return buildCrew(BLIND_STATE_FIELDS, BLIND_STATE_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.d, value.u, value.td, value.ts]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.d, value.u, value.td, value.ts]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.d, value.u, value.td, value.ts]);
+    },
+});
+const BOUND_STATE_FIELDS = Object.freeze(["d", "u", "td", "ts", "bn", "bd"]);
+const BOUND_STATE_CAST = Object.freeze({
+    d: castage(Noncer, "nonce"),
+    u: castage(Noncer, "nonce"),
+    td: castage(Noncer, "nonce"),
+    ts: castage(Labeler, "text"),
+    bn: castage(NumberPrimitive, "numh"),
+    bd: castage(Noncer, "nonce"),
+});
+export const BoundState = withSadProjection({
+    name: "BoundState",
+    fields: BOUND_STATE_FIELDS,
+    cast: BOUND_STATE_CAST,
+    coden: "BoundStateSextuples",
+    fromTuple([d, u, td, ts, bn, bd]) {
+        return freezeRecord({ d, u, td, ts, bn, bd });
+    },
+    fromQb64bTuple([d, u, td, ts, bn, bd]) {
+        return freezeRecord({
+            d: new Noncer({ qb64b: d }),
+            u: new Noncer({ qb64b: u }),
+            td: new Noncer({ qb64b: td }),
+            ts: new Labeler({ qb64b: ts }),
+            bn: new NumberPrimitive({ qb64b: bn }),
+            bd: new Noncer({ qb64b: bd }),
+        });
+    },
+    toTuple(value) {
+        return [
+            value.d,
+            value.u,
+            value.td,
+            value.ts,
+            value.bn,
+            value.bd,
+        ];
+    },
+    toCrew(value) {
+        return buildCrew(BOUND_STATE_FIELDS, BOUND_STATE_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([
+            value.d,
+            value.u,
+            value.td,
+            value.ts,
+            value.bn,
+            value.bd,
+        ]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([
+            value.d,
+            value.u,
+            value.td,
+            value.ts,
+            value.bn,
+            value.bd,
+        ]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([
+            value.d,
+            value.u,
+            value.td,
+            value.ts,
+            value.bn,
+            value.bd,
+        ]);
+    },
+});
+const TYPE_MEDIA_FIELDS = Object.freeze(["d", "u", "mt", "mv"]);
+const TYPE_MEDIA_CAST = Object.freeze({
+    d: castage(Noncer, "nonce"),
+    u: castage(Noncer, "nonce"),
+    mt: castage(Labeler, "text"),
+    mv: castage(Texter, "text"),
+});
+export const TypeMedia = withSadProjection({
+    name: "TypeMedia",
+    fields: TYPE_MEDIA_FIELDS,
+    cast: TYPE_MEDIA_CAST,
+    coden: "TypedMediaQuadruples",
+    fromTuple([d, u, mt, mv]) {
+        return freezeRecord({ d, u, mt, mv });
+    },
+    fromQb64bTuple([d, u, mt, mv]) {
+        return freezeRecord({
+            d: new Noncer({ qb64b: d }),
+            u: new Noncer({ qb64b: u }),
+            mt: new Labeler({ qb64b: mt }),
+            mv: new Texter({ qb64b: mv }),
+        });
+    },
+    toTuple(value) {
+        return [value.d, value.u, value.mt, value.mv];
+    },
+    toCrew(value) {
+        return buildCrew(TYPE_MEDIA_FIELDS, TYPE_MEDIA_CAST, value);
+    },
+    qb64(value) {
+        return serializeTupleQb64([value.d, value.u, value.mt, value.mv]);
+    },
+    qb64b(value) {
+        return serializeTupleQb64b([value.d, value.u, value.mt, value.mv]);
+    },
+    qb2(value) {
+        return serializeTupleQb2([value.d, value.u, value.mt, value.mv]);
+    },
+});
+/** Empty clan registry placeholder retained for KERIpy naming familiarity. */
+export const EmptyClanDom = Object.freeze({});
+/** Empty cast registry placeholder retained for KERIpy naming familiarity. */
+export const EmptyCastDom = Object.freeze({});
+/** KERIpy alias for `EmptyClanDom`. */
+export const EClanDom = EmptyClanDom;
+/** KERIpy alias for `EmptyCastDom`. */
+export const ECastDom = EmptyCastDom;
+/** Seal-struct clan registry (`SealDigest` through `SealKind`). */
+export const SealClanDom = Object.freeze({
+    SealDigest,
+    SealRoot,
+    SealSource,
+    SealEvent,
+    SealLast,
+    SealBack,
+    SealKind,
+});
+/** KERIpy alias for `SealClanDom`. */
+export const SClanDom = SealClanDom;
+/** Seal-struct cast registry keyed by clan name. */
+export const SealCastDom = Object.freeze({
+    SealDigest: SealDigest.cast,
+    SealRoot: SealRoot.cast,
+    SealSource: SealSource.cast,
+    SealEvent: SealEvent.cast,
+    SealLast: SealLast.cast,
+    SealBack: SealBack.cast,
+    SealKind: SealKind.cast,
+});
+/** KERIpy alias for `SealCastDom`. */
+export const SCastDom = SealCastDom;
+/** Blind-state clan registry (`BlindState`, `BoundState`). */
+export const BlindStateClanDom = Object.freeze({
+    BlindState,
+    BoundState,
+});
+/** KERIpy alias for `BlindStateClanDom`. */
+export const BSClanDom = BlindStateClanDom;
+/** Blind-state cast registry keyed by clan name. */
+export const BlindStateCastDom = Object.freeze({
+    BlindState: BlindState.cast,
+    BoundState: BoundState.cast,
+});
+/** KERIpy alias for `BlindStateCastDom`. */
+export const BSCastDom = BlindStateCastDom;
+/** Typed-media clan registry (`TypeMedia`). */
+export const TypeMediaClanDom = Object.freeze({
+    TypeMedia,
+});
+/** KERIpy alias for `TypeMediaClanDom`. */
+export const TMClanDom = TypeMediaClanDom;
+/** Typed-media cast registry keyed by clan name. */
+export const TypeMediaCastDom = Object.freeze({
+    TypeMedia: TypeMedia.cast,
+});
+/** KERIpy alias for `TypeMediaCastDom`. */
+export const TMCastDom = TypeMediaCastDom;
+/** All structing clan registries combined into one authoritative CESR view. */
+export const AllClanDom = Object.freeze({
+    ...SealClanDom,
+    ...BlindStateClanDom,
+    ...TypeMediaClanDom,
+});
+/** KERIpy alias for `AllClanDom`. */
+export const AClanDom = AllClanDom;
+/** All structing cast registries combined into one authoritative CESR view. */
+export const AllCastDom = Object.freeze({
+    ...SealCastDom,
+    ...BlindStateCastDom,
+    ...TypeMediaCastDom,
+});
+/** KERIpy alias for `AllCastDom`. */
+export const ACastDom = AllCastDom;
+/** Ordered seal descriptor registry for raw-SAD projection helpers. */
+export const SealDescriptors = Object.freeze([
+    SealDigest,
+    SealRoot,
+    SealSource,
+    SealEvent,
+    SealLast,
+    SealBack,
+    SealKind,
+]);
+/**
+ * Authoritative clan-name -> semantic counter-name map for structing families.
+ *
+ * This mirrors KERIpy `ClanToCodens`, but stores semantic counter names rather
+ * than Python codex members.
+ */
+export const ClanToCodens = Object.freeze({
+    SealDigest: SealDigest.coden,
+    SealRoot: SealRoot.coden,
+    SealSource: SealSource.coden,
+    SealEvent: SealEvent.coden,
+    SealLast: SealLast.coden,
+    SealBack: SealBack.coden,
+    SealKind: SealKind.coden,
+    BlindState: BlindState.coden,
+    BoundState: BoundState.coden,
+    TypeMedia: TypeMedia.coden,
+});
+/** Inverse semantic counter-name -> clan-name registry for structing families. */
+export const CodenToClans = invertClanCodens(ClanToCodens);