@tnid/core 0.0.1

package/esm/name_encoding.js

@@ -0,0 +1,92 @@
+// =============================================================================
+// Name Encoding - 5-bit encoding for TNID names
+// Valid characters: 0-4, a-z (31 chars + null terminator = 32 = 2^5)
+// =============================================================================
+const NAME_CHAR_TO_VALUE = {
+    "0": 1,
+    "1": 2,
+    "2": 3,
+    "3": 4,
+    "4": 5,
+    a: 6,
+    b: 7,
+    c: 8,
+    d: 9,
+    e: 10,
+    f: 11,
+    g: 12,
+    h: 13,
+    i: 14,
+    j: 15,
+    k: 16,
+    l: 17,
+    m: 18,
+    n: 19,
+    o: 20,
+    p: 21,
+    q: 22,
+    r: 23,
+    s: 24,
+    t: 25,
+    u: 26,
+    v: 27,
+    w: 28,
+    x: 29,
+    y: 30,
+    z: 31,
+};
+const NAME_VALUE_TO_CHAR = {};
+for (const [char, value] of Object.entries(NAME_CHAR_TO_VALUE)) {
+    NAME_VALUE_TO_CHAR[value] = char;
+}
+const VALID_NAME_CHARS = new Set("01234abcdefghijklmnopqrstuvwxyz".split(""));
+/**
+ * Encode a name into 20 bits (4 chars * 5 bits each).
+ * Null-pads on the right (least significant bits).
+ */
+export function encodeName(name) {
+    let result = 0;
+    for (let i = 0; i < 4; i++) {
+        result <<= 5;
+        if (i < name.length) {
+            const value = NAME_CHAR_TO_VALUE[name[i]];
+            if (value === undefined) {
+                throw new Error(`Invalid name character: ${name[i]}`);
+            }
+            result |= value;
+        }
+        // else: null (0) is already the default
+    }
+    return result;
+}
+/**
+ * Decode 20 bits back to a name string.
+ */
+export function decodeName(encoded) {
+    let result = "";
+    for (let i = 0; i < 4; i++) {
+        const shift = (3 - i) * 5;
+        const value = (encoded >> shift) & 0x1f;
+        if (value === 0)
+            break; // null terminator
+        const char = NAME_VALUE_TO_CHAR[value];
+        if (!char) {
+            throw new Error(`Invalid encoded name value: ${value}`);
+        }
+        result += char;
+    }
+    return result;
+}
+/**
+ * Validate a name at runtime.
+ * Must be 1-4 characters, each being 0-4 or a-z.
+ */
+export function isValidNameRuntime(name) {
+    if (name.length < 1 || name.length > 4)
+        return false;
+    for (const char of name) {
+        if (!VALID_NAME_CHARS.has(char))
+            return false;
+    }
+    return true;
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/types.d.ts

@@ -0,0 +1,93 @@
+/** Valid characters for TNID names (5-bit encoding): 0-4, a-z */
+export type NameChar = "0" | "1" | "2" | "3" | "4" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+/** Recursive validation - check one character at a time to avoid type explosion */
+type ValidateNameChars<S extends string> = S extends "" ? true : S extends `${infer First}${infer Rest}` ? First extends NameChar ? ValidateNameChars<Rest> : false : false;
+/** Check string length is 1-4 using tuple length trick */
+type StringLength<S extends string, Acc extends unknown[] = []> = S extends "" ? Acc["length"] : S extends `${infer _}${infer Rest}` ? StringLength<Rest, [...Acc, unknown]> : never;
+type ValidLength = 1 | 2 | 3 | 4;
+/**
+ * Validate a TNID name at compile time.
+ * Must be 1-4 characters, each being a valid NameChar.
+ */
+export type ValidateName<S extends string> = ValidateNameChars<S> extends true ? StringLength<S> extends ValidLength ? S : never : never;
+/**
+ * A TNID value branded with its name. At runtime this is just a string.
+ *
+ * @example
+ * ```ts
+ * // Define a NamedTnid and matching type
+ * const UserId = Tnid("user");
+ * type UserId = TnidType<typeof UserId>;
+ *
+ * // Generate IDs
+ * const id: UserId = UserId.new_v0();          // time-sortable
+ * const id2: UserId = UserId.new_v1();         // high-entropy random
+ *
+ * // Parse from strings
+ * const parsed = UserId.parse("user.abc...");  // validates name matches
+ * const fromUuid = UserId.parseUuidString("d6157329-4640-8e30-...");
+ *
+ * // DynamicTnid - runtime name validation
+ * DynamicTnid.new_v0("item");                  // create with runtime name
+ * DynamicTnid.new_v1("item");                  // create with runtime name
+ * DynamicTnid.parse("post.xyz...");            // parse any TNID
+ * DynamicTnid.getName(id);                     // "user"
+ * DynamicTnid.getVariant(id);                  // "v0" | "v1" | "v2" | "v3"
+ *
+ * // UuidLike - wrapper for any UUID hex string
+ * UuidLike.fromTnid(id);                       // TNID to UUID string
+ * UuidLike.parse("d6157329-...");              // parse any UUID (format only)
+ * UuidLike.toTnid(uuid);                       // UUID to DynamicTnid (validates)
+ *
+ * // Type safety: different names are incompatible
+ * const PostId = Tnid("post");
+ * type PostId = TnidType<typeof PostId>;
+ * const postId: PostId = PostId.new_v0();
+ * // id = postId;  // Compile error!
+ *
+ * // DynamicTnid type accepts any TNID
+ * function log(id: DynamicTnid) { console.log(DynamicTnid.getName(id)); }
+ * log(id);      // works
+ * log(postId);  // works
+ * ```
+ */
+export type TnidValue<Name extends string> = string & {
+    tnid: Name;
+};
+/** TNID variant: v0=time-ordered, v1=random, v2/v3=reserved */
+export type TnidVariant = "v0" | "v1" | "v2" | "v3";
+/** Case for UUID hex string formatting. */
+export type Case = "lower" | "upper";
+export interface NamedTnid<Name extends string> {
+    /** The TNID name */
+    readonly name: Name;
+    /** Generate a new time-sortable TNID (variant 0) */
+    new_v0(): TnidValue<Name>;
+    /** Generate a new random TNID (variant 1) */
+    new_v1(): TnidValue<Name>;
+    /** Construct a V0 TNID from specific parts (for deterministic testing) */
+    v0_from_parts(timestampMs: bigint, randomBits: bigint): TnidValue<Name>;
+    /** Construct a V1 TNID from specific parts (for deterministic testing) */
+    v1_from_parts(randomBits: bigint): TnidValue<Name>;
+    /**
+     * Parse and validate a TNID string.
+     * @throws Error if the string is invalid or the name doesn't match
+     */
+    parse(s: string): TnidValue<Name>;
+    /**
+     * Parse a UUID hex string into a TNID.
+     * Validates that it's a valid UUIDv8 TNID and the name matches.
+     * @throws Error if the UUID is invalid or the name doesn't match
+     */
+    parseUuidString(uuid: string): TnidValue<Name>;
+    /** Get the name encoded as a 5-character hex string. */
+    nameHex(): string;
+    /** Get the variant of a TNID. */
+    variant(id: TnidValue<Name>): TnidVariant;
+    /** Convert a TNID to UUID hex string format. */
+    toUuidString(id: TnidValue<Name>, caseFormat?: Case): string;
+}
+/** Extract the `TnidValue` type from a NamedTnid. */
+export type TnidType<T> = T extends NamedTnid<infer N> ? TnidValue<N> : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/esm/types.js

@@ -0,0 +1,4 @@
+// =============================================================================
+// TNID Type Definitions
+// =============================================================================
+export {};

package/esm/uuid.d.ts

@@ -0,0 +1,17 @@
+import type { TnidVariant } from "./types.js";
+export declare const UUID_REGEX: RegExp;
+/** Convert a 128-bit value to UUID hex string format */
+export declare function valueToUuidString(value: bigint, upperCase?: boolean): string;
+/** Parse a UUID hex string to a 128-bit value */
+export declare function parseUuidStringToValue(uuid: string): bigint;
+/** Extract name bits from a 128-bit TNID value */
+export declare function extractNameBitsFromValue(value: bigint): number;
+/** Extract TNID variant from a 128-bit value */
+export declare function extractVariantFromValue(value: bigint): TnidVariant;
+/** Validate that a 128-bit value has correct UUIDv8 version and variant bits */
+export declare function validateUuidBits(value: bigint): boolean;
+/** Convert bytes to TNID string */
+export declare function bytesToTnidString(bytes: Uint8Array, name: string): string;
+/** Convert 128-bit value to TNID string */
+export declare function valueToTnidString(value: bigint): string;
+//# sourceMappingURL=uuid.d.ts.map

package/esm/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAK9C,eAAO,MAAM,UAAU,QAC4C,CAAC;AAEpE,wDAAwD;AACxD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,OAAe,GACzB,MAAM,CAMR;AAED,iDAAiD;AACjD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM3D;AAED,kDAAkD;AAClD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,gDAAgD;AAChD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAIlE;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAUvD;AAED,mCAAmC;AACnC,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED,2CAA2C;AAC3C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKvD"}

package/esm/uuid.js

@@ -0,0 +1,55 @@
+// =============================================================================
+// UUID String Utilities
+// =============================================================================
+import { decodeName } from "./name_encoding.js";
+import { encodeData } from "./data_encoding.js";
+import { valueToBytes } from "./bits.js";
+export const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Convert a 128-bit value to UUID hex string format */
+export function valueToUuidString(value, upperCase = false) {
+    const hex = value.toString(16).padStart(32, "0");
+    const uuid = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    return upperCase ? uuid.toUpperCase() : uuid.toLowerCase();
+}
+/** Parse a UUID hex string to a 128-bit value */
+export function parseUuidStringToValue(uuid) {
+    if (!UUID_REGEX.test(uuid)) {
+        throw new Error(`Invalid UUID format: ${uuid}`);
+    }
+    const hex = uuid.replace(/-/g, "");
+    return BigInt("0x" + hex);
+}
+/** Extract name bits from a 128-bit TNID value */
+export function extractNameBitsFromValue(value) {
+    return Number((value >> 108n) & 0xfffffn);
+}
+/** Extract TNID variant from a 128-bit value */
+export function extractVariantFromValue(value) {
+    const variantBits = Number((value >> 60n) & 3n);
+    const variants = ["v0", "v1", "v2", "v3"];
+    return variants[variantBits];
+}
+/** Validate that a 128-bit value has correct UUIDv8 version and variant bits */
+export function validateUuidBits(value) {
+    // Check UUID version (bits 76-79 should be 0x8)
+    const version = Number((value >> 76n) & 0xfn);
+    if (version !== 8)
+        return false;
+    // Check UUID variant (bits 62-63 should be 0b10)
+    const variant = Number((value >> 62n) & 3n);
+    if (variant !== 0b10)
+        return false;
+    return true;
+}
+/** Convert bytes to TNID string */
+export function bytesToTnidString(bytes, name) {
+    const dataEncoded = encodeData(bytes);
+    return `${name}.${dataEncoded}`;
+}
+/** Convert 128-bit value to TNID string */
+export function valueToTnidString(value) {
+    const nameBits = extractNameBitsFromValue(value);
+    const name = decodeName(nameBits);
+    const bytes = valueToBytes(value);
+    return bytesToTnidString(bytes, name);
+}

package/esm/uuidlike.d.ts

@@ -0,0 +1,17 @@
+import type { DynamicTnid } from "./dynamic.js";
+/** A UUID hex string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx) that may or may not be a valid TNID. */
+export type UuidLike = string & {
+    __uuidlike: true;
+};
+/** Wrapper for UUID hex strings that may or may not be valid TNIDs. */
+export declare const UuidLike: {
+    /** Create from a TNID (always valid). */
+    readonly fromTnid: (id: DynamicTnid) => UuidLike;
+    /** Parse UUID hex string (format validation only, not TNID validation). */
+    readonly parse: (s: string) => UuidLike;
+    /** Try to convert to DynamicTnid (validates TNID structure). */
+    readonly toTnid: (uuid: UuidLike) => DynamicTnid;
+    /** Format as uppercase UUID hex string. */
+    readonly toUpperCase: (uuid: UuidLike) => UuidLike;
+};
+//# sourceMappingURL=uuidlike.d.ts.map

package/esm/uuidlike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuidlike.d.ts","sourceRoot":"","sources":["../src/uuidlike.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,oGAAoG;AACpG,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,CAAC;AAWrD,uEAAuE;AACvE,eAAO,MAAM,QAAQ;IACnB,yCAAyC;4BAC5B,WAAW,KAAG,QAAQ;IAInC,2EAA2E;wBAClE,MAAM,KAAG,QAAQ;IAQ1B,gEAAgE;4BACnD,QAAQ,KAAG,WAAW;IAanC,2CAA2C;iCACzB,QAAQ,KAAG,QAAQ;CAG7B,CAAC"}

package/esm/uuidlike.js

@@ -0,0 +1,38 @@
+// =============================================================================
+// UuidLike - Wrapper for UUID hex strings
+// =============================================================================
+import { decodeName, isValidNameRuntime } from "./name_encoding.js";
+import { UUID_REGEX, parseUuidStringToValue, validateUuidBits, extractNameBitsFromValue, valueToTnidString, } from "./uuid.js";
+import { toUuidStringImpl } from "./dynamic.js";
+/** Wrapper for UUID hex strings that may or may not be valid TNIDs. */
+export const UuidLike = {
+    /** Create from a TNID (always valid). */
+    fromTnid(id) {
+        return toUuidStringImpl(id, false);
+    },
+    /** Parse UUID hex string (format validation only, not TNID validation). */
+    parse(s) {
+        // Validate format only
+        if (!UUID_REGEX.test(s)) {
+            throw new Error(`Invalid UUID format: ${s}`);
+        }
+        return s.toLowerCase();
+    },
+    /** Try to convert to DynamicTnid (validates TNID structure). */
+    toTnid(uuid) {
+        const value = parseUuidStringToValue(uuid);
+        if (!validateUuidBits(value)) {
+            throw new Error("Invalid TNID: not a valid UUIDv8");
+        }
+        const nameBits = extractNameBitsFromValue(value);
+        const name = decodeName(nameBits);
+        if (!isValidNameRuntime(name)) {
+            throw new Error("Invalid TNID: invalid name encoding");
+        }
+        return valueToTnidString(value);
+    },
+    /** Format as uppercase UUID hex string. */
+    toUpperCase(uuid) {
+        return uuid.toUpperCase();
+    },
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@tnid/core",
+  "version": "0.0.1",
+  "description": "Type-safe, named, unique identifiers (TNIDs) - UUID-compatible IDs with embedded type names",
+  "keywords": [
+    "uuid",
+    "id",
+    "identifier",
+    "tnid",
+    "typed",
+    "type-safe"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tnid/tnid-typescript.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tnid/tnid-typescript/issues"
+  },
+  "main": "./script/index.js",
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./script/index.js"
+    }
+  },
+  "scripts": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deno/shim-crypto": "~0.3.1"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+export declare const dntGlobalThis: Omit<typeof globalThis, "crypto"> & {
+    crypto: import("@deno/shim-crypto").Crypto;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKrvB,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.crypto = void 0;
+const shim_crypto_1 = require("@deno/shim-crypto");
+var shim_crypto_2 = require("@deno/shim-crypto");
+Object.defineProperty(exports, "crypto", { enumerable: true, get: function () { return shim_crypto_2.crypto; } });
+const dntGlobals = {
+    crypto: shim_crypto_1.crypto,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/bits.d.ts

@@ -0,0 +1,18 @@
+export declare const UUID_V8_MASK = 604472133179351442128896n;
+export declare const V1_RANDOM_MASK = 324518552525041477071872066584575n;
+export declare const V0_RANDOM_MASK = 144115188075855871n;
+/** Place name bits in their correct position (bits 108-127) */
+export declare function nameMask(nameBits: number): bigint;
+/** Place UUID version/variant and TNID variant in their correct positions */
+export declare function uuidAndVariantMask(tnidVariant: bigint): bigint;
+/** Scatter 43-bit timestamp into its three positions within the 128-bit ID */
+export declare function millisMask(millisSinceEpoch: bigint): bigint;
+/** Build a 128-bit TNID value using mask-based OR operations */
+export declare function buildTnidValue(nameBits: number, payloadMask: bigint, tnidVariant: bigint): bigint;
+/** Convert 128-bit value to byte array */
+export declare function valueToBytes(value: bigint): Uint8Array;
+/** Generate a V0 (time-ordered) TNID as bytes */
+export declare function generateV0(nameBits: number, timestampMs?: bigint, randomBits?: bigint): Uint8Array;
+/** Generate a V1 (high-entropy random) TNID as bytes */
+export declare function generateV1(nameBits: number, randomBits?: bigint): Uint8Array;
+//# sourceMappingURL=bits.d.ts.map

package/script/bits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bits.d.ts","sourceRoot":"","sources":["../src/bits.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,YAAY,4BAA0C,CAAC;AAGpE,eAAO,MAAM,cAAc,qCAA0C,CAAC;AAGtE,eAAO,MAAM,cAAc,sBAA0C,CAAC;AAOtE,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAmB3D;AAED,gEAAgE;AAChE,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER;AAED,0CAA0C;AAC1C,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAQtD;AAED,iDAAiD;AACjD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,MAAM,GAClB,UAAU,CAmBZ;AAED,wDAAwD;AACxD,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,UAAU,CAe5E"}

package/script/bits.js

@@ -0,0 +1,134 @@
+"use strict";
+// =============================================================================
+// Bit Manipulation and TNID Generation
+// Mask-based approach matching Rust implementation
+// =============================================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V0_RANDOM_MASK = exports.V1_RANDOM_MASK = exports.UUID_V8_MASK = void 0;
+exports.nameMask = nameMask;
+exports.uuidAndVariantMask = uuidAndVariantMask;
+exports.millisMask = millisMask;
+exports.buildTnidValue = buildTnidValue;
+exports.valueToBytes = valueToBytes;
+exports.generateV0 = generateV0;
+exports.generateV1 = generateV1;
+// Masks for UUID version 8 and variant bits
+const dntShim = __importStar(require("./_dnt.shims.js"));
+exports.UUID_V8_MASK = 0x00000000000080008000000000000000n;
+// V1: 100 random bits scattered across the UUID
+exports.V1_RANDOM_MASK = 0x00000fffffff0fff0fffffffffffffffn;
+// V0: 57 random bits in the lower portion
+exports.V0_RANDOM_MASK = 0x000000000000000001ffffffffffffffn;
+// V0 timestamp masks (for extracting and placing 43-bit timestamp)
+const TIMESTAMP_FIRST_28_MASK = 0x000007ffffff8000n;
+const TIMESTAMP_SECOND_12_MASK = 0x0000000000007ff8n;
+const TIMESTAMP_LAST_3_MASK = 0x0000000000000007n;
+/** Place name bits in their correct position (bits 108-127) */
+function nameMask(nameBits) {
+    return BigInt(nameBits) << 108n;
+}
+/** Place UUID version/variant and TNID variant in their correct positions */
+function uuidAndVariantMask(tnidVariant) {
+    return exports.UUID_V8_MASK | ((tnidVariant & 3n) << 60n);
+}
+/** Scatter 43-bit timestamp into its three positions within the 128-bit ID */
+function millisMask(millisSinceEpoch) {
+    let mask = 0n;
+    // First 28 bits of timestamp → bits 80-107 of UUID
+    const first28LeadingZeros = 64n - 43n; // = 21, so mask starts at bit 42
+    mask |= (millisSinceEpoch & TIMESTAMP_FIRST_28_MASK) <<
+        (first28LeadingZeros + 64n - 20n);
+    // Middle 12 bits of timestamp → bits 64-75 of UUID (after version nibble)
+    const second12LeadingZeros = 64n - 15n; // = 49
+    mask |= (millisSinceEpoch & TIMESTAMP_SECOND_12_MASK) <<
+        (second12LeadingZeros + 64n - 52n);
+    // Last 3 bits of timestamp → bits 57-59 of UUID (after variant bits)
+    const last3LeadingZeros = 64n - 3n; // = 61
+    mask |= (millisSinceEpoch & TIMESTAMP_LAST_3_MASK) <<
+        (last3LeadingZeros + 64n - 68n);
+    return mask;
+}
+/** Build a 128-bit TNID value using mask-based OR operations */
+function buildTnidValue(nameBits, payloadMask, tnidVariant) {
+    return nameMask(nameBits) | uuidAndVariantMask(tnidVariant) | payloadMask;
+}
+/** Convert 128-bit value to byte array */
+function valueToBytes(value) {
+    const bytes = new Uint8Array(16);
+    let v = value;
+    for (let i = 15; i >= 0; i--) {
+        bytes[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return bytes;
+}
+/** Generate a V0 (time-ordered) TNID as bytes */
+function generateV0(nameBits, timestampMs, randomBits) {
+    const timestamp = timestampMs !== undefined
+        ? timestampMs & ((1n << 43n) - 1n)
+        : BigInt(Date.now()) & ((1n << 43n) - 1n);
+    let random;
+    if (randomBits !== undefined) {
+        random = randomBits;
+    }
+    else {
+        const randomBytes = dntShim.crypto.getRandomValues(new Uint8Array(8));
+        random = 0n;
+        for (const byte of randomBytes) {
+            random = (random << 8n) | BigInt(byte);
+        }
+    }
+    const payloadMask = millisMask(timestamp) | (random & exports.V0_RANDOM_MASK);
+    const value = buildTnidValue(nameBits, payloadMask, 0n);
+    return valueToBytes(value);
+}
+/** Generate a V1 (high-entropy random) TNID as bytes */
+function generateV1(nameBits, randomBits) {
+    let random;
+    if (randomBits !== undefined) {
+        random = randomBits;
+    }
+    else {
+        const randomBytes = dntShim.crypto.getRandomValues(new Uint8Array(16));
+        random = 0n;
+        for (const byte of randomBytes) {
+            random = (random << 8n) | BigInt(byte);
+        }
+    }
+    const payloadMask = random & exports.V1_RANDOM_MASK;
+    const value = buildTnidValue(nameBits, payloadMask, 1n);
+    return valueToBytes(value);
+}

package/script/data_encoding.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Encode a 16-byte TNID value as a 17-character data string.
+ */
+export declare function encodeData(bytes: Uint8Array): string;
+/**
+ * Decode a 17-character data string to data bits and TNID variant.
+ */
+export declare function decodeData(encoded: string): {
+    dataBits: bigint;
+    tnidVariant: number;
+};
+/**
+ * Convert data bits back to a 16-byte array.
+ */
+export declare function dataBitsToBytes(dataBits: bigint, nameBits: number): Uint8Array;
+//# sourceMappingURL=data_encoding.d.ts.map

package/script/data_encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_encoding.d.ts","sourceRoot":"","sources":["../src/data_encoding.ts"],"names":[],"mappings":"AA6BA;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAgCpD;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,GACd;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAmB3C;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CA8B9E"}