fix(db, db-ivm): support Temporal objects in join hashing and normalization

Temporal objects have no enumerable properties, so hashPlainObject()
produced identical hashes for all Temporal values. This caused join
index updates to be silently swallowed when a Temporal field changed.

- Add Temporal-aware hashing via Symbol.toStringTag + toString()
- Add Temporal normalization in normalizeValue() for join key matching
- Add Temporal handling in ascComparator for correct sort ordering
- Add null guard to exported isTemporal()
- Convert temporalTypes from Array to Set for consistency

Fixes #1367

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: KyleAMathews

.changeset/fix-temporal-join-hashing.md

@@ -0,0 +1,6 @@
+---
+'@tanstack/db': patch
+'@tanstack/db-ivm': patch
+---
+
+Fix Temporal objects breaking live query updates when used with joins. Temporal objects (e.g. `Temporal.PlainDate`) have no enumerable properties, so the structural hash function produced identical hashes for all Temporal values, causing join index updates to be silently swallowed. Also add Temporal support to value normalization for join key matching and to the comparator for correct sort ordering.

packages/db-ivm/src/hashing/hash.ts

@@ -18,6 +18,23 @@ 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`,
+])
+
+function isTemporal(input: object): boolean {
+  const tag = (input as any)[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 +76,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 +122,14 @@ function hashUint8Array(input: Uint8Array): number {
   return hasher.digest()
 }
 
+function hashTemporal(input: object): number {
+  const hasher = new MurmurHashStream()
+  hasher.update(TEMPORAL_MARKER)
+  hasher.update((input as any)[Symbol.toStringTag])
+  hasher.update((input as any).toString())
+  return hasher.digest()
+}
+
 function hashPlainObject(input: object, marker: number): number {
   const hasher = new MurmurHashStream()
 

packages/db/src/utils.ts

@@ -144,8 +144,8 @@ function deepEqualsInternal(
   // Handle Temporal objects
   // Check if both are Temporal objects of the same type
   if (isTemporal(a) && isTemporal(b)) {
-    const aTag = getStringTag(a)
-    const bTag = getStringTag(b)
+    const aTag = a[Symbol.toStringTag]
+    const bTag = b[Symbol.toStringTag]
 
     // If they're different Temporal types, they're not equal
     if (aTag !== bTag) return false
@@ -211,7 +211,7 @@ function deepEqualsInternal(
   return false
 }
 
-const temporalTypes = [
+const temporalTypes = new Set([
   `Temporal.Duration`,
   `Temporal.Instant`,
   `Temporal.PlainDate`,
@@ -220,16 +220,13 @@ const temporalTypes = [
   `Temporal.PlainTime`,
   `Temporal.PlainYearMonth`,
   `Temporal.ZonedDateTime`,
-]
-
-function getStringTag(a: any): any {
-  return a[Symbol.toStringTag]
-}
+])
 
 /** Checks if the value is a Temporal object by checking for the Temporal brand */
 export function isTemporal(a: any): boolean {
-  const tag = getStringTag(a)
-  return typeof tag === `string` && temporalTypes.includes(tag)
+  if (a == null || typeof a !== `object`) return false
+  const tag = a[Symbol.toStringTag]
+  return typeof tag === `string` && temporalTypes.has(tag)
 }
 
 export const DEFAULT_COMPARE_OPTIONS: CompareOptions = {

packages/db/src/utils/comparison.ts

@@ -1,3 +1,4 @@
+import { isTemporal } from '../utils'
 import type { CompareOptions } from '../query/builder/types'
 
 // WeakMap to store stable IDs for objects
@@ -54,6 +55,15 @@ export const ascComparator = (a: any, b: any, opts: CompareOptions): number => {
     return a.getTime() - b.getTime()
   }
 
+  // If both are Temporal objects of the same type, compare by string representation
+  if (isTemporal(a) && isTemporal(b)) {
+    const aStr = a.toString()
+    const bStr = b.toString()
+    if (aStr < bStr) return -1
+    if (aStr > bStr) return 1
+    return 0
+  }
+
   // If at least one of the values is an object, use stable IDs for comparison
   const aIsObject = typeof a === `object`
   const bIsObject = typeof b === `object`
@@ -154,6 +164,10 @@ export function normalizeValue(value: any): any {
     return value.getTime()
   }
 
+  if (isTemporal(value)) {
+    return `__temporal__${value[Symbol.toStringTag]}__${value.toString()}`
+  }
+
   // Normalize Uint8Arrays/Buffers to a string representation for Map key usage
   // This enables content-based equality for binary data like ULIDs
   const isUint8Array =