tuple-ts 0.2.3 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # TupleTS
 
-TupleTS is an implementation of interned tuples and records intended to be memory-safe, performant, and tiny.
+TupleTS is an implementation of tuples and records intended to be memory-safe, performant, and tiny.
 
 - **Referential Equality (`===`)**: Identical tuples and records return the same instance in memory.
 - **Composite Keys for `Set` & `Map`**: Use tuples or records as keys without custom serialization or hashing workarounds.
@@ -77,15 +77,15 @@ console.log(grid.get(tuple(0, 0))); // "Origin"
 console.log(grid.get(tuple(3, 4))); // "Target"
 ```
 
-### 4. Custom Typed Tuples (`tupleType`)
+### 4. Custom Typed Tuples (`defineTupleType`)
 
-You can create isolated, strictly-typed tuple factories with their own independent intern caches:
+You can create strictly-typed tuple factories:
 
 ```ts
-import { tupleType } from "tuple-ts";
+import { defineTupleType } from "tuple-ts";
 
 type Point2D = [x: number, y: number];
-const Point = tupleType<Point2D>();
+const Point = defineTupleType<Point2D>();
 
 const p1 = Point(12, 34);
 const p2 = Point(12, 34);
@@ -107,12 +107,12 @@ console.log(userA === userB); // true
 console.log(userA.role);      // "admin"
 ```
 
-### 6. Keyed Records (`recordType().withKeys(...)`)
+### 6. Custom Typed Records (`defineRecordType`)
 
-Define records interned and deduplicated on a specific subset of primary keys:
+As with tuples, you can also create strictly-typed record factories:
 
 ```ts
