@tanstack/db-ivm 0.1.17 → 0.1.18

package/dist/cjs/hashing/hash.cjs

@@ -13,6 +13,21 @@ const ARRAY_MARKER = murmur.randomHash();
 const MAP_MARKER = murmur.randomHash();
 const SET_MARKER = murmur.randomHash();
 const UINT8ARRAY_MARKER = murmur.randomHash();
+const TEMPORAL_MARKER = murmur.randomHash();
+const temporalTypes = /* @__PURE__ */ new Set([
+  `Temporal.Duration`,
+  `Temporal.Instant`,
+  `Temporal.PlainDate`,
+  `Temporal.PlainDateTime`,
+  `Temporal.PlainMonthDay`,
+  `Temporal.PlainTime`,
+  `Temporal.PlainYearMonth`,
+  `Temporal.ZonedDateTime`
+]);
+function isTemporal(input) {
+  const tag = input[Symbol.toStringTag];
+  return typeof tag === `string` && temporalTypes.has(tag);
+}
 const UINT8ARRAY_CONTENT_HASH_THRESHOLD = 128;
 const hashCache = /* @__PURE__ */ new WeakMap();
 function hash(input) {
@@ -39,6 +54,8 @@ function hashObject(input) {
     }
   } else if (input instanceof File) {
     return cachedReferenceHash(input);
+  } else if (isTemporal(input)) {
+    valueHash = hashTemporal(input);
   } else {
     let plainObjectInput = input;
     let marker = OBJECT_MARKER;
@@ -73,6 +90,13 @@ function hashUint8Array(input) {
   }
   return hasher.digest();
 }
