@cloudyventures/baseh 1.1.0 → 2.0.0

package/dist/cjs/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripVowels = exports.effectiveBlocklist = exports.DEFAULT_BLOCKLIST = exports.inspect = exports.validate = exports.decode = exports.encode = exports.expandableGrouping = exports.generationForId = exports.generationCapacity = exports.generationBase = exports.FROZEN_KEY_BYTES = exports.basehExpandablePV1 = exports.basehExpandableV1 = exports.basehHeavyPV1 = exports.basehMediumPV1 = exports.basehLightPV1 = exports.basehMinimumPV1 = exports.basehHeavyV1 = exports.basehMediumV1 = exports.basehLightV1 = exports.basehMinimumV1 = exports.inversePermute = exports.permute = exports.checksumValue = exports.calculateChecksum = exports.alphabetIndex = exports.decodeBaseN = exports.encodeBaseN = exports.CONFUSION_MAPS = exports.generateCandidates = exports.formatRaw = exports.normalize = exports.Baseh = exports.effectiveChecksumLength = exports.prepareProfile = exports.BasehError = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "BasehError", { enumerable: true, get: function () { return errors_js_1.BasehError; } });
+var profile_js_1 = require("./profile.js");
+Object.defineProperty(exports, "prepareProfile", { enumerable: true, get: function () { return profile_js_1.prepareProfile; } });
+Object.defineProperty(exports, "effectiveChecksumLength", { enumerable: true, get: function () { return profile_js_1.effectiveChecksumLength; } });
+var codec_js_1 = require("./codec.js");
+Object.defineProperty(exports, "Baseh", { enumerable: true, get: function () { return codec_js_1.Baseh; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return codec_js_1.normalize; } });
+Object.defineProperty(exports, "formatRaw", { enumerable: true, get: function () { return codec_js_1.formatRaw; } });
+Object.defineProperty(exports, "generateCandidates", { enumerable: true, get: function () { return codec_js_1.generateCandidates; } });
+Object.defineProperty(exports, "CONFUSION_MAPS", { enumerable: true, get: function () { return codec_js_1.CONFUSION_MAPS; } });
+var basen_js_1 = require("./basen.js");
+Object.defineProperty(exports, "encodeBaseN", { enumerable: true, get: function () { return basen_js_1.encodeBaseN; } });
+Object.defineProperty(exports, "decodeBaseN", { enumerable: true, get: function () { return basen_js_1.decodeBaseN; } });
+Object.defineProperty(exports, "alphabetIndex", { enumerable: true, get: function () { return basen_js_1.alphabetIndex; } });
+var checksum_js_1 = require("./checksum.js");
+Object.defineProperty(exports, "calculateChecksum", { enumerable: true, get: function () { return checksum_js_1.calculateChecksum; } });
+Object.defineProperty(exports, "checksumValue", { enumerable: true, get: function () { return checksum_js_1.checksumValue; } });
+var feistel_js_1 = require("./feistel.js");
+Object.defineProperty(exports, "permute", { enumerable: true, get: function () { return feistel_js_1.permute; } });
+Object.defineProperty(exports, "inversePermute", { enumerable: true, get: function () { return feistel_js_1.inversePermute; } });
+var profiles_js_1 = require("./profiles.js");
+Object.defineProperty(exports, "basehMinimumV1", { enumerable: true, get: function () { return profiles_js_1.basehMinimumV1; } });
+Object.defineProperty(exports, "basehLightV1", { enumerable: true, get: function () { return profiles_js_1.basehLightV1; } });
+Object.defineProperty(exports, "basehMediumV1", { enumerable: true, get: function () { return profiles_js_1.basehMediumV1; } });
+Object.defineProperty(exports, "basehHeavyV1", { enumerable: true, get: function () { return profiles_js_1.basehHeavyV1; } });
+Object.defineProperty(exports, "basehMinimumPV1", { enumerable: true, get: function () { return profiles_js_1.basehMinimumPV1; } });
+Object.defineProperty(exports, "basehLightPV1", { enumerable: true, get: function () { return profiles_js_1.basehLightPV1; } });
+Object.defineProperty(exports, "basehMediumPV1", { enumerable: true, get: function () { return profiles_js_1.basehMediumPV1; } });
+Object.defineProperty(exports, "basehHeavyPV1", { enumerable: true, get: function () { return profiles_js_1.basehHeavyPV1; } });
+Object.defineProperty(exports, "basehExpandableV1", { enumerable: true, get: function () { return profiles_js_1.basehExpandableV1; } });
+Object.defineProperty(exports, "basehExpandablePV1", { enumerable: true, get: function () { return profiles_js_1.basehExpandablePV1; } });
+Object.defineProperty(exports, "FROZEN_KEY_BYTES", { enumerable: true, get: function () { return profiles_js_1.FROZEN_KEY_BYTES; } });
+var codec_js_2 = require("./codec.js");
+Object.defineProperty(exports, "generationBase", { enumerable: true, get: function () { return codec_js_2.generationBase; } });
+Object.defineProperty(exports, "generationCapacity", { enumerable: true, get: function () { return codec_js_2.generationCapacity; } });
+Object.defineProperty(exports, "generationForId", { enumerable: true, get: function () { return codec_js_2.generationForId; } });
+Object.defineProperty(exports, "expandableGrouping", { enumerable: true, get: function () { return codec_js_2.expandableGrouping; } });
+var facade_js_1 = require("./facade.js");
+Object.defineProperty(exports, "encode", { enumerable: true, get: function () { return facade_js_1.encode; } });
+Object.defineProperty(exports, "decode", { enumerable: true, get: function () { return facade_js_1.decode; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return facade_js_1.validate; } });
+Object.defineProperty(exports, "inspect", { enumerable: true, get: function () { return facade_js_1.inspect; } });
+var blocklist_js_1 = require("./blocklist.js");
+Object.defineProperty(exports, "DEFAULT_BLOCKLIST", { enumerable: true, get: function () { return blocklist_js_1.DEFAULT_BLOCKLIST; } });
+Object.defineProperty(exports, "effectiveBlocklist", { enumerable: true, get: function () { return blocklist_js_1.effectiveBlocklist; } });
+Object.defineProperty(exports, "stripVowels", { enumerable: true, get: function () { return blocklist_js_1.stripVowels; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/profile.d.ts

@@ -0,0 +1,91 @@
+import { type BasehProfanity } from "./blocklist.js";
+export type BasehPermutation = {
+    enabled: false;
+} | {
+    enabled: true;
+    algorithm: "feistel-v1";
+    keyId: string;
+    keyBytes: Uint8Array;
+    rounds: number;
+};
+export interface BasehProfile {
+    profileId: string;
+    /**
+     * Spec 2.1/19.9. "fixed" keeps the classic constant-width behaviour;
+     * "expandable" gives variable-length codes driven by id magnitude
+     * (spec 19). Profiles that predate the mode field are fixed: the shared
+     * frozen vectors pin their byte-for-byte behaviour, so a missing mode is
+     * prepared as "fixed".
+     */
+    mode?: "fixed" | "expandable";
+    bodyAlphabet: string;
+    /** Fixed mode only; ignored in expandable mode. */
+    bodyLength?: number;
+    /** Expandable mode only; default 4. Must exceed checksumLength. */
+    minLength?: number;
+    checksumAlphabet: string;
+    checksumLength: number;
+    /**
+     * Spec 22. Expandable mode only. The checksum width used by generations at
+     * or below `shortChecksumUntil`; may be 0 (a zero-checksum window: those
+     * generations carry no checksum symbols and no typo detection). Without a
+     * window (`shortChecksumUntil` absent or 0) this must be absent or 0.
+     */
+    shortChecksumLength?: number;
+    /**
+     * Spec 22. The last generation (total length) that uses the short
+     * checksum; 0 or absent turns the feature off (the codebase convention,
+     * like maxRepetition). When set it must be an integer from `minLength`
+     * through 8.
+     */
+    shortChecksumUntil?: number;
+    caseSensitive: boolean;
+    separator: string;
+    /** Expandable mode only; default 0 (separator always applies). */
+    separatorMinLength?: number;
+    grouping: number[];
+    aliases: Record<string, string>;
+    permutation: BasehPermutation;
+    /** Spec 18. Defaults to mode "none". */
+    profanity?: BasehProfanity;
+    /**
+     * Spec 21. Maximum allowed run of the same symbol in a raw code. 0 (the
+     * default) disables the filter; otherwise it must be an integer of at
+     * least 3. A value above the code length is a legal no-op.
+     */
+    maxRepetition?: number;
+}
+/** Case-prepared derived data, computed once at construction. */
+export interface PreparedProfile extends BasehProfile {
+    readonly mode: "fixed" | "expandable";
+    readonly minLength: number;
+    readonly separatorMinLength: number;
+    readonly bodyAlphabetNorm: string;
+    readonly checksumAlphabetNorm: string;
+    readonly aliasesNorm: Record<string, string>;
+    readonly checksumModulus: bigint;
+    /** Fixed-mode capacity A^bodyLength. Meaningless in expandable mode. */
+    readonly capacity: bigint;
+    /** Spec 18. Empty unless the profile uses mode "blocklist". */
+    readonly blocklist: string[];
+    /** Spec 21. 0 disables the repetition filter. */
+    readonly maxRepetition: number;
+    /** Spec 22. 0 disables the short checksum. */
+    readonly shortChecksumLength: number;
+    /** Spec 22. Last short-checksum generation; 0 when the feature is off. */
+    readonly shortChecksumUntil: number;
+}
+/**
+ * Spec 22. The checksum length that applies to a generation of the given
+ * total length: `shortChecksumLength` at or below `shortChecksumUntil`,
+ * `checksumLength` above it (and always in fixed mode). The feature is on
+ * exactly when `shortChecksumUntil` is non-zero; a `shortChecksumLength` of
+ * 0 then means the window's generations carry no checksum symbols at all.
+ */
+export declare function effectiveChecksumLength(profile: PreparedProfile, length: number): number;
+/**
+ * Validates a profile per spec section 2.2 and returns it with derived,
+ * pre-computed values. Throws BasehError INVALID_PROFILE on any violation.
+ * Call once at construction, never per encode/decode.
+ */
+export declare function prepareProfile(profile: BasehProfile): PreparedProfile;

package/dist/cjs/profile.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectiveChecksumLength = effectiveChecksumLength;
+exports.prepareProfile = prepareProfile;
+const errors_js_1 = require("./errors.js");
+const basen_js_1 = require("./basen.js");
+const blocklist_js_1 = require("./blocklist.js");
+/**
+ * Spec 22. The checksum length that applies to a generation of the given
+ * total length: `shortChecksumLength` at or below `shortChecksumUntil`,
+ * `checksumLength` above it (and always in fixed mode). The feature is on
+ * exactly when `shortChecksumUntil` is non-zero; a `shortChecksumLength` of
+ * 0 then means the window's generations carry no checksum symbols at all.
+ */
+function effectiveChecksumLength(profile, length) {
+    if (profile.mode === "expandable" && profile.shortChecksumUntil > 0 && length <= profile.shortChecksumUntil) {
+        return profile.shortChecksumLength;
+    }
+    return profile.checksumLength;
+}
+const ASCII_ONLY = /^[\x20-\x7e]*$/;
+function fail(reason) {
+    throw new errors_js_1.BasehError("INVALID_PROFILE", `Invalid baseH profile: ${reason}`, false);
+}
+function isAsciiChar(ch) {
+    return ch.length === 1 && ASCII_ONLY.test(ch);
+}
+function norm(profile, ch) {
+    return profile.caseSensitive ? ch : ch.toUpperCase();
+}
+/**
+ * Validates a profile per spec section 2.2 and returns it with derived,
+ * pre-computed values. Throws BasehError INVALID_PROFILE on any violation.
+ * Call once at construction, never per encode/decode.
+ */
+function prepareProfile(profile) {
+    if (!profile || typeof profile !== "object")
+        fail("profile is required");
+    if (typeof profile.profileId !== "string" || profile.profileId.length === 0) {
+        fail("profileId must be non-empty");
+    }
+    if (!ASCII_ONLY.test(profile.profileId))
+        fail("profileId must be ASCII");
+    // Spec 2.2/19.9. A persisted or frozen profile declares its mode; profiles
+    // built before the mode field existed are fixed, so the frozen vectors keep
+    // matching byte for byte.
+    const mode = profile.mode ?? "fixed";
+    if (mode !== "fixed" && mode !== "expandable")
+        fail("mode must be fixed or expandable");
+    const caseSensitive = profile.caseSensitive === true;
+    const bodyAlphabet = profile.bodyAlphabet;
+    if (typeof bodyAlphabet !== "string" || bodyAlphabet.length < 2) {
+        fail("bodyAlphabet needs at least two symbols");
+    }
+    for (const ch of bodyAlphabet) {
+        if (!isAsciiChar(ch))
+            fail(`body alphabet symbol is not single ASCII: ${JSON.stringify(ch)}`);
+    }
+    const view = { caseSensitive };
+    let bodyNorm = [...bodyAlphabet].map((c) => norm(view, c)).join("");
+    // Spec 19.2: in expandable mode the zero ban strips 0 and O from the body
+    // alphabet silently, before any other validation, exactly like the
+    // no-vowels strip of section 18.1.
+    if (mode === "expandable") {
+        bodyNorm = [...bodyNorm].filter((c) => c !== "0" && c !== "O").join("");
+    }
+    if (new Set(bodyNorm).size !== bodyNorm.length) {
+        fail("body alphabet symbols must be unique after case normalization");
+    }
+    if (mode === "fixed") {
+        if (!Number.isInteger(profile.bodyLength) ||
+            profile.bodyLength < 1 ||
+            profile.bodyLength > 32) {
+            fail("bodyLength must be an integer from 1 through 32");
+        }
+    }
+    const minLength = profile.minLength ?? 4;
+    const separatorMinLength = profile.separatorMinLength ?? 0;
+    if (mode === "fixed" && separatorMinLength !== 0) {
+        fail("separatorMinLength must be 0 in fixed mode");
+    }
+    if (!Number.isInteger(profile.checksumLength) ||
+        profile.checksumLength < 0 ||
+        profile.checksumLength > 8) {
+        fail("checksumLength must be an integer from 0 through 8");
+    }
+    if (mode === "expandable") {
+        if (!Number.isInteger(minLength) || minLength < 1) {
+            fail("minLength must be an integer of at least 1");
+        }
+        if (minLength <= profile.checksumLength) {
+            fail("minLength must be greater than checksumLength");
+        }
+        if (!Number.isInteger(separatorMinLength) || separatorMinLength < 0) {
+            fail("separatorMinLength must be an integer of at least 0");
+        }
+    }
+    // Spec 22. The short checksum is expandable-only. The window field is the
+    // switch: `shortChecksumUntil` of 0 or absent turns the feature off (the
+    // codebase convention, like maxRepetition), and the length field without
+    // a window is INVALID_PROFILE.
+    const shortChecksumLength = profile.shortChecksumLength ?? 0;
+    const shortChecksumUntil = profile.shortChecksumUntil ?? 0;
+    if (mode === "fixed") {
+        if (shortChecksumLength !== 0 || shortChecksumUntil !== 0) {
+            fail("shortChecksumLength and shortChecksumUntil are expandable-mode only");
+        }
+    }
+    else if (shortChecksumUntil !== 0) {
+        if (!Number.isInteger(profile.shortChecksumUntil) || shortChecksumUntil < minLength) {
+            fail("shortChecksumUntil must be an integer of at least minLength");
+        }
+        // Beyond 8 the window would swallow nearly every practical code, and
+        // long codes genuinely want two checksum symbols.
+        if (shortChecksumUntil > 8) {
+            fail("shortChecksumUntil must be at most 8");
+        }
+        if (!Number.isInteger(shortChecksumLength) ||
+            shortChecksumLength < 0 ||
+            shortChecksumLength >= profile.checksumLength) {
+            fail("shortChecksumLength must be an integer from 0 through checksumLength - 1");
+        }
+        if (minLength <= shortChecksumLength) {
+            fail("minLength must be greater than shortChecksumLength");
+        }
+    }
+    else if (shortChecksumLength !== 0) {
+        fail("shortChecksumLength requires shortChecksumUntil");
+    }
+    const checksumAlphabet = profile.checksumAlphabet ?? "";
+    let checksumNorm = [...checksumAlphabet].map((c) => norm(view, c)).join("");
+    if (mode === "expandable") {
+        // Spec 19.3: the checksum alphabet is derived, "0" followed by the body
+        // alphabet in order. The configured checksumAlphabet is not consulted.
+        checksumNorm = "";
+    }
+    else if (profile.checksumLength > 0) {
+        if (typeof checksumAlphabet !== "string" || checksumAlphabet.length < 2) {
+            fail("checksumAlphabet needs at least two symbols when checksumLength is positive");
+        }
+        for (const ch of checksumAlphabet) {
+            if (!isAsciiChar(ch))
+                fail(`checksum alphabet symbol is not single ASCII: ${JSON.stringify(ch)}`);
+        }
+        if (new Set(checksumNorm).size !== checksumNorm.length) {
+            fail("checksum alphabet symbols must be unique after case normalization");
+        }
+    }
+    // Spec 18. no-vowels strips vowels before every downstream rule; blocklist
+    // only arms the encode-time scan.
+    const profanity = profile.profanity ?? { mode: "none" };
+    if (!["none", "no-vowels", "blocklist"].includes(profanity.mode)) {
+        fail("profanity mode must be none, no-vowels or blocklist");
+    }
+    if (profanity.mode === "no-vowels") {
+        bodyNorm = (0, blocklist_js_1.stripVowels)(bodyNorm);
+        checksumNorm = (0, blocklist_js_1.stripVowels)(checksumNorm);
+        if (bodyNorm.length < 2) {
+            fail("no-vowels mode leaves the body alphabet with fewer than two symbols");
+        }
+        if (mode === "fixed" && profile.checksumLength > 0 && checksumNorm.length < 2) {
+            fail("no-vowels mode leaves the checksum alphabet with fewer than two symbols");
+        }
+    }
+    if (mode === "expandable") {
+        // Derived after every body strip (zero ban, no-vowels) so all downstream
+        // rules — modulus, separator collision, alias targets — see the final
+        // alphabets.
+        checksumNorm = "0" + bodyNorm;
+    }
+    if (bodyNorm.length < 2) {
+        fail("body alphabet needs at least two symbols after preparation");
+    }
+    const blocklist = profanity.mode === "blocklist" ? (0, blocklist_js_1.effectiveBlocklist)(profanity) : [];
+    // Spec 21: 0 disables the filter; an active filter needs a floor of 3 —
+    // banning pairs (2) would destroy roughly 9% of every generation.
+    const maxRepetition = profile.maxRepetition ?? 0;
+    if (!Number.isInteger(maxRepetition) || maxRepetition < 0 || (maxRepetition > 0 && maxRepetition < 3)) {
+        fail("maxRepetition must be 0 (off) or an integer of at least 3");
+    }
+    const separator = profile.separator ?? "";
+    for (const ch of separator) {
+        if (bodyNorm.includes(ch) || checksumNorm.includes(ch)) {
+            fail("separator must not occur in either alphabet");
+        }
+    }
+    const aliases = profile.aliases ?? {};
+    const aliasesNorm = {};
+    const canonicalSet = new Set([...bodyNorm, ...checksumNorm]);
+    for (const [src, tgt] of Object.entries(aliases)) {
+        if (!isAsciiChar(src))
+            fail(`alias source is not single ASCII: ${JSON.stringify(src)}`);
+        if (!isAsciiChar(tgt))
+            fail(`alias target is not single ASCII: ${JSON.stringify(tgt)}`);
+        const sNorm = norm(view, src);
+        const tNorm = norm(view, tgt);
+        if (!canonicalSet.has(tNorm)) {
+            fail(`alias target ${JSON.stringify(tgt)} is not a canonical symbol`);
+        }
+        // Spec 3.2: an alias must never map two distinct canonical symbols into
+        // one value. Fixed mode rejects a canonical alias source outright. In
+        // expandable mode the frozen tier (spec 17.1) carries aliases whose
+        // sources are canonical body symbols (T, N, W stay in the body
+        // alphabet); the canonical symbol wins at normalization, making those
+        // entries inert instead of destructive.
+        if (mode === "fixed" && canonicalSet.has(sNorm)) {
+            fail(`alias source ${JSON.stringify(src)} is already a canonical symbol`);
+        }
+        if (sNorm in aliasesNorm)
+            fail(`duplicate alias source ${JSON.stringify(sNorm)} after case normalization`);
+        if (tNorm in aliases || [...Object.keys(aliases)].some((k) => norm(view, k) === tNorm)) {
+            fail(`alias chain forbidden: target ${tNorm} is also an alias source`);
+        }
+        aliasesNorm[sNorm] = tNorm;
+    }
+    const total = bodySum(profile.grouping);
+    if (separator.length === 0) {
+        if (profile.grouping.length !== 0)
+            fail("grouping must be empty when separator is empty");
+    }
+    else if (mode === "expandable") {
+        // Spec 19.5: the balanced grouping rule is a pure function of the total
+        // length, so a configurable grouping is meaningless in expandable mode.
+        if (profile.grouping.length !== 0)
+            fail("grouping must be empty in expandable mode");
+    }
+    else if (total !== profile.bodyLength + profile.checksumLength) {
+        fail("group sizes must sum to bodyLength + checksumLength");
+    }
+    const permutation = profile.permutation ?? { enabled: false };
+    if (permutation.enabled) {
+        if (permutation.algorithm !== "feistel-v1")
+            fail("unknown permutation algorithm");
+        if (typeof permutation.keyId !== "string" || permutation.keyId.length === 0) {
+            fail("permutation requires a keyId");
+        }
+        if (!(permutation.keyBytes instanceof Uint8Array) || permutation.keyBytes.length === 0) {
+            fail("permutation requires key material");
+        }
+        if (!Number.isInteger(permutation.rounds) ||
+            permutation.rounds < 4 ||
+            permutation.rounds > 16 ||
+            permutation.rounds % 2 !== 0) {
+            fail("Feistel rounds must be an even integer from 4 through 16");
+        }
+    }
+    return {
+        ...profile,
+        mode,
+        minLength,
+        separatorMinLength,
+        caseSensitive,
+        checksumAlphabet,
+        separator,
+        grouping: [...profile.grouping],
+        aliases: { ...aliases },
+        permutation,
+        bodyAlphabetNorm: bodyNorm,
+        checksumAlphabetNorm: checksumNorm,
+        aliasesNorm,
+        checksumModulus: (0, basen_js_1.powBigInt)(BigInt(checksumNorm.length || 1), profile.checksumLength),
+        capacity: (0, basen_js_1.powBigInt)(BigInt(bodyNorm.length), profile.bodyLength ?? 0),
+        blocklist,
+        maxRepetition,
+        shortChecksumLength,
+        shortChecksumUntil
+    };
+}
+function bodySum(grouping) {
+    if (!Array.isArray(grouping))
+        return -1;
+    let sum = 0;
+    for (const g of grouping) {
+        if (!Number.isInteger(g) || g < 1)
+            return -1;
+        sum += g;
+    }
+    return sum;
+}

package/dist/cjs/profiles.d.ts

@@ -0,0 +1,33 @@
+import type { BasehProfile } from "./profile.js";
+/**
+ * The frozen published permutation key. Public by design: it makes issued
+ * codes look non-sequential but offers no secrecy, since anyone can read it
+ * here. Never swap it on a live namespace; codes only decode with the key
+ * they were issued under. Use the -p variants to supply private key material.
+ */
+export declare const FROZEN_KEY_BYTES: Uint8Array;
+export interface FrozenKeyOptions {
+    keyBytes: Uint8Array;
+    keyId?: string;
+    rounds?: number;
+}
+/** Alphanumeric, no safety strips, no checksum, hyphen-delimited XXX-XXX. */
+export declare function basehMinimumV1(): BasehProfile;
+/** baseh-minimum permuted with caller-supplied key material. */
+export declare function basehMinimumPV1(options: FrozenKeyOptions): BasehProfile;
+/** Visual light plus spoken light, two checksum symbols, hyphen-delimited. */
+export declare function basehLightV1(): BasehProfile;
+/** baseh-light permuted with caller-supplied key material. */
+export declare function basehLightPV1(options: FrozenKeyOptions): BasehProfile;
+/** Visual medium plus spoken medium, two checksum symbols, hyphen-delimited. The default. */
+export declare function basehMediumV1(): BasehProfile;
+/** baseh-medium permuted with caller-supplied key material. */
+export declare function basehMediumPV1(options: FrozenKeyOptions): BasehProfile;
+/** Conservative alphabet plus spoken heavy, two checksum symbols, hyphen-delimited. */
+export declare function basehHeavyV1(): BasehProfile;
+/** The frozen expandable tier; the recommended starting point for new namespaces. */
+export declare function basehExpandableV1(): BasehProfile;
+/** baseh-expandable permuted with caller-supplied key material. */
+export declare function basehExpandablePV1(options: FrozenKeyOptions): BasehProfile;
+/** baseh-heavy permuted with caller-supplied key material. */
+export declare function basehHeavyPV1(options: FrozenKeyOptions): BasehProfile;

package/dist/cjs/profiles.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FROZEN_KEY_BYTES = void 0;
+exports.basehMinimumV1 = basehMinimumV1;
+exports.basehMinimumPV1 = basehMinimumPV1;
+exports.basehLightV1 = basehLightV1;
+exports.basehLightPV1 = basehLightPV1;
+exports.basehMediumV1 = basehMediumV1;
+exports.basehMediumPV1 = basehMediumPV1;
+exports.basehHeavyV1 = basehHeavyV1;
+exports.basehExpandableV1 = basehExpandableV1;
+exports.basehExpandablePV1 = basehExpandablePV1;
+exports.basehHeavyPV1 = basehHeavyPV1;
+/**
+ * Frozen tiers. Each is built from the full alphanumeric set with cumulative
+ * visual and spoken strips; the spoken strips interact with the visual ones
+ * exactly as the web tools derive them, so the tool capacities match.
+ *
+ *   Minimum  36 symbols, no checksum, XXX-XXX      2,176,782,336 ids
+ *   Light    31 symbols, 2 checksums, XXXX-XXXX      887,503,681 ids
+ *   Medium   28 symbols, 2 checksums, XXXX-XXXX      481,890,304 ids (default)
+ *   Heavy    26 symbols, 2 checksums, XXXX-XXXX      308,915,776 ids
+ *
+ * All four keep the typed O/I/L aliases where possible, use a hyphen
+ * delimiter at the midpoint and run the default profanity blocklist. Every
+ * tier permutes with the frozen published key (FROZEN_KEY_BYTES below): the
+ * key is public, so the permutation obscures sequence but is not secrecy.
+ * The -p variants are identical but permute with caller-supplied key
+ * material instead.
+ */
+const OIL_ALIASES = { O: "0", I: "1", L: "1" };
+const MINIMUM_BODY = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const LIGHT_BODY = "0123456789ABCEFGHJKMNPQRSUVWXYZ";
+const MEDIUM_BODY = "0123456789ACDEFGHJKMPQRUVXYZ";
+const HEAVY_BODY = "0123456789ABCEFHJKMPQRVXYZ";
+const LIGHT_CHECK = "234679ACEFGHJKMNPQRUVWXY";
+const MEDIUM_CHECK = "234679ACDEFGHJKMPQRUVXY";
+const HEAVY_CHECK = "234679ACEFHJKMPQRUVXY";
+/**
+ * The frozen published permutation key. Public by design: it makes issued
+ * codes look non-sequential but offers no secrecy, since anyone can read it
+ * here. Never swap it on a live namespace; codes only decode with the key
+ * they were issued under. Use the -p variants to supply private key material.
+ */
+exports.FROZEN_KEY_BYTES = new TextEncoder().encode("baseh-frozen-key-v1");
+function keyedPermutation(options) {
+    return {
+        enabled: true,
+        algorithm: "feistel-v1",
+        keyId: options.keyId ?? "default",
+        keyBytes: options.keyBytes,
+        rounds: options.rounds ?? 8
+    };
+}
+function tier(shape, permutation, pSuffix) {
+    return {
+        profileId: shape.profileId + (pSuffix ? "-p" : "") + "-v1",
+        mode: "fixed",
+        bodyAlphabet: shape.bodyAlphabet,
+        bodyLength: 6,
+        checksumAlphabet: shape.checksumAlphabet,
+        checksumLength: shape.checksumLength,
+        caseSensitive: false,
+        separator: shape.separator,
+        grouping: shape.grouping,
+        aliases: { ...shape.aliases },
+        permutation,
+        profanity: { mode: "blocklist" },
+        maxRepetition: 4
+    };
+}
+const MINIMUM = {
+    profileId: "baseh-minimum",
+    bodyAlphabet: MINIMUM_BODY,
+    checksumAlphabet: "",
+    checksumLength: 0,
+    separator: "-",
+    grouping: [3, 3],
+    aliases: {}
+};
+const LIGHT = {
+    profileId: "baseh-light",
+    bodyAlphabet: LIGHT_BODY,
+    checksumAlphabet: LIGHT_CHECK,
+    checksumLength: 2,
+    separator: "-",
+    grouping: [4, 4],
+    aliases: { ...OIL_ALIASES, D: "B", T: "P" }
+};
+const MEDIUM = {
+    profileId: "baseh-medium",
+    bodyAlphabet: MEDIUM_BODY,
+    checksumAlphabet: MEDIUM_CHECK,
+    checksumLength: 2,
+    separator: "-",
+    grouping: [4, 4],
+    // B and S are dropped for looking like 8 and 5; since they can never be
+    // issued, a typed B is always an 8 and a typed S always a 5.
+    aliases: { ...OIL_ALIASES, B: "8", S: "5", T: "P", N: "M", W: "V" }
+};
+const HEAVY = {
+    profileId: "baseh-heavy",
+    bodyAlphabet: HEAVY_BODY,
+    checksumAlphabet: HEAVY_CHECK,
+    checksumLength: 2,
+    separator: "-",
+    grouping: [4, 4],
+    aliases: { ...OIL_ALIASES, D: "B", T: "P", N: "M", W: "V", S: "F", G: "C" }
+};
+/** Permutation every plain tier applies, built from the frozen published key. */
+function frozenPermutation() {
+    return keyedPermutation({ keyBytes: exports.FROZEN_KEY_BYTES, keyId: "frozen" });
+}
+/** Alphanumeric, no safety strips, no checksum, hyphen-delimited XXX-XXX. */
+function basehMinimumV1() {
+    return tier(MINIMUM, frozenPermutation(), false);
+}
+/** baseh-minimum permuted with caller-supplied key material. */
+function basehMinimumPV1(options) {
+    return tier(MINIMUM, keyedPermutation(options), true);
+}
+/** Visual light plus spoken light, two checksum symbols, hyphen-delimited. */
+function basehLightV1() {
+    return tier(LIGHT, frozenPermutation(), false);
+}
+/** baseh-light permuted with caller-supplied key material. */
+function basehLightPV1(options) {
+    return tier(LIGHT, keyedPermutation(options), true);
+}
+/** Visual medium plus spoken medium, two checksum symbols, hyphen-delimited. The default. */
+function basehMediumV1() {
+    return tier(MEDIUM, frozenPermutation(), false);
+}
+/** baseh-medium permuted with caller-supplied key material. */
+function basehMediumPV1(options) {
+    return tier(MEDIUM, keyedPermutation(options), true);
+}
+/** Conservative alphabet plus spoken heavy, two checksum symbols, hyphen-delimited. */
+function basehHeavyV1() {
+    return tier(HEAVY, frozenPermutation(), false);
+}
+// Spec 17.1. The expandable recommended default carries the same safety
+// posture as baseh-medium-v1: the medium visual strips (O, I, L, B, S) and
+// the medium spoken strips (T, N, W), so an issued code never emits a
+// visual or spoken confusable. The zero ban of section 19.2 then removes 0
+// (and O, already gone), leaving a 27-symbol body. The checksum alphabet
+// derives as "0" plus the body (28 symbols).
+const EXPANDABLE_BODY = "123456789ACDEFGHJKMPQRUVXYZ";
+/**
+ * Spec 17.1. The frozen expandable tier: four characters while the namespace
+ * is small, gaining one symbol automatically as issuance climbs past each
+ * generation's capacity. The body alphabet is the medium safety set (the
+ * full alphanumeric set minus the visual look-alikes O, I, L, B, S and the
+ * spoken-confusable T, N, W), with the zero ban of spec 19.2 removing 0 (27
+ * symbols); the checksum alphabet derives as "0" plus the body (28 symbols).
+ * The short checksum of spec 22 is on: one checksum symbol through five
+ * characters (27^3 = 19,683 ids at length 4, 27^4 = 531,441 at length 5),
+ * two from six characters up. The hyphen appears from six characters up,
+ * split by the balanced grouping rule of spec 19.5.
+ */
+function expandableTier(permutation, pSuffix) {
+    return {
+        profileId: "baseh-expandable" + (pSuffix ? "-p" : "") + "-v1",
+        mode: "expandable",
+        bodyAlphabet: EXPANDABLE_BODY,
+        minLength: 4,
+        checksumAlphabet: "0" + EXPANDABLE_BODY,
+        checksumLength: 2,
+        shortChecksumLength: 1,
+        shortChecksumUntil: 5,
+        caseSensitive: false,
+        separator: "-",
+        separatorMinLength: 6,
+        grouping: [],
+        aliases: { ...OIL_ALIASES, B: "8", S: "5", T: "P", N: "M", W: "V" },
+        permutation,
+        profanity: { mode: "blocklist" },
+        maxRepetition: 4
+    };
+}
+/** The frozen expandable tier; the recommended starting point for new namespaces. */
+function basehExpandableV1() {
+    return expandableTier(frozenPermutation(), false);
+}
+/** baseh-expandable permuted with caller-supplied key material. */
+function basehExpandablePV1(options) {
+    return expandableTier(keyedPermutation(options), true);
+}
+/** baseh-heavy permuted with caller-supplied key material. */
+function basehHeavyPV1(options) {
+    return tier(HEAVY, keyedPermutation(options), true);
+}