keri-ts 0.10.0 → 0.10.2

package/esm/cesr/src/primitives/structing.js

@@ -1,727 +0,0 @@
-/**
- * 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.ts";
-import { Bexter } from "./bexter.ts";
-import { LabelDex, NonceDex } from "./codex.ts";
-import { Diger } from "./diger.ts";
-import { Labeler } from "./labeler.ts";
-import { Noncer } from "./noncer.ts";
-import { NumberPrimitive } from "./number.ts";
-import { Prefixer } from "./prefixer.ts";
-import { Texter } from "./texter.ts";
-import { Verser } from "./verser.ts";
-/**
- * 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);