@cloudyventures/baseh 1.1.0 → 2.0.0

package/dist/profile.js

@@ -1,5 +1,19 @@
 import { BasehError } from "./errors.js";
+import { powBigInt } from "./basen.js";
 import { effectiveBlocklist, stripVowels } from "./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.
+ */
+export 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 BasehError("INVALID_PROFILE", `Invalid baseH profile: ${reason}`, false);
@@ -10,12 +24,6 @@ function isAsciiChar(ch) {
 function norm(profile, ch) {
     return profile.caseSensitive ? ch : ch.toUpperCase();
 }
-function powBigInt(base, exp) {
-    let result = 1n;
-    for (let i = 0; i < exp; i += 1)
-        result *= base;
-    return result;
-}
 /**
  * Validates a profile per spec section 2.2 and returns it with derived,
  * pre-computed values. Throws BasehError INVALID_PROFILE on any violation.
@@ -29,6 +37,12 @@ export function prepareProfile(profile) {
     }
     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) {
@@ -40,21 +54,83 @@ export function prepareProfile(profile) {
     }
     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 (!Number.isInteger(profile.bodyLength) ||
-        profile.bodyLength < 1 ||
-        profile.bodyLength > 32) {
-        fail("bodyLength must be an integer from 1 through 32");
+    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 ?? "";
-    if (profile.checksumLength > 0) {
+    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");
         }
@@ -62,10 +138,9 @@ export function prepareProfile(profile) {
             if (!isAsciiChar(ch))
                 fail(`checksum alphabet symbol is not single ASCII: ${JSON.stringify(ch)}`);
         }
-    }
-    let checksumNorm = [...checksumAlphabet].map((c) => norm(view, c)).join("");
-    if (new Set(checksumNorm).size !== checksumNorm.length) {
-        fail("checksum alphabet symbols must be unique after case normalization");
+        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.
@@ -79,11 +154,26 @@ export function prepareProfile(profile) {
         if (bodyNorm.length < 2) {
             fail("no-vowels mode leaves the body alphabet with fewer than two symbols");
         }
-        if (profile.checksumLength > 0 && checksumNorm.length < 2) {
+        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" ? 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)) {
@@ -100,12 +190,18 @@ export function prepareProfile(profile) {
             fail(`alias target is not single ASCII: ${JSON.stringify(tgt)}`);
         const sNorm = norm(view, src);
         const tNorm = norm(view, tgt);
-        if (canonicalSet.has(sNorm)) {
-            fail(`alias source ${JSON.stringify(src)} is already a canonical symbol`);
-        }
         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)) {
@@ -118,6 +214,12 @@ export function prepareProfile(profile) {
         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");
     }
@@ -140,6 +242,9 @@ export function prepareProfile(profile) {
     }
     return {
         ...profile,
+        mode,
+        minLength,
+        separatorMinLength,
         caseSensitive,
         checksumAlphabet,
         separator,
@@ -150,8 +255,11 @@ export function prepareProfile(profile) {
         checksumAlphabetNorm: checksumNorm,
         aliasesNorm,
         checksumModulus: powBigInt(BigInt(checksumNorm.length || 1), profile.checksumLength),
-        capacity: powBigInt(BigInt(bodyNorm.length), profile.bodyLength),
-        blocklist
+        capacity: powBigInt(BigInt(bodyNorm.length), profile.bodyLength ?? 0),
+        blocklist,
+        maxRepetition,
+        shortChecksumLength,
+        shortChecksumUntil
     };
 }
 function bodySum(grouping) {

package/dist/profiles.d.ts

@@ -1,4 +1,11 @@
 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;
@@ -6,17 +13,21 @@ export interface FrozenKeyOptions {
 }
 /** Alphanumeric, no safety strips, no checksum, hyphen-delimited XXX-XXX. */
 export declare function basehMinimumV1(): BasehProfile;
-/** baseh-minimum with feistel-v1 permutation. */
+/** baseh-minimum permuted with caller-supplied key material. */
 export declare function basehMinimumPV1(options: FrozenKeyOptions): BasehProfile;
-/** Visual light plus spoken light, one checksum symbol. */
+/** Visual light plus spoken light, two checksum symbols, hyphen-delimited. */
 export declare function basehLightV1(): BasehProfile;
-/** baseh-light with feistel-v1 permutation. */
+/** baseh-light permuted with caller-supplied key material. */
 export declare function basehLightPV1(options: FrozenKeyOptions): BasehProfile;
-/** Visual medium plus spoken medium, one checksum symbol. The default. */
+/** Visual medium plus spoken medium, two checksum symbols, hyphen-delimited. The default. */
 export declare function basehMediumV1(): BasehProfile;
-/** baseh-medium with feistel-v1 permutation. */
+/** baseh-medium permuted with caller-supplied key material. */
 export declare function basehMediumPV1(options: FrozenKeyOptions): BasehProfile;
-/** Conservative alphabet plus spoken heavy, one checksum symbol. */
+/** Conservative alphabet plus spoken heavy, two checksum symbols, hyphen-delimited. */
 export declare function basehHeavyV1(): BasehProfile;
-/** baseh-heavy with feistel-v1 permutation. */
+/** 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/profiles.js

@@ -3,15 +3,17 @@
  * 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           2,176,782,336 ids
- *   Light    31 symbols, 1 checksum              887,503,681 ids
- *   Medium   28 symbols, 1 checksum              481,890,304 ids (default)
- *   Heavy    26 symbols, 1 checksum              308,915,776 ids
+ *   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 and run the default
- * profanity blocklist. Minimum also uses a hyphen delimiter; the rest have
- * none. The -p variants are identical but with feistel-v1 permutation and
- * require caller-supplied key material.
+ * 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";
@@ -21,6 +23,13 @@ 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.
+ */
+export const FROZEN_KEY_BYTES = new TextEncoder().encode("baseh-frozen-key-v1");
 function keyedPermutation(options) {
     return {
         enabled: true,
@@ -33,6 +42,7 @@ function keyedPermutation(options) {
 function tier(shape, permutation, pSuffix) {
     return {
         profileId: shape.profileId + (pSuffix ? "-p" : "") + "-v1",
+        mode: "fixed",
         bodyAlphabet: shape.bodyAlphabet,
         bodyLength: 6,
         checksumAlphabet: shape.checksumAlphabet,
@@ -42,7 +52,8 @@ function tier(shape, permutation, pSuffix) {
         grouping: shape.grouping,
         aliases: { ...shape.aliases },
         permutation,
-        profanity: { mode: "blocklist" }
+        profanity: { mode: "blocklist" },
+        maxRepetition: 4
     };
 }
 const MINIMUM = {
@@ -58,18 +69,18 @@ const LIGHT = {
     profileId: "baseh-light",
     bodyAlphabet: LIGHT_BODY,
     checksumAlphabet: LIGHT_CHECK,
-    checksumLength: 1,
-    separator: "",
-    grouping: [],
+    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: 1,
-    separator: "",
-    grouping: [],
+    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" }
@@ -78,40 +89,91 @@ const HEAVY = {
     profileId: "baseh-heavy",
     bodyAlphabet: HEAVY_BODY,
     checksumAlphabet: HEAVY_CHECK,
-    checksumLength: 1,
-    separator: "",
-    grouping: [],
+    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: FROZEN_KEY_BYTES, keyId: "frozen" });
+}
 /** Alphanumeric, no safety strips, no checksum, hyphen-delimited XXX-XXX. */
 export function basehMinimumV1() {
-    return tier(MINIMUM, { enabled: false }, false);
+    return tier(MINIMUM, frozenPermutation(), false);
 }
-/** baseh-minimum with feistel-v1 permutation. */
+/** baseh-minimum permuted with caller-supplied key material. */
 export function basehMinimumPV1(options) {
     return tier(MINIMUM, keyedPermutation(options), true);
 }
-/** Visual light plus spoken light, one checksum symbol. */
+/** Visual light plus spoken light, two checksum symbols, hyphen-delimited. */
 export function basehLightV1() {
-    return tier(LIGHT, { enabled: false }, false);
+    return tier(LIGHT, frozenPermutation(), false);
 }
-/** baseh-light with feistel-v1 permutation. */
+/** baseh-light permuted with caller-supplied key material. */
 export function basehLightPV1(options) {
     return tier(LIGHT, keyedPermutation(options), true);
 }
-/** Visual medium plus spoken medium, one checksum symbol. The default. */
+/** Visual medium plus spoken medium, two checksum symbols, hyphen-delimited. The default. */
 export function basehMediumV1() {
-    return tier(MEDIUM, { enabled: false }, false);
+    return tier(MEDIUM, frozenPermutation(), false);
 }
-/** baseh-medium with feistel-v1 permutation. */
+/** baseh-medium permuted with caller-supplied key material. */
 export function basehMediumPV1(options) {
     return tier(MEDIUM, keyedPermutation(options), true);
 }
-/** Conservative alphabet plus spoken heavy, one checksum symbol. */
+/** Conservative alphabet plus spoken heavy, two checksum symbols, hyphen-delimited. */
 export function basehHeavyV1() {
-    return tier(HEAVY, { enabled: false }, false);
+    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. */
+export function basehExpandableV1() {
+    return expandableTier(frozenPermutation(), false);
+}
+/** baseh-expandable permuted with caller-supplied key material. */
+export function basehExpandablePV1(options) {
+    return expandableTier(keyedPermutation(options), true);
 }
-/** baseh-heavy with feistel-v1 permutation. */
+/** baseh-heavy permuted with caller-supplied key material. */
 export function basehHeavyPV1(options) {
     return tier(HEAVY, keyedPermutation(options), true);
 }

package/package.json

@@ -1,33 +1,59 @@
 {
   "name": "@cloudyventures/baseh",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "baseH: reversible, checksummed, human-safe short references for integers.",
   "repository": "github:cloudyventures/baseh",
+  "homepage": "https://github.com/cloudyventures/baseh#readme",
+  "bugs": "https://github.com/cloudyventures/baseh/issues",
+  "keywords": [
+    "baseh",
+    "encoding",
+    "checksum",
+    "human-readable",
+    "identifier",
+    "short-id",
+    "reference-code"
+  ],
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc -p tsconfig.build.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json && node -e \"require('fs').writeFileSync('dist/cjs/package.json', JSON.stringify({ type: 'commonjs' }) + '\\n')\"",
     "test": "tsx --test test/*.test.ts",
-    "vectors": "tsx scripts/generate-vectors.ts"
+    "lint": "eslint src test",
+    "vectors": "tsx scripts/generate-vectors.ts",
+    "bench": "tsx scripts/bench.ts",
+    "prepack": "npm run build"
   },
   "dependencies": {
     "@noble/hashes": "^1.8.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/node": "^24.0.0",
+    "eslint": "^10.8.0",
     "fast-check": "^4.0.0",
     "tsx": "^4.19.0",
-    "typescript": "^5.6.0"
+    "typescript": "^5.6.0",
+    "typescript-eslint": "^8.65.0"
   },
   "license": "AGPL-3.0-only"
 }

package/dist/zero.d.ts

@@ -1,4 +0,0 @@
-/** Encode an identifier with the zero-config Medium profile. */
-export declare function toCode(id: bigint | number | string): string;
-/** Decode a code from the zero-config Medium profile back to its identifier. */
-export declare function fromCode(code: string): bigint;

package/dist/zero.js

@@ -1,39 +0,0 @@
-import { Baseh } from "./codec.js";
-import { basehMediumV1 } from "./profiles.js";
-/**
- * Zero-config pair over the frozen baseh-medium-v1 profile. No profile
- * object, no key: just the two functions an application needs when it
- * does not want to think about configuration.
- *
- *   toCode(id)   -> "7KM4Q2H"
- *   fromCode(code) -> id
- *
- * toCode accepts a bigint, a safe integer number or a decimal string.
- * fromCode strips every whitespace character (edges and internal),
- * accepts lowercase and the typed aliases (O, I, L) and returns the id
- * as a bigint. Any invalid input throws BasehError, including the rare
- * BLOCKED_CODE identifiers that spell a blocklisted word; no correction
- * attempts are ever made.
- */
-const ZERO = new Baseh(basehMediumV1());
-function toBigInt(id) {
-    if (typeof id === "bigint")
-        return id;
-    if (typeof id === "number") {
-        if (!Number.isSafeInteger(id) || id < 0) {
-            throw new TypeError("toCode expects a non-negative safe integer, bigint or decimal string");
-        }
-        return BigInt(id);
-    }
-    if (typeof id === "string" && /^[0-9]+$/.test(id))
-        return BigInt(id);
-    throw new TypeError("toCode expects a non-negative safe integer, bigint or decimal string");
-}
-/** Encode an identifier with the zero-config Medium profile. */
-export function toCode(id) {
-    return ZERO.encode(toBigInt(id));
-}
-/** Decode a code from the zero-config Medium profile back to its identifier. */
-export function fromCode(code) {
-    return ZERO.decode(code.replace(/\s+/g, "")).id;
-}