@tanstack/db-ivm 0.1.26 → 0.2.0

package/README.md

@@ -11,7 +11,7 @@ The API is almost identical to D2TS, but without the need to specify a version w
 Here's a simple example that demonstrates the core concepts:
 
 ```typescript
-import { D2, map, filter, debug, MultiSet } from '@tanstack/db-ivm'
+import { D2, map, filter, output, MultiSet } from '@tanstack/db-ivm'
 
 // Create a new D2 graph
 const graph = new D2()
@@ -25,10 +25,10 @@ const input = graph.newInput<number>()
 // 2. Adds 5 to each number
 // 3. Filters to keep only even numbers
 // Pipelines can have multiple inputs and outputs.
-const output = input.pipe(
+input.pipe(
   map((x) => x + 5),
   filter((x) => x % 2 === 0),
-  debug('output'),
+  output((message) => console.log(message.getInner())),
 )
 
 // Finalize the pipeline, after this point we can no longer add operators or
@@ -52,7 +52,6 @@ input.sendData(
 // Process the data
 graph.run()
 
-// Output will show:
-// 6 (from 1 + 5)
-// 8 (from 3 + 5)
+// Output will show [[6, 1], [8, 1]]: 6 (from 1 + 5) and 8 (from 3 + 5),
+// each with a multiplicity of 1
 ```

package/dist/cjs/hashing/hash.cjs

