@specific.dev/spectest 0.26.0 → 0.28.0

package/dist/ids.d.ts

@@ -0,0 +1,2 @@
+/** Mint a fresh id, e.g. `generateId("art")` → `art_0c3k9mpq…`. */
+export declare function generateId(prefix: string): string;

package/{src/ids.ts → dist/ids.js}

@@ -21,69 +21,65 @@
 // This makes duplicates practically impossible, but the control plane
 // still treats an id here as untrusted: shape-validated, and a duplicate
 // insert is flagged per-artifact rather than clobbering anything.
-
 import { createHash } from "node:crypto";
 import { closeSync, openSync, readSync } from "node:fs";
-
 /** Crockford base32, lowercased, minus `i`/`l`/`o`/`u` — mirrors ids.rs. */
 const ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
-
 /** Random base32 chars after the version digit (100 bits of entropy). */
 const RANDOM_LEN = 20;
-
 let mintCounter = 0;
-
 /** Mint a fresh id, e.g. `generateId("art")` → `art_0c3k9mpq…`. */
-export function generateId(prefix: string): string {
-  const digest = createHash("sha256")
-    .update(urandom(16))
-    .update(String(Date.now()))
-    .update(String(performance.now()))
-    .update(String(mintCounter++))
-    .digest();
-  return `${prefix}_0${base32Crockford(digest.subarray(0, 16)).slice(0, RANDOM_LEN)}`;
+export function generateId(prefix) {
+    const digest = createHash("sha256")
+        .update(urandom(16))
+        .update(String(Date.now()))
+        .update(String(performance.now()))
+        .update(String(mintCounter++))
+        .digest();
+    return `${prefix}_0${base32Crockford(digest.subarray(0, 16)).slice(0, RANDOM_LEN)}`;
 }
-
 /** Read `n` bytes directly from /dev/urandom (NOT Bun's cached pool). */
-function urandom(n: number): Uint8Array {
-  const buf = new Uint8Array(n);
-  try {
-    const fd = openSync("/dev/urandom", "r");
+function urandom(n) {
+    const buf = new Uint8Array(n);
     try {
-      let off = 0;
-      while (off < n) {
-        const read = readSync(fd, buf, off, n - off, null);
-        if (read <= 0) break;
-        off += read;
-      }
-    } finally {
-      closeSync(fd);
+        const fd = openSync("/dev/urandom", "r");
+        try {
+            let off = 0;
+            while (off < n) {
+                const read = readSync(fd, buf, off, n - off, null);
+                if (read <= 0)
+                    break;
+                off += read;
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
     }
-  } catch {
-    // Non-Linux host (SDK types compiled locally) or exotic failure — the
-    // clock + counter inputs still make the hash unique in practice.
-    crypto.getRandomValues(buf);
-  }
-  return buf;
+    catch {
+        // Non-Linux host (SDK types compiled locally) or exotic failure — the
+        // clock + counter inputs still make the hash unique in practice.
+        crypto.getRandomValues(buf);
+    }
+    return buf;
 }
-
 /** Encode bytes as Crockford base32 (no padding). 16 bytes → 26 chars. */
-function base32Crockford(bytes: Uint8Array): string {
-  let out = "";
-  let acc = 0;
-  let bits = 0;
-  for (const b of bytes) {
-    acc = (acc << 8) | b;
-    bits += 8;
-    while (bits >= 5) {
-      bits -= 5;
-      out += ALPHABET[(acc >> bits) & 0x1f];
+function base32Crockford(bytes) {
+    let out = "";
+    let acc = 0;
+    let bits = 0;
+    for (const b of bytes) {
+        acc = (acc << 8) | b;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            out += ALPHABET[(acc >> bits) & 0x1f];
+        }
+        // Keep the accumulator within 32-bit safe range for the `<<` operator.
+        acc &= (1 << bits) - 1;
+    }
+    if (bits > 0) {
+        out += ALPHABET[(acc << (5 - bits)) & 0x1f];
     }
-    // Keep the accumulator within 32-bit safe range for the `<<` operator.
-    acc &= (1 << bits) - 1;
-  }
-  if (bits > 0) {
-    out += ALPHABET[(acc << (5 - bits)) & 0x1f];
-  }
-  return out;
+    return out;
 }