+function hashTemporal(input) {
+  const hasher = new murmur.MurmurHashStream();
+  hasher.update(TEMPORAL_MARKER);
+  hasher.update(input[Symbol.toStringTag]);
+  hasher.update(input.toString());
+  return hasher.digest();
+}
 function hashPlainObject(input, marker) {
   const hasher = new murmur.MurmurHashStream();
   hasher.update(marker);

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

@@ -1 +1 @@
-{"version":3,"file":"hash.cjs","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, randomHash } from './murmur.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()\nconst DATE_MARKER = randomHash()\nconst OBJECT_MARKER = randomHash()\nconst ARRAY_MARKER = randomHash()\nconst MAP_MARKER = randomHash()\nconst SET_MARKER = randomHash()\nconst UINT8ARRAY_MARKER = randomHash()\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>()\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): number {\n  const cachedHash = hashCache.get(input)\n  if (cachedHash !== undefined) {\n    return cachedHash\n  }\n\n  let valueHash: number | undefined\n  if (input instanceof Date) {\n    valueHash = hashDate(input)\n  } else if (\n    // Check if input is a Uint8Array or Buffer\n    (typeof Buffer !== `undefined` && input instanceof Buffer) ||\n    input instanceof Uint8Array\n  ) {\n    // For small Uint8Arrays/Buffers (e.g., ULIDs, UUIDs), hash by content\n    // to enable proper equality comparisons. For large arrays, hash by reference\n    // to avoid performance costs.\n    if (input.byteLength <= UINT8ARRAY_CONTENT_HASH_THRESHOLD) {\n      valueHash = hashUint8Array(input)\n    } else {\n      // Deeply hashing large arrays would be too costly\n      // so we track them by reference and cache them in a weak map\n      return cachedReferenceHash(input)\n    }\n  } else if (input instanceof File) {\n    // Files are always hashed by reference due to their potentially large size\n    return cachedReferenceHash(input)\n  } else {\n    let plainObjectInput = input\n    let marker = OBJECT_MARKER\n\n    if (input instanceof Array) {\n      marker = ARRAY_MARKER\n    }\n\n    if (input instanceof Map) {\n      marker = MAP_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    if (input instanceof Set) {\n      marker = SET_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    valueHash = hashPlainObject(plainObjectInput, marker)\n  }\n\n  hashCache.set(input, valueHash)\n  return valueHash\n}\n\nfunction hashDate(input: Date): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(DATE_MARKER)\n  hasher.update(input.getTime())\n  return hasher.digest()\n}\n\nfunction hashUint8Array(input: Uint8Array): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(UINT8ARRAY_MARKER)\n  // Hash the byte length first to differentiate arrays of different sizes\n  hasher.update(input.byteLength)\n  // Hash each byte in the array\n  for (let i = 0; i < input.byteLength; i++) {\n    hasher.writeByte(input[i]!)\n  }\n  return hasher.digest()\n}\n\nfunction hashPlainObject(input: object, marker: number): number {\n  const hasher = new MurmurHashStream()\n\n  // Mark the type of the input\n  hasher.update(marker)\n  const keys = Object.keys(input)\n  keys.sort(keySort)\n  for (const key of keys) {\n    hasher.update(KEY)\n    hasher.update(key)\n    updateHasher(hasher, input[key as keyof typeof input])\n  }\n\n  return hasher.digest()\n}\n\nfunction updateHasher(hasher: Hasher, input: unknown): void {\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))\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      return\n    default:\n      console.warn(\n        `Ignored input during hashing because it is of type ${typeof input} which is not supported`,\n      )\n  }\n}\n\nfunction getCachedHash(input: object): number {\n  let valueHash = hashCache.get(input)\n  if (valueHash === undefined) {\n    valueHash = hashObject(input)\n  }\n  return valueHash\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  }\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"],"mappings":"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"}
+{"version":3,"file":"hash.cjs","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, randomHash } from './murmur.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()\nconst DATE_MARKER = randomHash()\nconst OBJECT_MARKER = randomHash()\nconst ARRAY_MARKER = randomHash()\nconst MAP_MARKER = randomHash()\nconst SET_MARKER = randomHash()\nconst UINT8ARRAY_MARKER = randomHash()\nconst TEMPORAL_MARKER = randomHash()\n\nconst temporalTypes = new Set([\n  `Temporal.Duration`,\n  `Temporal.Instant`,\n  `Temporal.PlainDate`,\n  `Temporal.PlainDateTime`,\n  `Temporal.PlainMonthDay`,\n  `Temporal.PlainTime`,\n  `Temporal.PlainYearMonth`,\n  `Temporal.ZonedDateTime`,\n])\n\ninterface TemporalLike {\n  [Symbol.toStringTag]: string\n  toString: () => string\n}\n\nfunction isTemporal(input: object): input is TemporalLike {\n  const tag = (input as Record<symbol, unknown>)[Symbol.toStringTag]\n  return typeof tag === `string` && temporalTypes.has(tag)\n}\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>()\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): number {\n  const cachedHash = hashCache.get(input)\n  if (cachedHash !== undefined) {\n    return cachedHash\n  }\n\n  let valueHash: number | undefined\n  if (input instanceof Date) {\n    valueHash = hashDate(input)\n  } else if (\n    // Check if input is a Uint8Array or Buffer\n    (typeof Buffer !== `undefined` && input instanceof Buffer) ||\n    input instanceof Uint8Array\n  ) {\n    // For small Uint8Arrays/Buffers (e.g., ULIDs, UUIDs), hash by content\n    // to enable proper equality comparisons. For large arrays, hash by reference\n    // to avoid performance costs.\n    if (input.byteLength <= UINT8ARRAY_CONTENT_HASH_THRESHOLD) {\n      valueHash = hashUint8Array(input)\n    } else {\n      // Deeply hashing large arrays would be too costly\n      // so we track them by reference and cache them in a weak map\n      return cachedReferenceHash(input)\n    }\n  } else if (input instanceof File) {\n    // Files are always hashed by reference due to their potentially large size\n    return cachedReferenceHash(input)\n  } else if (isTemporal(input)) {\n    valueHash = hashTemporal(input)\n  } else {\n    let plainObjectInput = input\n    let marker = OBJECT_MARKER\n\n    if (input instanceof Array) {\n      marker = ARRAY_MARKER\n    }\n\n    if (input instanceof Map) {\n      marker = MAP_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    if (input instanceof Set) {\n      marker = SET_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    valueHash = hashPlainObject(plainObjectInput, marker)\n  }\n\n  hashCache.set(input, valueHash)\n  return valueHash\n}\n\nfunction hashDate(input: Date): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(DATE_MARKER)\n  hasher.update(input.getTime())\n  return hasher.digest()\n}\n\nfunction hashUint8Array(input: Uint8Array): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(UINT8ARRAY_MARKER)\n  // Hash the byte length first to differentiate arrays of different sizes\n  hasher.update(input.byteLength)\n  // Hash each byte in the array\n  for (let i = 0; i < input.byteLength; i++) {\n    hasher.writeByte(input[i]!)\n  }\n  return hasher.digest()\n}\n\nfunction hashTemporal(input: TemporalLike): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(TEMPORAL_MARKER)\n  hasher.update(input[Symbol.toStringTag])\n  hasher.update(input.toString())\n  return hasher.digest()\n}\n\nfunction hashPlainObject(input: object, marker: number): number {\n  const hasher = new MurmurHashStream()\n\n  // Mark the type of the input\n  hasher.update(marker)\n  const keys = Object.keys(input)\n  keys.sort(keySort)\n  for (const key of keys) {\n    hasher.update(KEY)\n    hasher.update(key)\n    updateHasher(hasher, input[key as keyof typeof input])\n  }\n\n  return hasher.digest()\n}\n\nfunction updateHasher(hasher: Hasher, input: unknown): void {\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))\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      return\n    default:\n      console.warn(\n        `Ignored input during hashing because it is of type ${typeof input} which is not supported`,\n      )\n  }\n}\n\nfunction getCachedHash(input: object): number {\n  let valueHash = hashCache.get(input)\n  if (valueHash === undefined) {\n    valueHash = hashObject(input)\n  }\n  return valueHash\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  }\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"],"mappings":"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"}