-import { recordType } from "tuple-ts";
+import { defineRecordType } from "tuple-ts";
 
 interface UserProfile {
   id: string;
@@ -120,14 +120,13 @@ interface UserProfile {
   updatedAt: number;
 }
 
-// Only 'id' determines record identity
-const UserById = recordType<UserProfile>().withKeys("id");
+const User = defineRecordType<UserProfile>();
 
-const session1 = UserById({ id: "usr_1", name: "Alice", updatedAt: 1000 });
-const session2 = UserById({ id: "usr_1", name: "Alice B.", updatedAt: 2000 });
+const user1 = User({ id: "alice", name: "Alice", updatedAt: 1000 });
+const user2 = User({ name: "Alice", id: "alice", updatedAt: 1000 });
 
-console.log(session1 === session2); // true
-console.log(session1);              // { id: "usr_1" }
+console.log(user1 === user2); // true
+console.log(user1["name"]); // "Alice"
 ```
 
 ### 7. Memory Safety & Garbage Collection
@@ -135,7 +134,7 @@ console.log(session1);              // { id: "usr_1" }
 TupleTS uses `WeakRef` and `FinalizationRegistry` under the hood. When a tuple or record is no longer referenced anywhere in your program, the JavaScript runtime garbage-collects it, and its entry in the intern cache is automatically pruned.
 
 ```ts
-// No need to manually clear caches or worry about memory leaks!
+// No need to manually clear caches or worry about memory leaks.
 {
   const temp = tuple("transient", 123);
   // once 'temp' leaves scope and GC runs, the intern cache entry is freed.

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AA6GA,wBAAgB,SAAS,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAE9D;AASD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAKlE"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAoHA,wBAAgB,SAAS,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAE9D;AASD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAKlE"}

package/dist/hash.js

@@ -1,4 +1,6 @@
-const UINT32_BASE = 2n ** 32n;
+const BIGINT_UINT32_MASK = 0xffffffffn;
+const float64Buffer = new Float64Array(1);
+const uint32View = new Uint32Array(float64Buffer.buffer);
 function murmurHash3Mix_32bit(keys, seed = 0) {
     // The first (i.e., mixing) stage of the MurmurHash3 algorithm for 32-bit keys
     let hash = seed;
@@ -10,12 +12,12 @@ function murmurHash3Mix_32bit(keys, seed = 0) {
         k = Math.imul(k, 0x1b873593);
         hash ^= k;
         hash = (hash << 13) | (hash >>> 19); // ROTL32(h1, 13);
-        hash = Math.imul(hash, 5) + 0xe6546b64;
+        hash = (Math.imul(hash, 5) + 0xe6546b64) | 0; // Bitwise OR to force 32-bit
     }
     hash ^= keyCount * 4; // number of input bytes
     return hash >>> 0; // unsigned
 }
-function linearConguentialGenerator(seed = Date.now() >>> 0) {
+function linearCongruentialGenerator(seed = Date.now()) {
     let state = seed >>> 0; // Force to unsigned 32-bit
     return () => {
         // LCG constants from Numerical Recipes (good default)
@@ -23,7 +25,7 @@ function linearConguentialGenerator(seed = Date.now() >>> 0) {
         return state;
     };
 }
-const randomUint32 = linearConguentialGenerator();
+const randomUint32 = linearCongruentialGenerator();
 const tupleSeed = randomUint32();
 const recordSeed = randomUint32();
 const nullHash = randomUint32();
@@ -35,6 +37,7 @@ const bigIntSeed = randomUint32();
 const stringSeed = randomUint32();
 const registeredSymbolSeed = randomUint32();
 const objectHashMap = new WeakMap();
+const symbolHashMap = new WeakMap();
 function stableRandomHash(map, value) {
     if (value === null)
         return nullHash;
@@ -45,24 +48,29 @@ function stableRandomHash(map, value) {
     map.set(value, newHash);
     return newHash;
 }
-function* stringToUint32s(value) {
-    for (let i = 0; i < value.length; i += 2) {
-        const char1 = value.charCodeAt(i);
-        const char2 = value.charCodeAt(i + 1);
-        yield (char2 << 16) | char1;
+function stringToUint32s(value) {
+    const result = Array(Math.ceil(value.length / 2) + 1);
+    result[0] = value.length;
+    for (let i = 0; i < value.length / 2; i += 1) {
+        const char1 = value.charCodeAt(2 * i);
+        const char2 = value.charCodeAt(2 * i + 1);
+        result[i + 1] = (char2 << 16) | char1;
     }
+    return result;
 }
-function* numberToUint32s(value) {
-    const buffer = new ArrayBuffer(8); // 8 bytes = 64 bits
-    const view = new DataView(buffer);
-    view.setFloat64(0, value);
-    yield view.getUint32(0);
-    yield view.getUint32(4);
+function numberToUint32s(value) {
+    float64Buffer[0] = Number.isNaN(value) ? NaN : value;
+    return [uint32View[0], uint32View[1]];
 }
-function* bigIntToUint32s(value) {
-    for (let n = value; n !== 0n; n /= UINT32_BASE) {
-        yield Number(((n % UINT32_BASE) + UINT32_BASE) % UINT32_BASE); // Safely non-negative
+function bigintToUint32s(value) {
+    const isNegative = value < 0n;
+    let n = isNegative ? -value : value;
+    const result = [isNegative ? 1 : 0];
+    while (n !== 0n) {
+        result.push(Number(n & BIGINT_UINT32_MASK));
+        n >>= 32n;
     }
+    return result;
 }
 function valueHash(value) {
     switch (typeof value) {
@@ -71,13 +79,13 @@ function valueHash(value) {
         case "number":
             return mixHashes(numberToUint32s(value), numberSeed);
         case "bigint":
-            return mixHashes(bigIntToUint32s(value), bigIntSeed);
+            return mixHashes(bigintToUint32s(value), bigIntSeed);
         case "boolean":
             return value ? trueHash : falseHash;
         case "symbol":
             const k = Symbol.keyFor(value);
             return k === undefined
-                ? stableRandomHash(objectHashMap, value)
+                ? stableRandomHash(symbolHashMap, value)
                 : mixHashes(stringToUint32s(k), registeredSymbolSeed);
         case "undefined":
             return undefinedHash;
@@ -88,19 +96,17 @@ function valueHash(value) {
     }
 }
 const mixHashes = murmurHash3Mix_32bit;
-function* valueHashes(values) {
-    for (const v of values) {
-        yield valueHash(v);
-    }
+function valueHashes(values) {
+    return Array.from(values, valueHash);
 }
 export function tupleHash(elements) {
     return mixHashes(valueHashes(elements), tupleSeed);
 }
-function* keyAndValueHashes(record) {
-    for (const key of Object.keys(record).sort()) {
-        yield valueHash(key);
-        yield valueHash(record[key]);
-    }
+function keyAndValueHashes(record) {
+    return Object.keys(record).sort().flatMap(key => [
+        valueHash(key),
+        valueHash(record[key])
+    ]);
 }
 export function recordHash(record) {
     return mixHashes(keyAndValueHashes(record), recordSeed);

package/dist/index.d.ts

@@ -1,19 +1,11 @@
 import InternCache from "./intern-cache";
 export { InternCache };
-export type Tuple<T extends readonly unknown[] = readonly unknown[]> = T;
-export type TupleType<T extends Tuple = Tuple> = {
-    (...t: T): T;
-    _cache: InternCache<number, T>;
-};
-export type KeyedRecordType<R extends Record<string, unknown> = Record<string, unknown>> = {
-    (r: R): R;
-    _cache: InternCache<number, R>;
-};
-export type RecordType<R extends Record<string, unknown> = Record<string, unknown>> = KeyedRecordType<R> & {
-    withKeys: <K extends readonly (keyof R)[]>(...keys: K) => KeyedRecordType<Pick<R, K[number]>>;
-};
-export declare function tupleType<T extends Tuple>(): TupleType<T>;
-export declare function recordType<T extends Record<string, unknown>>(): RecordType<T>;
-export declare const tuple: TupleType<readonly unknown[]>;
-export declare const record: RecordType<Record<string, unknown>>;
+export type TupleType<T extends readonly unknown[]> = (...t: T) => Readonly<T>;
+export type RecordType<T extends Record<string, unknown>> = (r: T) => Readonly<T>;
+export declare const _tupleCache: InternCache<number, readonly unknown[]>;
+export declare const _recordCache: InternCache<number, Record<string, unknown>>;
+export declare const tuple: <const T_ extends readonly unknown[]>(...t: T_) => Readonly<T_>;
+export declare const record: <const T_ extends Record<string, unknown>>({ ...r }: T_) => T_;
+export declare const defineTupleType: <T extends readonly unknown[]>() => TupleType<T>;
+export declare const defineRecordType: <T extends Record<string, unknown>>() => RecordType<T>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,CAAC;AAGvB,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC;AAEzE,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI;IAC/C,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IACb,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,eAAe,CACzB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzD;IAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,UAAU,CACpB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzD,eAAe,CAAC,CAAC,CAAC,GAAG;IACvB,QAAQ,EAAE,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,EACvC,GAAG,IAAI,EAAE,CAAC,KACP,eAAe,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC1C,CAAC;AA4BF,wBAAgB,SAAS,CAAC,CAAC,SAAS,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,CAKzD;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAO7E;AAED,eAAO,MAAM,KAAK,+BAAc,CAAC;AACjC,eAAO,MAAM,MAAM,qCAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,CAAC;AAGvB,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AAC/E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAC1D,CAAC,EAAE,CAAC,KACD,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEjB,eAAO,MAAM,WAAW,yCAGvB,CAAC;AACF,eAAO,MAAM,YAAY,8CAGxB,CAAC;AA4BF,eAAO,MAAM,KAAK,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,GAAG,GAAG,EAAE,iBAChC,CAAC;AAEpC,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,UAE9D,EAAE,KAAG,EAAwC,CAAC;AAEjD,eAAO,MAAM,eAAe,GACzB,CAAC,SAAS,SAAS,OAAO,EAAE,OAAK,SAAS,CAAC,CAAC,CAEjB,CAAC;AAE/B,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAAK,UAAU,CAAC,CAAC,CAExC,CAAC"}

package/dist/index.js

@@ -1,6 +1,8 @@
 import InternCache from "./intern-cache";
 export { InternCache };
 import * as hash from "./hash";
+export const _tupleCache = new InternCache(hash.tupleHash, arrayEquivalent);
+export const _recordCache = new InternCache(hash.recordHash, recordEquivalent);
 function arrayEquivalent(a1, a2) {
     if (a2.length !== a1.length)
         return false;
@@ -24,31 +26,7 @@ function recordEquivalent(r1, r2) {
     }
     return true;
 }
-export function tupleType() {
-    const _cache = new InternCache(hash.tupleHash, arrayEquivalent);
-    return Object.assign((...t) => Object.freeze(_cache.get(t)), {
-        _cache,
-    });
-}
-export function recordType() {
-    const _cache = new InternCache(hash.recordHash, recordEquivalent);
-    return Object.assign(({ ...r }) => Object.freeze(_cache.get(r)), {
-        _cache,
-        withKeys: (...keys) => recordTypeToKeyedRecordType(...keys),
-    });
-}
-export const tuple = tupleType();
-export const record = recordType();
-function recordToTuple(record, keys) {
-    return keys.map((k) => record[k]);
-}
-function recordTypeToKeyedRecordType(...keys) {
-    const _cache = new InternCache((r) => hash.tupleHash(recordToTuple(r, keys)), (r1, r2) => arrayEquivalent(recordToTuple(r1, keys), recordToTuple(r2, keys)));
-    return Object.assign((r) => {
-        const r_ = {};
-        for (const k of keys) {
-            r_[k] = r[k];
-        }
-        return Object.freeze(_cache.get(r_));
-    }, { _cache });
-}
+export const tuple = (...t) => Object.freeze(_tupleCache.get(t));
+export const record = ({ ...r }) => Object.freeze(_recordCache.get(r));
+export const defineTupleType = () => (...t) => tuple(...t);
+export const defineRecordType = () => (r) => record(r);

package/dist/intern-cache.d.ts

@@ -7,5 +7,6 @@ export default class<H, T extends object> {
     private remove;
     get<U extends T>(obj: U): U;
     get size(): number;
+    reset(): void;
 }
 //# sourceMappingURL=intern-cache.d.ts.map

package/dist/intern-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intern-cache.d.ts","sourceRoot":"","sources":["../src/intern-cache.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAQ,CAAC,EAAE,CAAC,SAAS,MAAM;IACvC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsC;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAC3D,OAAO,CAAC,eAAe,CAAoD;gBAE/D,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO;IAK5E,OAAO,CAAC,MAAM;IAQd,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAqB3B,IAAI,IAAI,IAAI,MAAM,CAIjB;CACF"}
+{"version":3,"file":"intern-cache.d.ts","sourceRoot":"","sources":["../src/intern-cache.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM;IACtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsC;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAC3D,OAAO,CAAC,eAAe,CAErB;gBAGA,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EACrB,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO;IAM3C,OAAO,CAAC,MAAM;IAWd,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAqB3B,IAAI,IAAI,IAAI,MAAM,CAKjB;IAED,KAAK,IAAI,IAAI;CAId"}

package/dist/intern-cache.js

@@ -1,18 +1,19 @@
 export default class {
     constructor(hashFn, identityFn) {
         this.map = new Map();
-        this.cleanupRegistry = new FinalizationRegistry(this.remove.bind(this));
+        this.cleanupRegistry = new FinalizationRegistry((x) => this.remove(x));
         this.hashFn = hashFn;
         this.identityFn = identityFn;
     }
     remove([hash, ref]) {
         const hashBucket = this.map.get(hash);
-        if (hashBucket === undefined)
-            throw new Error("Could not get tuple set");
-        if (!hashBucket.delete(ref))
-            throw new Error("Could not delete tuple WeakRef");
-        if (hashBucket.size === 0)
+        if (!hashBucket) {
+            return;
+        }
+        hashBucket.delete(ref);
+        if (hashBucket.size === 0) {
             this.map.delete(hash);
+        }
     }
     get(obj) {
         const hash = this.hashFn(obj);
@@ -36,8 +37,10 @@ export default class {
         return obj;
     }
     get size() {
-        return [...this.map.entries()]
-            .map(([_, b]) => b.size)
-            .reduce((a, b) => a + b, 0);
+        return Array.from(this.map.entries(), ([_, b]) => b.size).reduce((acc, x) => acc + x, 0);
+    }
+    reset() {
+        this.map.clear();
+        this.cleanupRegistry = new FinalizationRegistry((x) => this.remove(x));
     }
 }

package/dist/record.spec.js

@@ -1,4 +1,4 @@
-import { record, recordType } from ".";
+import { record } from ".";
 describe("record", () => {
     it("preserves keys and values", () => {
         const a = record({ x: 1, y: 2 });
@@ -16,24 +16,3 @@ describe("record", () => {
         expect(record({ x: 1, y: 2, z: 3 })).not.toBe(r);
     });
 });
-describe("Keyed record type", () => {
-    const Person = recordType().withKeys("name", "age");
-    it("interns on only specified keys and values", () => {
-        const a = { name: "Bob", age: 42, sex: "male" };
-        const b = { name: "Bob", age: 42, occupation: "teacher" };
-        expect(Person(a)).toBe(Person(b));
-        expect(Person(a)).toEqual({ name: "Bob", age: 42 });
-    });
-    it("returns different object if keys or values differ", () => {
-        const r = Person({ name: "Tom", age: 42 });
-        expect({ x: 1, y: 3 }).not.toBe(r);
-        expect({ x: 1, y: 3 }).not.toBe(r);
-        expect({ x: 1, y: 2, z: 3 }).not.toBe(r);
-    });
-    it("respects inherited attributes", () => {
-        const proto = { name: "Bob" };
-        const a = Object.create(proto);
-        a.age = 42;
-        expect(Person(a)).toBe(Person({ name: "Bob", age: 42 }));
-    });
-});

package/dist/tuple.spec.js

@@ -1,4 +1,9 @@
-import { tuple, tupleType } from ".";
+import { tuple, defineTupleType, _tupleCache } from ".";
+async function waitForGC() {
+    await new Promise((res) => setTimeout(res, 0));
+    global.gc(); // requires node --expose-gc
+    await new Promise((res) => setTimeout(res, 0));
+}
 test("Empty tuples", () => {
     const a = tuple();
     const b = tuple();
@@ -46,16 +51,34 @@ test("Nestable", () => {
 test("NaN is equivalent to itself", () => {
     expect(tuple(NaN)).toBe(tuple(NaN));
 });
+test("NaN values with different bit representations are interned as identical", () => {
+    // Construct NaN with payload 1
+    const view1 = new DataView(new ArrayBuffer(8));
+    view1.setUint32(0, 0x7ff80000);
+    view1.setUint32(4, 0x00000001);
+    const nan1 = view1.getFloat64(0);
+    // Construct NaN with payload 2
+    const view2 = new DataView(new ArrayBuffer(8));
+    view2.setUint32(0, 0x7ff80000);
+    view2.setUint32(4, 0x00000002);
+    const nan2 = view2.getFloat64(0);
+    // Verify they are both recognized as NaNs and Object.is equivalent:
+    expect(Number.isNaN(nan1)).toBe(true);
+    expect(Number.isNaN(nan2)).toBe(true);
+    expect(Object.is(nan1, nan2)).toBe(true);
+    // If NaNs were not canonicalized in numberToUint32s, this would fail (.not.toBe)
+    // because nan1 and nan2 would hash to different buckets:
+    expect(tuple(nan1)).toBe(tuple(nan2));
+});
 test("Positive and negative zero are distinct", () => {
     expect(tuple(+0)).not.toBe(tuple(-0));
 });
 test("Tuple cache entry is cleared when tuple is garbage-collected", async () => {
-    const Point = tupleType();
+    _tupleCache.reset();
+    expect(_tupleCache.size).toBe(0);
+    const Point = defineTupleType();
     Point(15, 42);
-    expect(Point._cache.size).toBe(1);
-    // Trigger garbage collection (requires node --expose-gc)
-    await new Promise((res) => setTimeout(res, 100));
-    global.gc();
-    await new Promise((res) => setTimeout(res, 100));
-    expect(Point._cache.size).toBe(0);
+    expect(_tupleCache.size).toBe(1);
+    await waitForGC();
+    expect(_tupleCache.size).toBe(0);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "tuple-ts",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Python-like tuples for JavaScript/TypeScript",
   "keywords": [
     "tuple",