genome 1.0.0 → 1.0.3

package/genome_rs_bg.js

@@ -0,0 +1,288 @@
+/**
+ * Compares two structure ID strings and returns a similarity score
+ * between 0.0 (completely different) and 1.0 (identical).
+ *
+ * ```js
+ * import { compare } from 'genome'
+ * const score = compare("L0:100-L1:200", "L0:100-L1:200") // 1.0
+ * ```
+ * @param {string} id_a
+ * @param {string} id_b
+ * @returns {number}
+ */
+export function compare(id_a, id_b) {
+    const ptr0 = passStringToWasm0(id_a, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(id_b, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compare(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+/**
+ * Compares two JSON strings structurally and returns a similarity score.
+ *
+ * ```js
+ * import { compareValues } from 'genome'
+ * const score = compareValues(
+ *   JSON.stringify({ id: 1, name: "alice" }),
+ *   JSON.stringify({ id: 2, name: "bob" }),
+ * ) // 1.0 — same structure
+ * ```
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function compareValues(a, b) {
+    const ptr0 = passStringToWasm0(a, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(b, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compareValues(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+}
+
+/**
+ * Generates a deterministic hierarchical structure ID for a JSON string.
+ *
+ * ```js
+ * import { hash } from 'genome'
+ * const id = hash(JSON.stringify({ id: 1, name: "alice" }))
+ * ```
+ * @param {string} json
+ * @returns {string}
+ */
+export function hash(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Hashes a string with xxHash32 and returns a hex string.
+ *
+ * ```js
+ * import { hashStr } from 'genome'
+ * const hex = hashStr("hello", 0)
+ * ```
+ * @param {string} input
+ * @param {number} seed
+ * @returns {string}
+ */
+export function hashStr(input, seed) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hashStr(ptr0, len0, seed);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Resets all internal state — clears the key cache and collision counters.
+ *
+ * ```js
+ * import { reset } from 'genome'
+ * reset()
+ * ```
+ */
+export function reset() {
+    wasm.reset();
+}
+
+/**
+ * Seeds the collision counter for a known signature.
+ * Use this to restore persisted counter state.
+ *
+ * ```js
+ * import { seed } from 'genome'
+ * seed("L1:12345-L2:67890", 3n)
+ * ```
+ * @param {string} signature
+ * @param {bigint} count
+ */
+export function seed(signature, count) {
+    const ptr0 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.seed(ptr0, len0, count);
+}
+
+/**
+ * Sets the global config. Call this before using any other functions
+ * if you need non-default behaviour.
+ *
+ * ```js
+ * import { setConfig, hash } from 'genome'
+ *
+ * setConfig({ ignoreArrayLength: true, ignoreValueTypes: true })
+ * const id = hash(JSON.stringify({ items: [1, 2, 3] }))
+ * ```
+ * @param {boolean} new_id_on_collision
+ * @param {boolean} ignore_array_length
+ * @param {boolean} ignore_value_types
+ */
+export function setConfig(new_id_on_collision, ignore_array_length, ignore_value_types) {
+    wasm.setConfig(new_id_on_collision, ignore_array_length, ignore_value_types);
+}
+
+/**
+ * Returns the structural signature for a JSON string.
+ *
+ * In default mode returns the full ID. When `newIdOnCollision` is true
+ * (set via `setConfig`), strips L0 and returns L1+ only.
+ *
+ * ```js
+ * import { signature } from 'genome'
+ * const sig = signature(JSON.stringify({ id: 1, name: "alice" }))
+ * ```
+ * @param {string} json
+ * @returns {string}
+ */
+export function signature(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signature(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/package.json

@@ -1,96 +1,52 @@
 {
-	"private": false,
-	"name": "genome",
-	"version": "1.0.0",
-	"description": "Deterministic structure ID generation for JavaScript objects using hierarchical hashing and collision-resistant algorithms",
-	"author": "Michael Sweeney <overthemike@gmail.com>",
-	"type": "module",
-	"source": "./src/index.ts",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		"./package.json": "./package.json",
-		".": {
-			"require": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.cjs"
-			},
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			}
-		}
-	},
-	"scripts": {
-		"build": "pnpm run clean && pnpm run build:types && pnpm run build:js",
-		"build:types": "tsc --emitDeclarationOnly --declarationMap",
-		"build:js": "tsup",
-		"changeset": "changeset",
-		"version": "changeset version",
-		"release": "changeset publish",
-		"clean": "rm -rf dist",
-		"lint": "biome lint",
-		"lint:fix": "biome lint --fix",
-		"test": "vitest run",
-		"typecheck": "tsc --noEmit",
-		"prepublishOnly": "pnpm run build",
-		"bench": "vitest bench",
-		"coverage": "vitest run --coverage",
-		"test:ui": "vitest --ui"
-	},
-	"files": [
-		"dist",
-		"README.md"
-	],
-	"publishConfig": {
-		"access": "public"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/synpatico/genome.git"
-	},
-	"bugs": {
-		"url": "https://github.com/synpatico/gnome/issues"
-	},
-	"homepage": "https://github.com/synpatico/genome",
-	"directories": {
-		"test": "tests"
-	},
-	"license": "MIT",
-	"devDependencies": {
-		"@biomejs/biome": "^2.1.4",
-		"@testing-library/jest-dom": "^6.6.3",
-		"@types/benchmark": "^2.1.5",
-		"@types/node": "^22.13.14",
-		"@vitest/coverage-v8": "^3.0.9",
-		"@vitest/ui": "^3.0.9",
-		"tsup": "^8.4.0",
-		"typescript": "^5.8.2",
-		"vite": "^6.2.3",
-		"vitest": "^3.0.9"
-	},
-	"keywords": [
-		"structure",
-		"shape",
-		"id",
-		"identifier",
-		"generator",
-		"hash",
-		"fingerprint",
-		"signature",
-		"genome",
-		"schema",
-		"compare",
-		"diff",
-		"deduplication",
-		"memoization",
-		"caching",
-		"serialization",
-		"object",
-		"json",
-		"deterministic",
-		"unique",
-		"synpatico",
-		"type"
-	]
+  "name": "genome",
+  "type": "module",
+  "collaborators": [
+    "Michael Sweeney <overthemike@gmail.com>"
+  ],
+  "description": "Deterministic structure ID generation for JavaScript objects using hierarchical hashing and collision-resistant algorithms",
+  "version": "1.0.3",
+  "license": "MIT",
+  "repository": "https://github.com/overthemike/genome.git",
+  "files": [
+    "genome_rs_bg.wasm",
+    "genome_rs.js",
+    "genome_rs_bg.js",
+    "genome_rs.d.ts"
+  ],
+  "main": "genome_rs.js",
+  "homepage": "https://github.com/overthemike/genome",
+  "types": "genome_rs.d.ts",
+  "sideEffects": [
+    "./genome_rs.js",
+    "./snippets/*"
+  ],
+  "keywords": [
+    "structure",
+    "shape",
+    "id",
+    "identifier",
+    "generator",
+    "hash",
+    "fingerprint",
+    "signature",
+    "genome",
+    "schema",
+    "compare",
+    "diff",
+    "deduplication",
+    "memoization",
+    "caching",
+    "serialization",
+    "object",
+    "json",
+    "deterministic",
+    "unique",
+    "synpatico",
+    "type",
+    "wasm",
+    "rust"
+  ],
+  "author": "Michael Sweeney <overthemike@gmail.com>",
+  "bugs": "https://github.com/overthemike/genome/issues"
 }

package/dist/hash.d.ts

@@ -1,67 +0,0 @@
-/**
- * @fileoverview Fast, non-cryptographic hash functions for structure ID generation
- * @module @synpatico/genome/hash
- */
-/**
- * Available hash function implementations
- */
-export declare const hashFunction: {
-    readonly MURMUR: typeof murmurHash3;
-    readonly XXHASH: typeof xxHash32;
-};
-/**
- * Type representing available hash functions
- */
-export type HashFunction = (typeof hashFunction)[keyof typeof hashFunction];
-/**
- * Options for hash function selection
- */
-type HashFunctionProps = {
-    /** Built-in hash function to use */
-    type?: HashFunction;
-    /** Custom hash function implementation */
-    custom?: (str: string) => string;
-};
-/**
- * Generates a hash from a string using the specified algorithm.
- * Defaults to xxHash32 for optimal performance.
- *
- * @param str - The string to hash
- * @param options - Optional hash function configuration
- * @returns A hexadecimal hash string
- *
- * @example
- * ```javascript
- * // Using default xxHash32
- * const h1 = hash("hello"); // "884863d4"
- *
- * // Using MurmurHash3
- * const h2 = hash("hello", { type: hashFunction.MURMUR }); // "613cae7d"
- *
- * // Using custom function
- * const h3 = hash("hello", { custom: (s) => s.length.toString() }); // "5"
- * ```
- */
-export declare const hash: (str: string, options?: HashFunctionProps) => string;
-/**
- * MurmurHash3 implementation - fast non-cryptographic hash function.
- * Provides good distribution and collision resistance for hash tables.
- *
- * @param str - The string to hash
- * @returns A hexadecimal hash string
- *
- * @example
- * ```javascript
- * const hash = murmurHash3("hello world");
- * console.log(hash); // "5e928f0f"
- * ```
- */
-export declare function murmurHash3(str: string): string;
-/**
- *
- * @param input - byte array or string
- * @param seed - optional seed (32-bit unsigned);
- */
-export declare function xxHash32(input: Uint8Array | string, seed?: number): string;
-export {};
-//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;CAGf,CAAA;AAEV;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAA;AAE3E;;GAEG;AACH,KAAK,iBAAiB,GAAG;IACxB,oCAAoC;IACpC,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAChC,CAAA;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,MAAM,EAAE,UAAU,iBAAiB,KAAG,MAU/D,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAyD/C;AAsBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,IAAI,SAAI,GAAG,MAAM,CA2KrE"}

package/dist/id-indexhash.d.ts

@@ -1,21 +0,0 @@
-/**
- * Order-preserving structure ID generator that avoids GLOBAL_KEY_MAP growth
- * from array indices and lengths by hashing numeric values directly.
- *
- * This mirrors the current generateStructureId algorithm with one change:
- * - For arrays, we compute index/length contributions via numeric hashing
- *   (fixed seeds) instead of storing strings like "[i]" and "length:n"
- *   in GLOBAL_KEY_MAP. Property names still use GLOBAL_KEY_MAP.
- */
-import { type StructureIdConfig } from "./index";
-/**
- * Generate a structure ID while avoiding GLOBAL_KEY_MAP growth from array indices/lengths.
- * Property names still use GLOBAL_KEY_MAP like the current implementation.
- */
-export declare const generateStructureIdIndexHash: (obj: unknown, config?: StructureIdConfig) => string;
-export declare function getStructureInfoIndexHash(obj: unknown, config?: StructureIdConfig): {
-    id: string;
-    levels: number;
-    collisionCount: number;
-};
-//# sourceMappingURL=id-indexhash.d.ts.map

package/dist/id-indexhash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"id-indexhash.d.ts","sourceRoot":"","sources":["../src/id-indexhash.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAML,KAAK,iBAAiB,EACvB,MAAM,SAAS,CAAA;AA8DhB;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACvC,KAAK,OAAO,EACZ,SAAS,iBAAiB,KACzB,MAuHF,CAAA;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,EACZ,MAAM,CAAC,EAAE,iBAAiB,GACzB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAUxD"}

package/dist/id-multiset.d.ts

@@ -1,6 +0,0 @@
-export declare function generateStructureIdMultiset(obj: unknown): string;
-export declare function getStructureInfoMultiset(obj: unknown): {
-    id: string;
-    levels: number;
-};
-//# sourceMappingURL=id-multiset.d.ts.map

package/dist/id-multiset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"id-multiset.d.ts","sourceRoot":"","sources":["../src/id-multiset.ts"],"names":[],"mappings":"AAgCA,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAyEhE;AAGD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAGrF"}

package/dist/id-multiset32.d.ts

@@ -1,2 +0,0 @@
-export declare function generateStructureIdMultiset32(obj: unknown): string;
-//# sourceMappingURL=id-multiset32.d.ts.map

package/dist/id-multiset32.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"id-multiset32.d.ts","sourceRoot":"","sources":["../src/id-multiset32.ts"],"names":[],"mappings":"AAwCA,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAiElE"}