package/dist/cjs/index.cjs

@@ -3,52 +3,47 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const d2 = require("./d2.cjs");
 const multiset = require("./multiset.cjs");
 const utils = require("./utils.cjs");
-const groupBy = require("./operators/groupBy.cjs");
-const pipe = require("./operators/pipe.cjs");
-const map = require("./operators/map.cjs");
-const tap = require("./operators/tap.cjs");
-const filter = require("./operators/filter.cjs");
-const negate = require("./operators/negate.cjs");
 const concat = require("./operators/concat.cjs");
-const debug = require("./operators/debug.cjs");
-const output = require("./operators/output.cjs");
 const consolidate = require("./operators/consolidate.cjs");
-const join = require("./operators/join.cjs");
-const reduce = require("./operators/reduce.cjs");
 const count = require("./operators/count.cjs");
+const debug = require("./operators/debug.cjs");
 const distinct = require("./operators/distinct.cjs");
-const keying = require("./operators/keying.cjs");
-const topK = require("./operators/topK.cjs");
-const topKWithFractionalIndex = require("./operators/topKWithFractionalIndex.cjs");
+const filter = require("./operators/filter.cjs");
 const groupedTopKWithFractionalIndex = require("./operators/groupedTopKWithFractionalIndex.cjs");
-const orderBy = require("./operators/orderBy.cjs");
-const groupedOrderBy = require("./operators/groupedOrderBy.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;
 exports.MultiSet = multiset.MultiSet;
 exports.compareKeys = utils.compareKeys;
 exports.serializeValue = utils.serializeValue;
-exports.groupBy = groupBy.groupBy;
-exports.groupByOperators = groupBy.groupByOperators;
-exports.pipe = pipe.pipe;
-exports.MapOperator = map.MapOperator;
-exports.map = map.map;
-exports.TapOperator = tap.TapOperator;
-exports.tap = tap.tap;
-exports.FilterOperator = filter.FilterOperator;
-exports.filter = filter.filter;
-exports.NegateOperator = negate.NegateOperator;
-exports.negate = negate.negate;
 exports.ConcatOperator = concat.ConcatOperator;
 exports.concat = concat.concat;
-exports.DebugOperator = debug.DebugOperator;
-exports.debug = debug.debug;
-exports.OutputOperator = output.OutputOperator;
-exports.output = output.output;
 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;
+exports.filter = filter.filter;
+exports.GroupedTopKWithFractionalIndexOperator = groupedTopKWithFractionalIndex.GroupedTopKWithFractionalIndexOperator;
+exports.groupedTopKWithFractionalIndex = groupedTopKWithFractionalIndex.groupedTopKWithFractionalIndex;
 exports.JoinOperator = join.JoinOperator;
 exports.antiJoin = join.antiJoin;
 exports.fullJoin = join.fullJoin;
@@ -56,25 +51,30 @@ 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;
 exports.reduce = reduce.reduce;
-exports.CountOperator = count.CountOperator;
-exports.count = count.count;
-exports.DistinctOperator = distinct.DistinctOperator;
-exports.distinct = distinct.distinct;
+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.topK = topK.topK;
-exports.topKWithIndex = topK.topKWithIndex;
-exports.TopKWithFractionalIndexOperator = topKWithFractionalIndex.TopKWithFractionalIndexOperator;
-exports.topKWithFractionalIndex = topKWithFractionalIndex.topKWithFractionalIndex;
-exports.GroupedTopKWithFractionalIndexOperator = groupedTopKWithFractionalIndex.GroupedTopKWithFractionalIndexOperator;
-exports.groupedTopKWithFractionalIndex = groupedTopKWithFractionalIndex.groupedTopKWithFractionalIndex;
 exports.orderBy = orderBy.orderBy;
 exports.orderByWithFractionalIndex = orderBy.orderByWithFractionalIndex;
 exports.orderByWithFractionalIndexBase = orderBy.orderByWithFractionalIndexBase;
 exports.orderByWithIndex = orderBy.orderByWithIndex;
-exports.groupedOrderByWithFractionalIndex = groupedOrderBy.groupedOrderByWithFractionalIndex;
-exports.filterBy = filterBy.filterBy;
+exports.pipe = pipe.pipe;
+exports.topK = topK.topK;
+exports.topKWithIndex = topK.topKWithIndex;
 //# sourceMappingURL=index.cjs.map

package/dist/esm/hashing/hash.js

@@ -11,6 +11,21 @@ const ARRAY_MARKER = randomHash();
 const MAP_MARKER = randomHash();
 const SET_MARKER = randomHash();
 const UINT8ARRAY_MARKER = randomHash();
+const TEMPORAL_MARKER = randomHash();
+const temporalTypes = /* @__PURE__ */ new Set([
+  `Temporal.Duration`,
+  `Temporal.Instant`,
+  `Temporal.PlainDate`,
+  `Temporal.PlainDateTime`,
+  `Temporal.PlainMonthDay`,
+  `Temporal.PlainTime`,
+  `Temporal.PlainYearMonth`,
+  `Temporal.ZonedDateTime`
+]);
+function isTemporal(input) {
+  const tag = input[Symbol.toStringTag];
+  return typeof tag === `string` && temporalTypes.has(tag);
+}
 const UINT8ARRAY_CONTENT_HASH_THRESHOLD = 128;
 const hashCache = /* @__PURE__ */ new WeakMap();
 function hash(input) {
@@ -37,6 +52,8 @@ function hashObject(input) {
     }
   } else if (input instanceof File) {
     return cachedReferenceHash(input);
+  } else if (isTemporal(input)) {
+    valueHash = hashTemporal(input);
   } else {
     let plainObjectInput = input;
     let marker = OBJECT_MARKER;
@@ -71,6 +88,13 @@ function hashUint8Array(input) {
   }
   return hasher.digest();
 }
+function hashTemporal(input) {
+  const hasher = new MurmurHashStream();
+  hasher.update(TEMPORAL_MARKER);
+  hasher.update(input[Symbol.toStringTag]);
+  hasher.update(input.toString());
+  return hasher.digest();
+}
 function hashPlainObject(input, marker) {
   const hasher = new MurmurHashStream();
   hasher.update(marker);

package/dist/esm/hashing/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, randomHash } from './murmur.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()\nconst DATE_MARKER = randomHash()\nconst OBJECT_MARKER = randomHash()\nconst ARRAY_MARKER = randomHash()\nconst MAP_MARKER = randomHash()\nconst SET_MARKER = randomHash()\nconst UINT8ARRAY_MARKER = randomHash()\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>()\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): number {\n  const cachedHash = hashCache.get(input)\n  if (cachedHash !== undefined) {\n    return cachedHash\n  }\n\n  let valueHash: number | undefined\n  if (input instanceof Date) {\n    valueHash = hashDate(input)\n  } else if (\n    // Check if input is a Uint8Array or Buffer\n    (typeof Buffer !== `undefined` && input instanceof Buffer) ||\n    input instanceof Uint8Array\n  ) {\n    // For small Uint8Arrays/Buffers (e.g., ULIDs, UUIDs), hash by content\n    // to enable proper equality comparisons. For large arrays, hash by reference\n    // to avoid performance costs.\n    if (input.byteLength <= UINT8ARRAY_CONTENT_HASH_THRESHOLD) {\n      valueHash = hashUint8Array(input)\n    } else {\n      // Deeply hashing large arrays would be too costly\n      // so we track them by reference and cache them in a weak map\n      return cachedReferenceHash(input)\n    }\n  } else if (input instanceof File) {\n    // Files are always hashed by reference due to their potentially large size\n    return cachedReferenceHash(input)\n  } else {\n    let plainObjectInput = input\n    let marker = OBJECT_MARKER\n\n    if (input instanceof Array) {\n      marker = ARRAY_MARKER\n    }\n\n    if (input instanceof Map) {\n      marker = MAP_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    if (input instanceof Set) {\n      marker = SET_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    valueHash = hashPlainObject(plainObjectInput, marker)\n  }\n\n  hashCache.set(input, valueHash)\n  return valueHash\n}\n\nfunction hashDate(input: Date): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(DATE_MARKER)\n  hasher.update(input.getTime())\n  return hasher.digest()\n}\n\nfunction hashUint8Array(input: Uint8Array): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(UINT8ARRAY_MARKER)\n  // Hash the byte length first to differentiate arrays of different sizes\n  hasher.update(input.byteLength)\n  // Hash each byte in the array\n  for (let i = 0; i < input.byteLength; i++) {\n    hasher.writeByte(input[i]!)\n  }\n  return hasher.digest()\n}\n\nfunction hashPlainObject(input: object, marker: number): number {\n  const hasher = new MurmurHashStream()\n\n  // Mark the type of the input\n  hasher.update(marker)\n  const keys = Object.keys(input)\n  keys.sort(keySort)\n  for (const key of keys) {\n    hasher.update(KEY)\n    hasher.update(key)\n    updateHasher(hasher, input[key as keyof typeof input])\n  }\n\n  return hasher.digest()\n}\n\nfunction updateHasher(hasher: Hasher, input: unknown): void {\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))\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      return\n    default:\n      console.warn(\n        `Ignored input during hashing because it is of type ${typeof input} which is not supported`,\n      )\n  }\n}\n\nfunction getCachedHash(input: object): number {\n  let valueHash = hashCache.get(input)\n  if (valueHash === undefined) {\n    valueHash = hashObject(input)\n  }\n  return valueHash\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  }\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":[],"mappings":"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"}
+{"version":3,"file":"hash.js","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, randomHash } from './murmur.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()\nconst DATE_MARKER = randomHash()\nconst OBJECT_MARKER = randomHash()\nconst ARRAY_MARKER = randomHash()\nconst MAP_MARKER = randomHash()\nconst SET_MARKER = randomHash()\nconst UINT8ARRAY_MARKER = randomHash()\nconst TEMPORAL_MARKER = randomHash()\n\nconst temporalTypes = new Set([\n  `Temporal.Duration`,\n  `Temporal.Instant`,\n  `Temporal.PlainDate`,\n  `Temporal.PlainDateTime`,\n  `Temporal.PlainMonthDay`,\n  `Temporal.PlainTime`,\n  `Temporal.PlainYearMonth`,\n  `Temporal.ZonedDateTime`,\n])\n\ninterface TemporalLike {\n  [Symbol.toStringTag]: string\n  toString: () => string\n}\n\nfunction isTemporal(input: object): input is TemporalLike {\n  const tag = (input as Record<symbol, unknown>)[Symbol.toStringTag]\n  return typeof tag === `string` && temporalTypes.has(tag)\n}\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>()\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): number {\n  const cachedHash = hashCache.get(input)\n  if (cachedHash !== undefined) {\n    return cachedHash\n  }\n\n  let valueHash: number | undefined\n  if (input instanceof Date) {\n    valueHash = hashDate(input)\n  } else if (\n    // Check if input is a Uint8Array or Buffer\n    (typeof Buffer !== `undefined` && input instanceof Buffer) ||\n    input instanceof Uint8Array\n  ) {\n    // For small Uint8Arrays/Buffers (e.g., ULIDs, UUIDs), hash by content\n    // to enable proper equality comparisons. For large arrays, hash by reference\n    // to avoid performance costs.\n    if (input.byteLength <= UINT8ARRAY_CONTENT_HASH_THRESHOLD) {\n      valueHash = hashUint8Array(input)\n    } else {\n      // Deeply hashing large arrays would be too costly\n      // so we track them by reference and cache them in a weak map\n      return cachedReferenceHash(input)\n    }\n  } else if (input instanceof File) {\n    // Files are always hashed by reference due to their potentially large size\n    return cachedReferenceHash(input)\n  } else if (isTemporal(input)) {\n    valueHash = hashTemporal(input)\n  } else {\n    let plainObjectInput = input\n    let marker = OBJECT_MARKER\n\n    if (input instanceof Array) {\n      marker = ARRAY_MARKER\n    }\n\n    if (input instanceof Map) {\n      marker = MAP_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    if (input instanceof Set) {\n      marker = SET_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    valueHash = hashPlainObject(plainObjectInput, marker)\n  }\n\n  hashCache.set(input, valueHash)\n  return valueHash\n}\n\nfunction hashDate(input: Date): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(DATE_MARKER)\n  hasher.update(input.getTime())\n  return hasher.digest()\n}\n\nfunction hashUint8Array(input: Uint8Array): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(UINT8ARRAY_MARKER)\n  // Hash the byte length first to differentiate arrays of different sizes\n  hasher.update(input.byteLength)\n  // Hash each byte in the array\n  for (let i = 0; i < input.byteLength; i++) {\n    hasher.writeByte(input[i]!)\n  }\n  return hasher.digest()\n}\n\nfunction hashTemporal(input: TemporalLike): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(TEMPORAL_MARKER)\n  hasher.update(input[Symbol.toStringTag])\n  hasher.update(input.toString())\n  return hasher.digest()\n}\n\nfunction hashPlainObject(input: object, marker: number): number {\n  const hasher = new MurmurHashStream()\n\n  // Mark the type of the input\n  hasher.update(marker)\n  const keys = Object.keys(input)\n  keys.sort(keySort)\n  for (const key of keys) {\n    hasher.update(KEY)\n    hasher.update(key)\n    updateHasher(hasher, input[key as keyof typeof input])\n  }\n\n  return hasher.digest()\n}\n\nfunction updateHasher(hasher: Hasher, input: unknown): void {\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))\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      return\n    default:\n      console.warn(\n        `Ignored input during hashing because it is of type ${typeof input} which is not supported`,\n      )\n  }\n}\n\nfunction getCachedHash(input: object): number {\n  let valueHash = hashCache.get(input)\n  if (valueHash === undefined) {\n    valueHash = hashObject(input)\n  }\n  return valueHash\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  }\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":[],"mappings":"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"}

package/dist/esm/index.js

@@ -1,27 +1,27 @@
 import { D2, RootStreamBuilder, StreamBuilder } from "./d2.js";
 import { MultiSet } from "./multiset.js";
 import { compareKeys, serializeValue } from "./utils.js";
-import { groupBy, groupByOperators } from "./operators/groupBy.js";
-import { pipe } from "./operators/pipe.js";
-import { MapOperator, map } from "./operators/map.js";
-import { TapOperator, tap } from "./operators/tap.js";
-import { FilterOperator, filter } from "./operators/filter.js";
-import { NegateOperator, negate } from "./operators/negate.js";
 import { ConcatOperator, concat } from "./operators/concat.js";
-import { DebugOperator, debug } from "./operators/debug.js";
-import { OutputOperator, output } from "./operators/output.js";
 import { ConsolidateOperator, consolidate } from "./operators/consolidate.js";
-import { JoinOperator, antiJoin, fullJoin, innerJoin, join, leftJoin, rightJoin } from "./operators/join.js";
-import { ReduceOperator, reduce } from "./operators/reduce.js";
 import { CountOperator, count } from "./operators/count.js";
+import { DebugOperator, debug } from "./operators/debug.js";
 import { DistinctOperator, distinct } from "./operators/distinct.js";
-import { keyBy, rekey, unkey } from "./operators/keying.js";
-import { topK, topKWithIndex } from "./operators/topK.js";
-import { TopKWithFractionalIndexOperator, topKWithFractionalIndex } from "./operators/topKWithFractionalIndex.js";
+import { FilterOperator, filter } from "./operators/filter.js";
 import { GroupedTopKWithFractionalIndexOperator, groupedTopKWithFractionalIndex } from "./operators/groupedTopKWithFractionalIndex.js";
-import { orderBy, orderByWithFractionalIndex, orderByWithFractionalIndexBase, orderByWithIndex } from "./operators/orderBy.js";
-import { groupedOrderByWithFractionalIndex } from "./operators/groupedOrderBy.js";
+import { JoinOperator, antiJoin, fullJoin, innerJoin, join, leftJoin, rightJoin } from "./operators/join.js";
+import { MapOperator, map } from "./operators/map.js";
+import { NegateOperator, negate } from "./operators/negate.js";
+import { OutputOperator, output } from "./operators/output.js";
+import { ReduceOperator, reduce } from "./operators/reduce.js";
+import { TapOperator, tap } from "./operators/tap.js";
+import { TopKWithFractionalIndexOperator, topKWithFractionalIndex } from "./operators/topKWithFractionalIndex.js";
 import { filterBy } from "./operators/filterBy.js";
+import { groupBy, groupByOperators } from "./operators/groupBy.js";
+import { groupedOrderByWithFractionalIndex } from "./operators/groupedOrderBy.js";
+import { keyBy, rekey, unkey } from "./operators/keying.js";
+import { orderBy, orderByWithFractionalIndex, orderByWithFractionalIndexBase, orderByWithIndex } from "./operators/orderBy.js";
+import { pipe } from "./operators/pipe.js";
+import { topK, topKWithIndex } from "./operators/topK.js";
 export {
   ConcatOperator,
   ConsolidateOperator,

package/dist/esm/operators/topKArray.js

@@ -1,5 +1,5 @@
 import { generateKeyBetween } from "fractional-indexing";
-import { compareKeys, diffHalfOpen, binarySearch } from "../utils.js";
+import { compareKeys, binarySearch, diffHalfOpen } from "../utils.js";
 function indexedValue(value, index) {
   return [value, index];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/db-ivm",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "Incremental View Maintenance for TanStack DB based on Differential Dataflow",
   "author": "Sam Willis",
   "license": "MIT",
@@ -49,7 +49,8 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "@vitest/coverage-istanbul": "^3.2.4"
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "temporal-polyfill": "^0.3.0"
   },
   "scripts": {
     "build": "vite build",

package/src/hashing/hash.ts

@@ -18,6 +18,28 @@ const ARRAY_MARKER = randomHash()
 const MAP_MARKER = randomHash()
 const SET_MARKER = randomHash()
 const UINT8ARRAY_MARKER = randomHash()
+const TEMPORAL_MARKER = randomHash()
+
+const temporalTypes = new Set([
+  `Temporal.Duration`,
+  `Temporal.Instant`,
+  `Temporal.PlainDate`,
+  `Temporal.PlainDateTime`,
+  `Temporal.PlainMonthDay`,
+  `Temporal.PlainTime`,
+  `Temporal.PlainYearMonth`,
+  `Temporal.ZonedDateTime`,
+])
+
+interface TemporalLike {
+  [Symbol.toStringTag]: string
+  toString: () => string
+}
+
+function isTemporal(input: object): input is TemporalLike {
+  const tag = (input as Record<symbol, unknown>)[Symbol.toStringTag]
+  return typeof tag === `string` && temporalTypes.has(tag)
+}
 
 // Maximum byte length for Uint8Arrays to hash by content instead of reference
 // Arrays smaller than this will be hashed by content, allowing proper equality comparisons
@@ -59,6 +81,8 @@ function hashObject(input: object): number {
   } else if (input instanceof File) {
     // Files are always hashed by reference due to their potentially large size
     return cachedReferenceHash(input)
+  } else if (isTemporal(input)) {
+    valueHash = hashTemporal(input)
   } else {
     let plainObjectInput = input
     let marker = OBJECT_MARKER
@@ -103,6 +127,14 @@ function hashUint8Array(input: Uint8Array): number {
   return hasher.digest()
 }
 
+function hashTemporal(input: TemporalLike): number {
+  const hasher = new MurmurHashStream()
+  hasher.update(TEMPORAL_MARKER)
+  hasher.update(input[Symbol.toStringTag])
+  hasher.update(input.toString())
+  return hasher.digest()
+}
+
 function hashPlainObject(input: object, marker: number): number {
   const hasher = new MurmurHashStream()