@@ -45,7 +45,9 @@ function hashObject(input, context) {
       if (body) updateHasher(hasher, value, context);
       else hasher.update(value);
     if (body) {
-      const keys = Object.keys(body).sort(keySort);
+      const keys = Object.keys(body);
+      const denseArray = Array.isArray(body) && keys.length === body.length && (keys.length === 0 || keys[keys.length - 1] === String(body.length - 1));
+      if (!denseArray) keys.sort();
       keys.push(
         ...Object.getOwnPropertySymbols(body).filter(
           (key) => Object.prototype.propertyIsEnumerable.call(body, key)
@@ -179,10 +181,63 @@ function cachedReferenceHash(fn) {
   }
   return valueHash;
 }
-function keySort(a, b) {
-  return a.localeCompare(b);
+const MARKER_TAGS = /* @__PURE__ */ new Map([
+  [ARRAY_MARKER, `[`],
+  [OBJECT_MARKER, `{`],
+  [DATE_MARKER, `<`],
+  [REGEXP_MARKER, `/`],
+  [MAP_MARKER, `&`],
+  [SET_MARKER, `*`],
+  [UINT8ARRAY_MARKER, `^`],
+  [TEMPORAL_MARKER, `?`]
+]);
+const MAX_IDENTITY_DEPTH = 4;
+function structuralIdentity(value, depth = 0) {
+  switch (typeof value) {
+    case `number`:
+      return `#${value === 0 ? 0 : value}`;
+    case `string`:
+      return `"${value.length}:${value}`;
+    case `boolean`:
+      return value ? `+` : `-`;
+    case `undefined`:
+      return `~`;
+    case `bigint`:
+      return `%${value}`;
+    case `symbol`:
+      return `$${murmur.getSymbolIdentity(value)}`;
+    case `object`: {
+      if (value === null) return `!`;
+      if (depth >= MAX_IDENTITY_DEPTH || isReferenceHashedObject(value))
+        return void 0;
+      const [marker, header, body] = objectParts(value);
+      let head = MARKER_TAGS.get(marker);
+      for (const part of header) {
+        if (Number.isNaN(part)) return void 0;
+        head += structuralIdentity(part, depth + 1);
+      }
+      if (!body) return head;
+      if (Object.getOwnPropertySymbols(body).some(
+        (key) => Object.prototype.propertyIsEnumerable.call(body, key)
+      ))
+        return void 0;
+      let parts = ``;
+      for (const key of Object.keys(body).sort()) {
+        const part = structuralIdentity(
+          body[key],
+          depth + 1
+        );
+        if (part === void 0) return void 0;
+        parts += `${key.length}:${key}=${part}|`;
+      }
+      return `${head}:${parts.length}:${parts}`;
+    }
+    default:
+      return void 0;
+  }
 }
 exports.equalHashValues = equalHashValues;
 exports.hash = hash;
 exports.registerOpaqueHash = registerOpaqueHash;
+exports.structuralIdentity = structuralIdentity;
 //# sourceMappingURL=hash.cjs.map

package/dist/cjs/hashing/hash.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hash.cjs","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, getSymbolIdentity, randomHash } from './murmur.js'\nimport { isTemporal } from './temporal.js'\nimport type { Hasher } from './murmur.js'\n\n/*\n * Implementation of structural hashing based on the Composites polyfill implementation:\n * https://github.com/tc39/proposal-composites\n */\n\nconst TRUE = randomHash()\nconst FALSE = randomHash()\nconst NULL = randomHash()\nconst UNDEFINED = randomHash()\nconst KEY = randomHash()\nconst FUNCTIONS = randomHash()\n// Identity is distinct even if two random hash values happen to collide.\nconst DATE_MARKER = { hash: randomHash() }\nconst REGEXP_MARKER = { hash: randomHash() }\nconst OBJECT_MARKER = { hash: randomHash() }\nconst ARRAY_MARKER = { hash: randomHash() }\nconst MAP_MARKER = { hash: randomHash() }\nconst SET_MARKER = { hash: randomHash() }\nconst UINT8ARRAY_MARKER = { hash: randomHash() }\nconst TEMPORAL_MARKER = { hash: randomHash() }\n// Bound structural recursion and value visits. Shared acyclic subtrees are\n// cached; cycles are rejected rather than given context-dependent hashes.\nconst MAX_STRUCTURAL_HASH_WORK = 1_000_000\nconst MAX_STRUCTURAL_HASH_DEPTH = 768\n\n// Maximum byte length for Uint8Arrays to hash by content instead of reference\n// Arrays smaller than this will be hashed by content, allowing proper equality comparisons\n// for small arrays like ULIDs (16 bytes) while still avoiding performance costs for large arrays\nconst UINT8ARRAY_CONTENT_HASH_THRESHOLD = 128\n\nconst hashCache = new WeakMap<object, number>()\nconst referenceValues = new WeakSet<object>()\n\n/** @internal Register a mutable handle before it enters a structural value. */\nexport function registerOpaqueHash(value: object): void {\n  cachedReferenceHash(value)\n}\n\ntype HashContext = {\n  activeObjects: Set<object>\n  work: number\n  pendingHashes: Map<object, number>\n}\n\nexport function hash(input: any): number {\n  const hasher = new MurmurHashStream()\n  updateHasher(hasher, input)\n  return hasher.digest()\n}\n\nfunction hashObject(input: object, context: HashContext): number {\n  if (context.activeObjects.size >= MAX_STRUCTURAL_HASH_DEPTH) {\n    throw new RangeError(\n      `Value is too complex to hash safely: structural depth`,\n    )\n  }\n\n  context.activeObjects.add(input)\n\n  let valueHash: number | undefined\n  try {\n    const [marker, header, body] = objectParts(input)\n    const hasher = new MurmurHashStream()\n    hasher.update(marker.hash)\n    // Header values of a type with a body (array length, RegExp fields)\n    // count toward the work cap; Date, binary, and Temporal headers do not.\n    for (const value of header)\n      if (body) updateHasher(hasher, value, context)\n      else hasher.update(value as string | number)\n    if (body) {\n      // Sorted string keys, then enumerable symbol keys by identity.\n      const keys: Array<string | symbol> = Object.keys(body).sort(keySort)\n      keys.push(\n        ...Object.getOwnPropertySymbols(body)\n          .filter((key) =>\n            Object.prototype.propertyIsEnumerable.call(body, key),\n          )\n          .sort(\n            (left, right) => getSymbolIdentity(left) - getSymbolIdentity(right),\n          ),\n      )\n      for (const key of keys) {\n        hasher.update(KEY)\n        hasher.update(key)\n        updateHasher(hasher, body[key as keyof typeof body], context)\n      }\n    }\n    valueHash = hasher.digest()\n  } finally {\n    context.activeObjects.delete(input)\n  }\n\n  context.pendingHashes.set(input, valueHash)\n  return valueHash\n}\n\n/**\n * The one type dispatch shared by structural hashing and equality: a type\n * marker, primitive header values, and an optional object whose enumerable\n * own properties are compared structurally.\n */\ntype ObjectParts = [\n  marker: Readonly<{ hash: number }>,\n  // A RegExp `lastIndex` can hold any value; the other headers are strings\n  // or numbers.\n  header: ReadonlyArray<unknown>,\n  body?: object,\n]\n\nfunction objectParts(input: object): ObjectParts {\n  if (input instanceof Date) {\n    const time = input.getTime()\n    // Invalid dates are equal to each other; headers compare with `===`.\n    return [DATE_MARKER, [Number.isNaN(time) ? `invalid` : time]]\n  }\n  if (isBinaryValue(input))\n    return [\n      UINT8ARRAY_MARKER,\n      [String.fromCharCode.apply(null, input as unknown as Array<number>)],\n    ]\n  if (isTemporal(input))\n    return [TEMPORAL_MARKER, [input[Symbol.toStringTag], input.toString()]]\n  if (input instanceof RegExp)\n    return [REGEXP_MARKER, [input.source, input.flags, input.lastIndex], input]\n  if (input instanceof Map) return [MAP_MARKER, [], [...input.entries()]]\n  if (input instanceof Set) return [SET_MARKER, [], [...input.values()]]\n  return input instanceof Array\n    ? [ARRAY_MARKER, [input.length], input]\n    : [OBJECT_MARKER, [], input]\n}\n\nfunction updateHasher(\n  hasher: Hasher,\n  input: unknown,\n  context?: HashContext,\n): void {\n  if (context && ++context.work > MAX_STRUCTURAL_HASH_WORK) {\n    throw new RangeError(`Value is too complex to hash safely: structural work`)\n  }\n  if (input === null) {\n    hasher.update(NULL)\n    return\n  }\n  switch (typeof input) {\n    case `undefined`:\n      hasher.update(UNDEFINED)\n      return\n    case `boolean`:\n      hasher.update(input ? TRUE : FALSE)\n      return\n    case `number`:\n      // Normalize NaNs and -0\n      hasher.update(isNaN(input) ? NaN : input === 0 ? 0 : input)\n      return\n    case `bigint`:\n    case `string`:\n    case `symbol`:\n      hasher.update(input)\n      return\n    case `object`:\n      hasher.update(getCachedHash(input, context))\n      return\n    case `function`:\n      // Functions are assigned a globally unique ID\n      // and that ID is cached in the weak map\n      hasher.update(cachedReferenceHash(input))\n  }\n}\n\nfunction getCachedHash(input: object, context?: HashContext): number {\n  // Active objects are neither cached nor pending, so the cycle check below\n  // still sees every back-reference.\n  const cached = hashCache.get(input) ?? context?.pendingHashes.get(input)\n  if (cached !== undefined) return cached\n\n  // Opaque leaves cannot contain structural back-references. Resolve them\n  // before entering structural recursion, even when they have user properties.\n  if (isReferenceHashedObject(input)) return cachedReferenceHash(input)\n\n  if (context) {\n    if (context.activeObjects.has(input)) {\n      throw new TypeError(`Cannot hash cyclic structural values`)\n    }\n    return hashObject(input, context)\n  }\n\n  // Only an uncached structural root needs graph traversal state. Commit its\n  // cache entries after success so a failed traversal cannot poison retries.\n  const root: HashContext = {\n    activeObjects: new Set(),\n    work: 0,\n    pendingHashes: new Map(),\n  }\n  const result = hashObject(input, root)\n  for (const [object, valueHash] of root.pendingHashes) {\n    hashCache.set(object, valueHash)\n  }\n  return result\n}\n\nfunction isReferenceHashedObject(input: object): boolean {\n  return (\n    referenceValues.has(input) ||\n    (typeof File !== `undefined` && input instanceof File) ||\n    (isBinaryValue(input) &&\n      input.byteLength > UINT8ARRAY_CONTENT_HASH_THRESHOLD)\n  )\n}\n\n// Buffer can come from another realm than Uint8Array (for example under jsdom).\nfunction isBinaryValue(input: object): input is Uint8Array {\n  return (\n    (typeof Buffer !== `undefined` && input instanceof Buffer) ||\n    input instanceof Uint8Array\n  )\n}\n\n/** @internal Compare immutable structural values without computing a digest.\n * Pair memoization also permits cyclic values that structural hashing rejects.\n * Reference-valued leaves remain opaque, including registered mutable handles.\n */\nexport function equalHashValues(left: unknown, right: unknown): boolean {\n  const compared = new Map<object, Set<object>>()\n  const keys = (value: object) =>\n    Reflect.ownKeys(value).filter((key) =>\n      Object.prototype.propertyIsEnumerable.call(value, key),\n    )\n  function equal(a: unknown, b: unknown): boolean {\n    if (a === b || (Number.isNaN(a) && Number.isNaN(b))) return true\n    if (\n      a === null ||\n      b === null ||\n      typeof a !== `object` ||\n      typeof b !== `object` ||\n      isReferenceHashedObject(a) ||\n      isReferenceHashedObject(b)\n    )\n      return false\n    // Arrays from another realm take the object marker but keep this check.\n    if (Array.isArray(a) && Array.isArray(b) && a.length !== b.length)\n      return false\n\n    // Revisited pairs close cycles and avoid expanding shared subtrees. Check\n    // before objectParts copies Map or Set entries; record only pairs with a\n    // body, after their markers and headers match.\n    const peers = compared.get(a)\n    if (peers?.has(b)) return true\n    const [aMarker, aHeader, aBody] = objectParts(a)\n    const [bMarker, bHeader, bBody] = objectParts(b)\n    if (\n      aMarker !== bMarker ||\n      !aHeader.every((value, index) => value === bHeader[index])\n    )\n      return false\n    if (!aBody || !bBody) return true\n    if (peers) peers.add(b)\n    else compared.set(a, new Set([b]))\n    const aKeys = keys(aBody)\n    return (\n      aKeys.length === keys(bBody).length &&\n      aKeys.every(\n        (key) =>\n          Object.prototype.propertyIsEnumerable.call(bBody, key) &&\n          equal(aBody[key as keyof object], bBody[key as keyof object]),\n      )\n    )\n  }\n  return equal(left, right)\n}\n\nlet nextRefId = 1\nfunction cachedReferenceHash(fn: object): number {\n  let valueHash = hashCache.get(fn)\n  if (valueHash === undefined) {\n    valueHash = nextRefId ^ FUNCTIONS\n    nextRefId++\n    hashCache.set(fn, valueHash)\n    referenceValues.add(fn)\n  }\n  return valueHash\n}\n\n/**\n * Strings sorted lexicographically.\n */\nfunction keySort(a: string, b: string): number {\n  return a.localeCompare(b)\n}\n"],"names":["randomHash","MurmurHashStream","getSymbolIdentity","isTemporal"],"mappings":"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"}
+{"version":3,"file":"hash.cjs","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, getSymbolIdentity, randomHash } from './murmur.js'\nimport { isTemporal } from './temporal.js'\nimport type { Hasher } from './murmur.js'\n\n/*\n * Implementation of structural hashing based on the Composites polyfill implementation:\n * https://github.com/tc39/proposal-composites\n */\n\nconst TRUE = randomHash()\nconst FALSE = randomHash()\nconst NULL = randomHash()\nconst UNDEFINED = randomHash()\nconst KEY = randomHash()\nconst FUNCTIONS = randomHash()\n// Identity is distinct even if two random hash values happen to collide.\nconst DATE_MARKER = { hash: randomHash() }\nconst REGEXP_MARKER = { hash: randomHash() }\nconst OBJECT_MARKER = { hash: randomHash() }\nconst ARRAY_MARKER = { hash: randomHash() }\nconst MAP_MARKER = { hash: randomHash() }\nconst SET_MARKER = { hash: randomHash() }\nconst UINT8ARRAY_MARKER = { hash: randomHash() }\nconst TEMPORAL_MARKER = { hash: randomHash() }\n// Bound structural recursion and value visits. Shared acyclic subtrees are\n// cached; cycles are rejected rather than given context-dependent hashes.\nconst MAX_STRUCTURAL_HASH_WORK = 1_000_000\nconst MAX_STRUCTURAL_HASH_DEPTH = 768\n\n// Maximum byte length for Uint8Arrays to hash by content instead of reference\n// Arrays smaller than this will be hashed by content, allowing proper equality comparisons\n// for small arrays like ULIDs (16 bytes) while still avoiding performance costs for large arrays\nconst UINT8ARRAY_CONTENT_HASH_THRESHOLD = 128\n\nconst hashCache = new WeakMap<object, number>()\nconst referenceValues = new WeakSet<object>()\n\n/** @internal Register a mutable handle before it enters a structural value. */\nexport function registerOpaqueHash(value: object): void {\n  cachedReferenceHash(value)\n}\n\ntype HashContext = {\n  activeObjects: Set<object>\n  work: number\n  pendingHashes: Map<object, number>\n}\n\nexport function hash(input: any): number {\n  const hasher = new MurmurHashStream()\n  updateHasher(hasher, input)\n  return hasher.digest()\n}\n\nfunction hashObject(input: object, context: HashContext): number {\n  if (context.activeObjects.size >= MAX_STRUCTURAL_HASH_DEPTH) {\n    throw new RangeError(\n      `Value is too complex to hash safely: structural depth`,\n    )\n  }\n\n  context.activeObjects.add(input)\n\n  let valueHash: number | undefined\n  try {\n    const [marker, header, body] = objectParts(input)\n    const hasher = new MurmurHashStream()\n    hasher.update(marker.hash)\n    // Header values of a type with a body (array length, RegExp fields)\n    // count toward the work cap; Date, binary, and Temporal headers do not.\n    for (const value of header)\n      if (body) updateHasher(hasher, value, context)\n      else hasher.update(value as string | number)\n    if (body) {\n      // String keys in UTF-16 code-unit order, then enumerable symbol keys by\n      // identity. Code-unit order is total; locale collation can rank two\n      // distinct keys as equal and leave their insertion order in the hash.\n      const keys: Array<string | symbol> = Object.keys(body)\n      // A dense array with no other keys lists its indices in one order for\n      // every equal array: integer keys come first, so the last key is the\n      // last index. Anything else sorts.\n      const denseArray =\n        Array.isArray(body) &&\n        keys.length === body.length &&\n        (keys.length === 0 || keys[keys.length - 1] === String(body.length - 1))\n      if (!denseArray) keys.sort()\n      keys.push(\n        ...Object.getOwnPropertySymbols(body)\n          .filter((key) =>\n            Object.prototype.propertyIsEnumerable.call(body, key),\n          )\n          .sort(\n            (left, right) => getSymbolIdentity(left) - getSymbolIdentity(right),\n          ),\n      )\n      for (const key of keys) {\n        hasher.update(KEY)\n        hasher.update(key)\n        updateHasher(hasher, body[key as keyof typeof body], context)\n      }\n    }\n    valueHash = hasher.digest()\n  } finally {\n    context.activeObjects.delete(input)\n  }\n\n  context.pendingHashes.set(input, valueHash)\n  return valueHash\n}\n\n/**\n * The one type dispatch shared by structural hashing and equality: a type\n * marker, primitive header values, and an optional object whose enumerable\n * own properties are compared structurally.\n */\ntype ObjectParts = [\n  marker: Readonly<{ hash: number }>,\n  // A RegExp `lastIndex` can hold any value; the other headers are strings\n  // or numbers.\n  header: ReadonlyArray<unknown>,\n  body?: object,\n]\n\nfunction objectParts(input: object): ObjectParts {\n  if (input instanceof Date) {\n    const time = input.getTime()\n    // Invalid dates are equal to each other; headers compare with `===`.\n    return [DATE_MARKER, [Number.isNaN(time) ? `invalid` : time]]\n  }\n  if (isBinaryValue(input))\n    return [\n      UINT8ARRAY_MARKER,\n      [String.fromCharCode.apply(null, input as unknown as Array<number>)],\n    ]\n  if (isTemporal(input))\n    return [TEMPORAL_MARKER, [input[Symbol.toStringTag], input.toString()]]\n  if (input instanceof RegExp)\n    return [REGEXP_MARKER, [input.source, input.flags, input.lastIndex], input]\n  if (input instanceof Map) return [MAP_MARKER, [], [...input.entries()]]\n  if (input instanceof Set) return [SET_MARKER, [], [...input.values()]]\n  return input instanceof Array\n    ? [ARRAY_MARKER, [input.length], input]\n    : [OBJECT_MARKER, [], input]\n}\n\nfunction updateHasher(\n  hasher: Hasher,\n  input: unknown,\n  context?: HashContext,\n): void {\n  if (context && ++context.work > MAX_STRUCTURAL_HASH_WORK) {\n    throw new RangeError(`Value is too complex to hash safely: structural work`)\n  }\n  if (input === null) {\n    hasher.update(NULL)\n    return\n  }\n  switch (typeof input) {\n    case `undefined`:\n      hasher.update(UNDEFINED)\n      return\n    case `boolean`:\n      hasher.update(input ? TRUE : FALSE)\n      return\n    case `number`:\n      // Normalize NaNs and -0\n      hasher.update(isNaN(input) ? NaN : input === 0 ? 0 : input)\n      return\n    case `bigint`:\n    case `string`:\n    case `symbol`:\n      hasher.update(input)\n      return\n    case `object`:\n      hasher.update(getCachedHash(input, context))\n      return\n    case `function`:\n      // Functions are assigned a globally unique ID\n      // and that ID is cached in the weak map\n      hasher.update(cachedReferenceHash(input))\n  }\n}\n\nfunction getCachedHash(input: object, context?: HashContext): number {\n  // Active objects are neither cached nor pending, so the cycle check below\n  // still sees every back-reference.\n  const cached = hashCache.get(input) ?? context?.pendingHashes.get(input)\n  if (cached !== undefined) return cached\n\n  // Opaque leaves cannot contain structural back-references. Resolve them\n  // before entering structural recursion, even when they have user properties.\n  if (isReferenceHashedObject(input)) return cachedReferenceHash(input)\n\n  if (context) {\n    if (context.activeObjects.has(input)) {\n      throw new TypeError(`Cannot hash cyclic structural values`)\n    }\n    return hashObject(input, context)\n  }\n\n  // Only an uncached structural root needs graph traversal state. Commit its\n  // cache entries after success so a failed traversal cannot poison retries.\n  const root: HashContext = {\n    activeObjects: new Set(),\n    work: 0,\n    pendingHashes: new Map(),\n  }\n  const result = hashObject(input, root)\n  for (const [object, valueHash] of root.pendingHashes) {\n    hashCache.set(object, valueHash)\n  }\n  return result\n}\n\nfunction isReferenceHashedObject(input: object): boolean {\n  return (\n    referenceValues.has(input) ||\n    (typeof File !== `undefined` && input instanceof File) ||\n    (isBinaryValue(input) &&\n      input.byteLength > UINT8ARRAY_CONTENT_HASH_THRESHOLD)\n  )\n}\n\n// Buffer can come from another realm than Uint8Array (for example under jsdom).\nfunction isBinaryValue(input: object): input is Uint8Array {\n  return (\n    (typeof Buffer !== `undefined` && input instanceof Buffer) ||\n    input instanceof Uint8Array\n  )\n}\n\n/** @internal Compare immutable structural values without computing a digest.\n * Pair memoization also permits cyclic values that structural hashing rejects.\n * Reference-valued leaves remain opaque, including registered mutable handles.\n */\nexport function equalHashValues(left: unknown, right: unknown): boolean {\n  const compared = new Map<object, Set<object>>()\n  const keys = (value: object) =>\n    Reflect.ownKeys(value).filter((key) =>\n      Object.prototype.propertyIsEnumerable.call(value, key),\n    )\n  function equal(a: unknown, b: unknown): boolean {\n    if (a === b || (Number.isNaN(a) && Number.isNaN(b))) return true\n    if (\n      a === null ||\n      b === null ||\n      typeof a !== `object` ||\n      typeof b !== `object` ||\n      isReferenceHashedObject(a) ||\n      isReferenceHashedObject(b)\n    )\n      return false\n    // Arrays from another realm take the object marker but keep this check.\n    if (Array.isArray(a) && Array.isArray(b) && a.length !== b.length)\n      return false\n\n    // Revisited pairs close cycles and avoid expanding shared subtrees. Check\n    // before objectParts copies Map or Set entries; record only pairs with a\n    // body, after their markers and headers match.\n    const peers = compared.get(a)\n    if (peers?.has(b)) return true\n    const [aMarker, aHeader, aBody] = objectParts(a)\n    const [bMarker, bHeader, bBody] = objectParts(b)\n    if (\n      aMarker !== bMarker ||\n      !aHeader.every((value, index) => value === bHeader[index])\n    )\n      return false\n    if (!aBody || !bBody) return true\n    if (peers) peers.add(b)\n    else compared.set(a, new Set([b]))\n    const aKeys = keys(aBody)\n    return (\n      aKeys.length === keys(bBody).length &&\n      aKeys.every(\n        (key) =>\n          Object.prototype.propertyIsEnumerable.call(bBody, key) &&\n          equal(aBody[key as keyof object], bBody[key as keyof object]),\n      )\n    )\n  }\n  return equal(left, right)\n}\n\nlet nextRefId = 1\nfunction cachedReferenceHash(fn: object): number {\n  let valueHash = hashCache.get(fn)\n  if (valueHash === undefined) {\n    valueHash = nextRefId ^ FUNCTIONS\n    nextRefId++\n    hashCache.set(fn, valueHash)\n    referenceValues.add(fn)\n  }\n  return valueHash\n}\n\n// One punctuation tag per objectParts marker, so values of different kinds\n// never share an identity (and no tag reads as an identifier in this source).\nconst MARKER_TAGS = new Map<{ hash: number }, string>([\n  [ARRAY_MARKER, `[`],\n  [OBJECT_MARKER, `{`],\n  [DATE_MARKER, `<`],\n  [REGEXP_MARKER, `/`],\n  [MAP_MARKER, `&`],\n  [SET_MARKER, `*`],\n  [UINT8ARRAY_MARKER, `^`],\n  [TEMPORAL_MARKER, `?`],\n])\n\n// Nesting a structural identity follows: a min or max input is an array of\n// exact keys, and an exact key can hold a reference tuple.\nconst MAX_IDENTITY_DEPTH = 4\n\n/**\n * @internal An exact identity string for a value, or undefined when it has\n * no cheap one. Two values that `equalHashValues` treats as equal get the\n * same result, both undefined or one string; two that it treats as different\n * never share a string. The decision uses only what equalHashValues reads:\n * the type, the `objectParts` marker and headers, and enumerable own keys. groupBy uses it\n * to merge equal contributions without hashing them.\n */\nexport function structuralIdentity(\n  value: unknown,\n  depth = 0,\n): string | undefined {\n  switch (typeof value) {\n    case `number`:\n      // The hash treats -0 as 0 and every NaN as one value.\n      return `#${value === 0 ? 0 : value}`\n    case `string`:\n      return `\"${value.length}:${value}`\n    case `boolean`:\n      return value ? `+` : `-`\n    case `undefined`:\n      return `~`\n    case `bigint`:\n      return `%${value}`\n    case `symbol`:\n      return `$${getSymbolIdentity(value)}`\n    case `object`: {\n      if (value === null) return `!`\n      if (depth >= MAX_IDENTITY_DEPTH || isReferenceHashedObject(value))\n        return undefined\n      const [marker, header, body] = objectParts(value)\n      // equalHashValues compares headers with ===, so a NaN header is never\n      // equal to another value's, and gets no identity.\n      let head = MARKER_TAGS.get(marker)!\n      for (const part of header) {\n        if (Number.isNaN(part)) return undefined\n        head += structuralIdentity(part, depth + 1)\n      }\n      if (!body) return head\n      if (\n        Object.getOwnPropertySymbols(body).some((key) =>\n          Object.prototype.propertyIsEnumerable.call(body, key),\n        )\n      )\n        return undefined\n      let parts = ``\n      for (const key of Object.keys(body).sort()) {\n        const part = structuralIdentity(\n          (body as Record<string, unknown>)[key],\n          depth + 1,\n        )\n        if (part === undefined) return undefined\n        parts += `${key.length}:${key}=${part}|`\n      }\n      // An array's header is its length, so a hole differs from undefined.\n      return `${head}:${parts.length}:${parts}`\n    }\n    default:\n      return undefined\n  }\n}\n"],"names":["randomHash","MurmurHashStream","getSymbolIdentity","isTemporal"],"mappings":"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"}

package/dist/cjs/hashing/hash.d.cts

@@ -6,3 +6,12 @@ export declare function hash(input: any): number;
  * Reference-valued leaves remain opaque, including registered mutable handles.
  */
 export declare function equalHashValues(left: unknown, right: unknown): boolean;
+/**
+ * @internal An exact identity string for a value, or undefined when it has
+ * no cheap one. Two values that `equalHashValues` treats as equal get the
+ * same result, both undefined or one string; two that it treats as different
+ * never share a string. The decision uses only what equalHashValues reads:
+ * the type, the `objectParts` marker and headers, and enumerable own keys. groupBy uses it
+ * to merge equal contributions without hashing them.
+ */
+export declare function structuralIdentity(value: unknown, depth?: number): string | undefined;

package/dist/cjs/hashing/murmur.cjs

@@ -38,9 +38,7 @@ function createSymbolIdStore() {
 function randomHash() {
   return Math.random() * (2 ** 31 - 1) >>> 0;
 }
-const buf = new ArrayBuffer(8);
-const dv = new DataView(buf);
-const u8 = new Uint8Array(buf);
+const dv = new DataView(new ArrayBuffer(8));
 class MurmurHashStream {
   constructor() {
     this.hash = RANDOM_SEED;
@@ -66,6 +64,17 @@ class MurmurHashStream {
       this.carryBytes = 0;
     }
   }
+  /** Write four bytes, low byte first, as four `writeByte` calls would. */
+  writeWord(word) {
+    this.length += 4;
+    if (this.carryBytes === 0) {
+      this._mix(word >>> 0);
+      return;
+    }
+    const shift = 8 * this.carryBytes;
+    this._mix((this.carry | word << shift) >>> 0);
+    this.carry = word >>> 32 - shift;
+  }
   update(chunk) {
     switch (typeof chunk) {
       case `symbol`: {
@@ -75,22 +84,24 @@ class MurmurHashStream {
       }
       case `string`:
         this.update(STRING_MARKER);
-        for (let i = 0; i < chunk.length; i++) {
-          const code = chunk.charCodeAt(i);
-          this.writeByte(code & 255);
-          this.writeByte(code >>> 8 & 255);
+        {
+          const pairs = chunk.length - chunk.length % 2;
+          for (let i = 0; i < pairs; i += 2) {
+            this.writeWord(
+              chunk.charCodeAt(i) | chunk.charCodeAt(i + 1) << 16
+            );
+          }
+          if (pairs < chunk.length) {
+            const code = chunk.charCodeAt(pairs);
+            this.writeByte(code & 255);
+            this.writeByte(code >>> 8 & 255);
+          }
         }
         return;
       case `number`:
         dv.setFloat64(0, chunk, true);
-        this.writeByte(u8[0]);
-        this.writeByte(u8[1]);
-        this.writeByte(u8[2]);
-        this.writeByte(u8[3]);
-        this.writeByte(u8[4]);
-        this.writeByte(u8[5]);
-        this.writeByte(u8[6]);
-        this.writeByte(u8[7]);
+        this.writeWord(dv.getUint32(0, true));
+        this.writeWord(dv.getUint32(4, true));
         return;
       case `bigint`: {
         let value = chunk;

package/dist/cjs/hashing/murmur.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"murmur.cjs","sources":["../../../src/hashing/murmur.ts"],"sourcesContent":["/*\n * Implementation of murmur hash based on the Composites polyfill implementation:\n * https://github.com/tc39/proposal-composites\n */\n\nconst RANDOM_SEED = randomHash()\nconst STRING_MARKER = randomHash()\nconst BIG_INT_MARKER = randomHash()\nconst NEG_BIG_INT_MARKER = randomHash()\nconst SYMBOL_MARKER = randomHash()\n\ntype SymbolIdStore = {\n  get: (key: symbol) => number | undefined\n  set: (key: symbol, value: number) => unknown\n}\n\nconst symbolIds = createSymbolIdStore()\nconst registeredSymbolIds = new Map<string, number>()\nlet nextSymbolId = 0\n\nexport function getSymbolIdentity(symbol: symbol): number {\n  const registeredKey = Symbol.keyFor(symbol)\n  if (registeredKey !== undefined) {\n    let id = registeredSymbolIds.get(registeredKey)\n    if (id === undefined) {\n      id = ++nextSymbolId\n      registeredSymbolIds.set(registeredKey, id)\n    }\n    return id\n  }\n\n  let id = symbolIds.get(symbol)\n  if (id === undefined) {\n    id = ++nextSymbolId\n    symbolIds.set(symbol, id)\n  }\n  return id\n}\n\nfunction createSymbolIdStore(): SymbolIdStore {\n  const weakIds = new WeakMap<object, number>() as unknown as SymbolIdStore\n  const probe = Symbol()\n\n  try {\n    weakIds.set(probe, 0)\n    if (weakIds.get(probe) === 0) return weakIds\n  } catch {\n    // Older runtimes reject symbols as weak keys. Retain them rather than\n    // merge distinct symbols and corrupt differential state.\n  }\n\n  return new Map<symbol, number>()\n}\n\nexport type Hash = number\n\nexport function randomHash() {\n  return (Math.random() * (2 ** 31 - 1)) >>> 0\n}\n\nexport interface Hasher {\n  update: (val: symbol | string | number | bigint) => void\n  digest: () => number\n}\n\n// Allocate these once, outside the hot path\nconst buf = new ArrayBuffer(8)\n// dv and u8 are 2 different views on the same buffer `buf`\nconst dv = new DataView(buf)\nconst u8 = new Uint8Array(buf)\n\n/**\n * This implementation of Murmur hash uses a random initial seed and random markers.\n * This means that hashes aren't deterministic across app restarts.\n * This is intentional in the composites polyfill to be resistent to hash-flooding attacks\n * where malicious users would precompute lots of different objects whose hashes collide with each other.\n *\n * Currently, for ts/db-ivm this is fine because we don't persist client state.\n * However, when we will introduce persistence we will either need to store the seeds or remove the randomness\n * to ensure deterministic hashes across app restarts.\n */\nexport class MurmurHashStream implements Hasher {\n  private hash: number = RANDOM_SEED\n  private length = 0\n  private carry = 0\n  private carryBytes = 0\n\n  private _mix(k1: number): void {\n    k1 = Math.imul(k1, 0xcc9e2d51)\n    k1 = (k1 << 15) | (k1 >>> 17)\n    k1 = Math.imul(k1, 0x1b873593)\n    this.hash ^= k1\n    this.hash = (this.hash << 13) | (this.hash >>> 19)\n    this.hash = Math.imul(this.hash, 5) + 0xe6546b64\n  }\n\n  writeByte(byte: number): void {\n    this.carry |= (byte & 0xff) << (8 * this.carryBytes)\n    this.carryBytes++\n    this.length++\n\n    if (this.carryBytes === 4) {\n      this._mix(this.carry >>> 0)\n      this.carry = 0\n      this.carryBytes = 0\n    }\n  }\n\n  update(chunk: symbol | string | number | bigint): void {\n    switch (typeof chunk) {\n      case `symbol`: {\n        this.update(SYMBOL_MARKER)\n        this.update(getSymbolIdentity(chunk))\n        return\n      }\n      case `string`:\n        this.update(STRING_MARKER)\n        for (let i = 0; i < chunk.length; i++) {\n          const code = chunk.charCodeAt(i)\n          this.writeByte(code & 0xff)\n          this.writeByte((code >>> 8) & 0xff)\n        }\n        return\n      case `number`:\n        dv.setFloat64(0, chunk, true) // fixed little-endian\n        this.writeByte(u8[0]!)\n        this.writeByte(u8[1]!)\n        this.writeByte(u8[2]!)\n        this.writeByte(u8[3]!)\n        this.writeByte(u8[4]!)\n        this.writeByte(u8[5]!)\n        this.writeByte(u8[6]!)\n        this.writeByte(u8[7]!)\n        return\n      case `bigint`: {\n        let value = chunk\n        if (value < 0n) {\n          value = -value\n          this.update(NEG_BIG_INT_MARKER)\n        } else {\n          this.update(BIG_INT_MARKER)\n        }\n        while (value > 0n) {\n          this.writeByte(Number(value & 0xffn))\n          value >>= 8n\n        }\n        if (chunk === 0n) this.writeByte(0)\n        return\n      }\n      default:\n        throw new TypeError(`Unsupported input type: ${typeof chunk}`)\n    }\n  }\n\n  digest(): number {\n    if (this.carryBytes > 0) {\n      let k1 = this.carry >>> 0\n      k1 = Math.imul(k1, 0xcc9e2d51)\n      k1 = (k1 << 15) | (k1 >>> 17)\n      k1 = Math.imul(k1, 0x1b873593)\n      this.hash ^= k1\n    }\n\n    this.hash ^= this.length\n    this.hash ^= this.hash >>> 16\n    this.hash = Math.imul(this.hash, 0x85ebca6b)\n    this.hash ^= this.hash >>> 13\n    this.hash = Math.imul(this.hash, 0xc2b2ae35)\n    this.hash ^= this.hash >>> 16\n\n    return this.hash >>> 0\n  }\n}\n"],"names":["id"],"mappings":"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"}
+{"version":3,"file":"murmur.cjs","sources":["../../../src/hashing/murmur.ts"],"sourcesContent":["/*\n * Implementation of murmur hash based on the Composites polyfill implementation:\n * https://github.com/tc39/proposal-composites\n */\n\nconst RANDOM_SEED = randomHash()\nconst STRING_MARKER = randomHash()\nconst BIG_INT_MARKER = randomHash()\nconst NEG_BIG_INT_MARKER = randomHash()\nconst SYMBOL_MARKER = randomHash()\n\ntype SymbolIdStore = {\n  get: (key: symbol) => number | undefined\n  set: (key: symbol, value: number) => unknown\n}\n\nconst symbolIds = createSymbolIdStore()\nconst registeredSymbolIds = new Map<string, number>()\nlet nextSymbolId = 0\n\nexport function getSymbolIdentity(symbol: symbol): number {\n  const registeredKey = Symbol.keyFor(symbol)\n  if (registeredKey !== undefined) {\n    let id = registeredSymbolIds.get(registeredKey)\n    if (id === undefined) {\n      id = ++nextSymbolId\n      registeredSymbolIds.set(registeredKey, id)\n    }\n    return id\n  }\n\n  let id = symbolIds.get(symbol)\n  if (id === undefined) {\n    id = ++nextSymbolId\n    symbolIds.set(symbol, id)\n  }\n  return id\n}\n\nfunction createSymbolIdStore(): SymbolIdStore {\n  const weakIds = new WeakMap<object, number>() as unknown as SymbolIdStore\n  const probe = Symbol()\n\n  try {\n    weakIds.set(probe, 0)\n    if (weakIds.get(probe) === 0) return weakIds\n  } catch {\n    // Older runtimes reject symbols as weak keys. Retain them rather than\n    // merge distinct symbols and corrupt differential state.\n  }\n\n  return new Map<symbol, number>()\n}\n\nexport type Hash = number\n\nexport function randomHash() {\n  return (Math.random() * (2 ** 31 - 1)) >>> 0\n}\n\nexport interface Hasher {\n  update: (val: symbol | string | number | bigint) => void\n  digest: () => number\n}\n\n// Allocate this once, outside the hot path\nconst dv = new DataView(new ArrayBuffer(8))\n\n/**\n * This implementation of Murmur hash uses a random initial seed and random markers.\n * This means that hashes aren't deterministic across app restarts.\n * This is intentional in the composites polyfill to be resistent to hash-flooding attacks\n * where malicious users would precompute lots of different objects whose hashes collide with each other.\n *\n * Currently, for ts/db-ivm this is fine because we don't persist client state.\n * However, when we will introduce persistence we will either need to store the seeds or remove the randomness\n * to ensure deterministic hashes across app restarts.\n */\nexport class MurmurHashStream implements Hasher {\n  private hash: number = RANDOM_SEED\n  private length = 0\n  private carry = 0\n  private carryBytes = 0\n\n  private _mix(k1: number): void {\n    k1 = Math.imul(k1, 0xcc9e2d51)\n    k1 = (k1 << 15) | (k1 >>> 17)\n    k1 = Math.imul(k1, 0x1b873593)\n    this.hash ^= k1\n    this.hash = (this.hash << 13) | (this.hash >>> 19)\n    this.hash = Math.imul(this.hash, 5) + 0xe6546b64\n  }\n\n  writeByte(byte: number): void {\n    this.carry |= (byte & 0xff) << (8 * this.carryBytes)\n    this.carryBytes++\n    this.length++\n\n    if (this.carryBytes === 4) {\n      this._mix(this.carry >>> 0)\n      this.carry = 0\n      this.carryBytes = 0\n    }\n  }\n\n  /** Write four bytes, low byte first, as four `writeByte` calls would. */\n  private writeWord(word: number): void {\n    this.length += 4\n    if (this.carryBytes === 0) {\n      this._mix(word >>> 0)\n      return\n    }\n    // The carry's bytes come first. The word's low bytes complete that block,\n    // and its high bytes become the new carry, which keeps its byte count.\n    const shift = 8 * this.carryBytes\n    this._mix((this.carry | (word << shift)) >>> 0)\n    this.carry = word >>> (32 - shift)\n  }\n\n  update(chunk: symbol | string | number | bigint): void {\n    switch (typeof chunk) {\n      case `symbol`: {\n        this.update(SYMBOL_MARKER)\n        this.update(getSymbolIdentity(chunk))\n        return\n      }\n      case `string`:\n        this.update(STRING_MARKER)\n        {\n          // Each code unit is two bytes, so a pair of them is one word.\n          const pairs = chunk.length - (chunk.length % 2)\n          for (let i = 0; i < pairs; i += 2) {\n            this.writeWord(\n              chunk.charCodeAt(i) | (chunk.charCodeAt(i + 1) << 16),\n            )\n          }\n          if (pairs < chunk.length) {\n            const code = chunk.charCodeAt(pairs)\n            this.writeByte(code & 0xff)\n            this.writeByte((code >>> 8) & 0xff)\n          }\n        }\n        return\n      case `number`:\n        dv.setFloat64(0, chunk, true) // fixed little-endian\n        this.writeWord(dv.getUint32(0, true))\n        this.writeWord(dv.getUint32(4, true))\n        return\n      case `bigint`: {\n        let value = chunk\n        if (value < 0n) {\n          value = -value\n          this.update(NEG_BIG_INT_MARKER)\n        } else {\n          this.update(BIG_INT_MARKER)\n        }\n        while (value > 0n) {\n          this.writeByte(Number(value & 0xffn))\n          value >>= 8n\n        }\n        if (chunk === 0n) this.writeByte(0)\n        return\n      }\n      default:\n        throw new TypeError(`Unsupported input type: ${typeof chunk}`)\n    }\n  }\n\n  digest(): number {\n    if (this.carryBytes > 0) {\n      let k1 = this.carry >>> 0\n      k1 = Math.imul(k1, 0xcc9e2d51)\n      k1 = (k1 << 15) | (k1 >>> 17)\n      k1 = Math.imul(k1, 0x1b873593)\n      this.hash ^= k1\n    }\n\n    this.hash ^= this.length\n    this.hash ^= this.hash >>> 16\n    this.hash = Math.imul(this.hash, 0x85ebca6b)\n    this.hash ^= this.hash >>> 13\n    this.hash = Math.imul(this.hash, 0xc2b2ae35)\n    this.hash ^= this.hash >>> 16\n\n    return this.hash >>> 0\n  }\n}\n"],"names":["id"],"mappings":";;AAKA,MAAM,cAAc,WAAA;AACpB,MAAM,gBAAgB,WAAA;AACtB,MAAM,iBAAiB,WAAA;AACvB,MAAM,qBAAqB,WAAA;AAC3B,MAAM,gBAAgB,WAAA;AAOtB,MAAM,YAAY,oBAAA;AAClB,MAAM,0CAA0B,IAAA;AAChC,IAAI,eAAe;AAEZ,SAAS,kBAAkB,QAAwB;AACxD,QAAM,gBAAgB,OAAO,OAAO,MAAM;AAC1C,MAAI,kBAAkB,QAAW;AAC/B,QAAIA,MAAK,oBAAoB,IAAI,aAAa;AAC9C,QAAIA,QAAO,QAAW;AACpBA,YAAK,EAAE;AACP,0BAAoB,IAAI,eAAeA,GAAE;AAAA,IAC3C;AACA,WAAOA;AAAAA,EACT;AAEA,MAAI,KAAK,UAAU,IAAI,MAAM;AAC7B,MAAI,OAAO,QAAW;AACpB,SAAK,EAAE;AACP,cAAU,IAAI,QAAQ,EAAE;AAAA,EAC1B;AACA,SAAO;AACT;AAEA,SAAS,sBAAqC;AAC5C,QAAM,8BAAc,QAAA;AACpB,QAAM,QAAQ,uBAAA;AAEd,MAAI;AACF,YAAQ,IAAI,OAAO,CAAC;AACpB,QAAI,QAAQ,IAAI,KAAK,MAAM,EAAG,QAAO;AAAA,EACvC,QAAQ;AAAA,EAGR;AAEA,6BAAW,IAAA;AACb;AAIO,SAAS,aAAa;AAC3B,SAAQ,KAAK,OAAA,KAAY,KAAK,KAAK,OAAQ;AAC7C;AAQA,MAAM,KAAK,IAAI,SAAS,IAAI,YAAY,CAAC,CAAC;AAYnC,MAAM,iBAAmC;AAAA,EAAzC,cAAA;AACL,SAAQ,OAAe;AACvB,SAAQ,SAAS;AACjB,SAAQ,QAAQ;AAChB,SAAQ,aAAa;AAAA,EAAA;AAAA,EAEb,KAAK,IAAkB;AAC7B,SAAK,KAAK,KAAK,IAAI,UAAU;AAC7B,SAAM,MAAM,KAAO,OAAO;AAC1B,SAAK,KAAK,KAAK,IAAI,SAAU;AAC7B,SAAK,QAAQ;AACb,SAAK,OAAQ,KAAK,QAAQ,KAAO,KAAK,SAAS;AAC/C,SAAK,OAAO,KAAK,KAAK,KAAK,MAAM,CAAC,IAAI;AAAA,EACxC;AAAA,EAEA,UAAU,MAAoB;AAC5B,SAAK,UAAU,OAAO,QAAU,IAAI,KAAK;AACzC,SAAK;AACL,SAAK;AAEL,QAAI,KAAK,eAAe,GAAG;AACzB,WAAK,KAAK,KAAK,UAAU,CAAC;AAC1B,WAAK,QAAQ;AACb,WAAK,aAAa;AAAA,IACpB;AAAA,EACF;AAAA;AAAA,EAGQ,UAAU,MAAoB;AACpC,SAAK,UAAU;AACf,QAAI,KAAK,eAAe,GAAG;AACzB,WAAK,KAAK,SAAS,CAAC;AACpB;AAAA,IACF;AAGA,UAAM,QAAQ,IAAI,KAAK;AACvB,SAAK,MAAM,KAAK,QAAS,QAAQ,WAAY,CAAC;AAC9C,SAAK,QAAQ,SAAU,KAAK;AAAA,EAC9B;AAAA,EAEA,OAAO,OAAgD;AACrD,YAAQ,OAAO,OAAA;AAAA,MACb,KAAK,UAAU;AACb,aAAK,OAAO,aAAa;AACzB,aAAK,OAAO,kBAAkB,KAAK,CAAC;AACpC;AAAA,MACF;AAAA,MACA,KAAK;AACH,aAAK,OAAO,aAAa;AACzB;AAEE,gBAAM,QAAQ,MAAM,SAAU,MAAM,SAAS;AAC7C,mBAAS,IAAI,GAAG,IAAI,OAAO,KAAK,GAAG;AACjC,iBAAK;AAAA,cACH,MAAM,WAAW,CAAC,IAAK,MAAM,WAAW,IAAI,CAAC,KAAK;AAAA,YAAA;AAAA,UAEtD;AACA,cAAI,QAAQ,MAAM,QAAQ;AACxB,kBAAM,OAAO,MAAM,WAAW,KAAK;AACnC,iBAAK,UAAU,OAAO,GAAI;AAC1B,iBAAK,UAAW,SAAS,IAAK,GAAI;AAAA,UACpC;AAAA,QACF;AACA;AAAA,MACF,KAAK;AACH,WAAG,WAAW,GAAG,OAAO,IAAI;AAC5B,aAAK,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;AACpC,aAAK,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;AACpC;AAAA,MACF,KAAK,UAAU;AACb,YAAI,QAAQ;AACZ,YAAI,QAAQ,IAAI;AACd,kBAAQ,CAAC;AACT,eAAK,OAAO,kBAAkB;AAAA,QAChC,OAAO;AACL,eAAK,OAAO,cAAc;AAAA,QAC5B;AACA,eAAO,QAAQ,IAAI;AACjB,eAAK,UAAU,OAAO,QAAQ,KAAK,CAAC;AACpC,oBAAU;AAAA,QACZ;AACA,YAAI,UAAU,GAAI,MAAK,UAAU,CAAC;AAClC;AAAA,MACF;AAAA,MACA;AACE,cAAM,IAAI,UAAU,2BAA2B,OAAO,KAAK,EAAE;AAAA,IAAA;AAAA,EAEnE;AAAA,EAEA,SAAiB;AACf,QAAI,KAAK,aAAa,GAAG;AACvB,UAAI,KAAK,KAAK,UAAU;AACxB,WAAK,KAAK,KAAK,IAAI,UAAU;AAC7B,WAAM,MAAM,KAAO,OAAO;AAC1B,WAAK,KAAK,KAAK,IAAI,SAAU;AAC7B,WAAK,QAAQ;AAAA,IACf;AAEA,SAAK,QAAQ,KAAK;AAClB,SAAK,QAAQ,KAAK,SAAS;AAC3B,SAAK,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU;AAC3C,SAAK,QAAQ,KAAK,SAAS;AAC3B,SAAK,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU;AAC3C,SAAK,QAAQ,KAAK,SAAS;AAE3B,WAAO,KAAK,SAAS;AAAA,EACvB;AACF;;;;"}

package/dist/cjs/hashing/murmur.d.cts

@@ -22,6 +22,8 @@ export declare class MurmurHashStream implements Hasher {
     private carryBytes;
     private _mix;
     writeByte(byte: number): void;
+    /** Write four bytes, low byte first, as four `writeByte` calls would. */
+    private writeWord;
     update(chunk: symbol | string | number | bigint): void;
     digest(): number;
 }

package/dist/cjs/index.cjs

@@ -6,25 +6,19 @@ const utils = require("./utils.cjs");
 const hash = require("./hashing/hash.cjs");
 const concat = require("./operators/concat.cjs");
 const consolidate = require("./operators/consolidate.cjs");
-const count = require("./operators/count.cjs");
-const debug = require("./operators/debug.cjs");
 const distinct = require("./operators/distinct.cjs");
 const filter = require("./operators/filter.cjs");
 const groupedTopKWithFractionalIndex = require("./operators/groupedTopKWithFractionalIndex.cjs");
 const join = require("./operators/join.cjs");
 const map = require("./operators/map.cjs");
-const negate = require("./operators/negate.cjs");
 const output = require("./operators/output.cjs");
 const reduce = require("./operators/reduce.cjs");
 const tap = require("./operators/tap.cjs");
 const topKWithFractionalIndex = require("./operators/topKWithFractionalIndex.cjs");
-const filterBy = require("./operators/filterBy.cjs");
 const groupBy = require("./operators/groupBy.cjs");
 const groupedOrderBy = require("./operators/groupedOrderBy.cjs");
-const keying = require("./operators/keying.cjs");
 const orderBy = require("./operators/orderBy.cjs");
 const pipe = require("./operators/pipe.cjs");
-const topK = require("./operators/topK.cjs");
 exports.D2 = d2.D2;
 exports.RootStreamBuilder = d2.RootStreamBuilder;
 exports.StreamBuilder = d2.StreamBuilder;
@@ -36,10 +30,6 @@ exports.ConcatOperator = concat.ConcatOperator;
 exports.concat = concat.concat;
 exports.ConsolidateOperator = consolidate.ConsolidateOperator;
 exports.consolidate = consolidate.consolidate;
-exports.CountOperator = count.CountOperator;
-exports.count = count.count;
-exports.DebugOperator = debug.DebugOperator;
-exports.debug = debug.debug;
 exports.DistinctOperator = distinct.DistinctOperator;
 exports.distinct = distinct.distinct;
 exports.FilterOperator = filter.FilterOperator;
@@ -47,16 +37,9 @@ exports.filter = filter.filter;
 exports.GroupedTopKWithFractionalIndexOperator = groupedTopKWithFractionalIndex.GroupedTopKWithFractionalIndexOperator;
 exports.groupedTopKWithFractionalIndex = groupedTopKWithFractionalIndex.groupedTopKWithFractionalIndex;
 exports.JoinOperator = join.JoinOperator;
-exports.antiJoin = join.antiJoin;
-exports.fullJoin = join.fullJoin;
-exports.innerJoin = join.innerJoin;
 exports.join = join.join;
-exports.leftJoin = join.leftJoin;
-exports.rightJoin = join.rightJoin;
 exports.MapOperator = map.MapOperator;
 exports.map = map.map;
-exports.NegateOperator = negate.NegateOperator;
-exports.negate = negate.negate;
 exports.OutputOperator = output.OutputOperator;
 exports.output = output.output;
 exports.ReduceOperator = reduce.ReduceOperator;
@@ -65,18 +48,9 @@ exports.TapOperator = tap.TapOperator;
 exports.tap = tap.tap;
 exports.TopKWithFractionalIndexOperator = topKWithFractionalIndex.TopKWithFractionalIndexOperator;
 exports.topKWithFractionalIndex = topKWithFractionalIndex.topKWithFractionalIndex;
-exports.filterBy = filterBy.filterBy;
 exports.groupBy = groupBy.groupBy;
 exports.groupByOperators = groupBy.groupByOperators;
 exports.groupedOrderByWithFractionalIndex = groupedOrderBy.groupedOrderByWithFractionalIndex;
-exports.keyBy = keying.keyBy;
-exports.rekey = keying.rekey;
-exports.unkey = keying.unkey;
-exports.orderBy = orderBy.orderBy;
 exports.orderByWithFractionalIndex = orderBy.orderByWithFractionalIndex;
-exports.orderByWithFractionalIndexBase = orderBy.orderByWithFractionalIndexBase;
-exports.orderByWithIndex = orderBy.orderByWithIndex;
 exports.pipe = pipe.pipe;
-exports.topK = topK.topK;
-exports.topKWithIndex = topK.topKWithIndex;
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/indexes.cjs

@@ -6,8 +6,9 @@ const NO_PREFIX = /* @__PURE__ */ Symbol(`NO_PREFIX`);
 class PrefixMap extends Map {
   /**
    * Add a value to the PrefixMap. Returns true if the map becomes empty after the operation.
+   * With `prefixIdentity`, values that share a prefix are the same value.
    */
-  addValue(value, multiplicity) {
+  addValue(value, multiplicity, prefixIdentity = false) {
     if (multiplicity === 0) return this.size === 0;
     const prefix = getPrefix(value);
     const valueMapOrSingleValue = this.get(prefix);
@@ -17,7 +18,7 @@ class PrefixMap extends Map {
       if (!isSamePrefix(currentPrefix, prefix)) {
         throw new Error(`Mismatching prefixes, this should never happen`);
       }
-      if (currentValue === value || hash.hash(currentValue) === hash.hash(value)) {
+      if (currentValue === value || prefixIdentity && prefix !== NO_PREFIX || hash.hash(currentValue) === hash.hash(value)) {
         const newMultiplicity = currentMultiplicity + multiplicity;
         if (newMultiplicity === 0) {
           this.delete(prefix);
@@ -78,10 +79,20 @@ class Index {
    *   hash to identify identical values, storing them in a third level value map.
    */
   #inner;
-  #consolidatedMultiplicity = /* @__PURE__ */ new Map();
-  // sum of multiplicities per key
-  constructor() {
+  // Sum of multiplicities per key, for presence. Only joins read presence; a
+  // reduce index is built without it.
+  #consolidatedMultiplicity;
+  /**
+   * When true, the producer guarantees that a value's string or number
+   * prefix determines the value: two values under one key with an equal
+   * prefix are equal, so they merge without a structural hash.
+   */
+  #prefixIdentity;
+  constructor(options) {
     this.#inner = /* @__PURE__ */ new Map();
+    if (options?.trackPresence ?? true)
+      this.#consolidatedMultiplicity = /* @__PURE__ */ new Map();
+    this.#prefixIdentity = options?.prefixIdentity ?? false;
   }
   /**
    * Create an Index from multiple MultiSet messages.
@@ -116,6 +127,11 @@ class Index {
   get size() {
     return this.#inner.size;
   }
+  #presence() {
+    if (this.#consolidatedMultiplicity === void 0)
+      throw new Error(`This Index does not track presence`);
+    return this.#consolidatedMultiplicity;
+  }
   /**
    * This method checks if the index has a given key.
    * @param key - The key to check.
@@ -130,7 +146,7 @@ class Index {
    * @returns True if the key has non-zero consolidated multiplicity, false otherwise.
    */
   hasPresence(key) {
-    return (this.#consolidatedMultiplicity.get(key) || 0) !== 0;
+    return (this.#presence().get(key) || 0) !== 0;
   }
   /**
    * Get the consolidated multiplicity (sum of multiplicities) for a key.
@@ -138,14 +154,14 @@ class Index {
    * @returns The consolidated multiplicity for the key.
    */
   getConsolidatedMultiplicity(key) {
-    return this.#consolidatedMultiplicity.get(key) || 0;
+    return this.#presence().get(key) || 0;
   }
   /**
    * Get all keys that have presence (non-zero consolidated multiplicity).
    * @returns An iterator of keys with non-zero consolidated multiplicity.
    */
   getPresenceKeys() {
-    return this.#consolidatedMultiplicity.keys();
+    return this.#presence().keys();
   }
   /**
    * This method returns all values for a given key.
@@ -153,7 +169,20 @@ class Index {
    * @returns An array of value tuples [value, multiplicity].
    */
   get(key) {
-    return [...this.getIterator(key)];
+    const mapOrSingleValue = this.#inner.get(key);
+    if (mapOrSingleValue === void 0) return [];
+    if (isSingleValue(mapOrSingleValue)) return [mapOrSingleValue];
+    if (mapOrSingleValue instanceof ValueMap)
+      return [...mapOrSingleValue.values()];
+    const result = [];
+    for (const singleValueOrValueMap of mapOrSingleValue.values()) {
+      if (isSingleValue(singleValueOrValueMap))
+        result.push(singleValueOrValueMap);
+      else
+        for (const valueTuple of singleValueOrValueMap.values())
+          result.push(valueTuple);
+    }
+    return result;
   }
   /**
    * This method returns an iterator over all values for a given key.
@@ -212,11 +241,14 @@ class Index {
   addValue(key, valueTuple) {
     const [value, multiplicity] = valueTuple;
     if (multiplicity === 0) return;
-    const newConsolidatedMultiplicity = (this.#consolidatedMultiplicity.get(key) || 0) + multiplicity;
-    if (newConsolidatedMultiplicity === 0) {
-      this.#consolidatedMultiplicity.delete(key);
-    } else {
-      this.#consolidatedMultiplicity.set(key, newConsolidatedMultiplicity);
+    const presence = this.#consolidatedMultiplicity;
+    if (presence) {
+      const newConsolidatedMultiplicity = (presence.get(key) || 0) + multiplicity;
+      if (newConsolidatedMultiplicity === 0) {
+        presence.delete(key);
+      } else {
+        presence.set(key, newConsolidatedMultiplicity);
+      }
     }
     const mapOrSingleValue = this.#inner.get(key);
     if (mapOrSingleValue === void 0) {
@@ -246,7 +278,11 @@ class Index {
         }
       }
     } else {
-      const isEmpty = mapOrSingleValue.addValue(value, multiplicity);
+      const isEmpty = mapOrSingleValue.addValue(
+        value,
+        multiplicity,
+        this.#prefixIdentity
+      );
       if (isEmpty) {
         this.#inner.delete(key);
       }
@@ -268,7 +304,7 @@ class Index {
     }
     const newPrefix = getPrefix(newValue);
     const currentPrefix = getPrefix(currentValue);
-    if (isSamePrefix(currentPrefix, newPrefix) && (currentValue === newValue || hash.hash(currentValue) === hash.hash(newValue))) {
+    if (isSamePrefix(currentPrefix, newPrefix) && (this.#prefixIdentity && newPrefix !== NO_PREFIX || hash.hash(currentValue) === hash.hash(newValue))) {
       const newMultiplicity = currentMultiplicity + multiplicity;
       if (newMultiplicity === 0) {
         this.#inner.delete(key);