@tldraw/store 4.2.0-next.47462e908ff5 → 4.2.0-next.54bc357bbff2

package/dist-esm/lib/executeQuery.mjs

@@ -1,44 +1,68 @@
 import { intersectSets } from "./setUtils.mjs";
+function isQueryValueMatcher(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "eq" in value || "neq" in value || "gt" in value;
+}
+function extractMatcherPaths(query, prefix = "") {
+  const paths = [];
+  for (const [key, value] of Object.entries(query)) {
+    const currentPath = prefix ? `${prefix}\\${key}` : key;
+    if (isQueryValueMatcher(value)) {
+      paths.push({ path: currentPath, matcher: value });
+    } else if (typeof value === "object" && value !== null) {
+      paths.push(...extractMatcherPaths(value, currentPath));
+    }
+  }
+  return paths;
+}
 function objectMatchesQuery(query, object) {
-  for (const [key, _matcher] of Object.entries(query)) {
-    const matcher = _matcher;
+  for (const [key, matcher] of Object.entries(query)) {
     const value = object[key];
-    if ("eq" in matcher && value !== matcher.eq) return false;
-    if ("neq" in matcher && value === matcher.neq) return false;
-    if ("gt" in matcher && (typeof value !== "number" || value <= matcher.gt)) return false;
+    if (isQueryValueMatcher(matcher)) {
+      if ("eq" in matcher && value !== matcher.eq) return false;
+      if ("neq" in matcher && value === matcher.neq) return false;
+      if ("gt" in matcher && (typeof value !== "number" || value <= matcher.gt)) return false;
+      continue;
+    }
+    if (typeof value !== "object" || value === null) return false;
+    if (!objectMatchesQuery(matcher, value)) {
+      return false;
+    }
   }
   return true;
 }
 function executeQuery(store, typeName, query) {
-  const matchIds = Object.fromEntries(Object.keys(query).map((key) => [key, /* @__PURE__ */ new Set()]));
-  for (const [k, matcher] of Object.entries(query)) {
+  const matcherPaths = extractMatcherPaths(query);
+  const matchIds = Object.fromEntries(matcherPaths.map(({ path }) => [path, /* @__PURE__ */ new Set()]));
+  for (const { path, matcher } of matcherPaths) {
+    const index = store.index(typeName, path);
     if ("eq" in matcher) {
-      const index = store.index(typeName, k);
       const ids = index.get().get(matcher.eq);
       if (ids) {
         for (const id of ids) {
-          matchIds[k].add(id);
+          matchIds[path].add(id);
         }
       }
     } else if ("neq" in matcher) {
-      const index = store.index(typeName, k);
       for (const [value, ids] of index.get()) {
         if (value !== matcher.neq) {
           for (const id of ids) {
-            matchIds[k].add(id);
+            matchIds[path].add(id);
           }
         }
       }
     } else if ("gt" in matcher) {
-      const index = store.index(typeName, k);
       for (const [value, ids] of index.get()) {
-        if (value > matcher.gt) {
+        if (typeof value === "number" && value > matcher.gt) {
           for (const id of ids) {
-            matchIds[k].add(id);
+            matchIds[path].add(id);
           }
         }
       }
     }
+    if (matchIds[path].size === 0) {
+      return /* @__PURE__ */ new Set();
+    }
   }
   return intersectSets(Object.values(matchIds));
 }

package/dist-esm/lib/executeQuery.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/executeQuery.ts"],
-  "sourcesContent": ["import { IdOf, UnknownRecord } from './BaseRecord'\nimport { intersectSets } from './setUtils'\nimport { StoreQueries } from './StoreQueries'\n\n/**\n * Defines matching criteria for query values. Supports equality, inequality, and greater-than comparisons.\n *\n * @example\n * ```ts\n * // Exact match\n * const exactMatch: QueryValueMatcher<string> = { eq: 'Science Fiction' }\n *\n * // Not equal to\n * const notMatch: QueryValueMatcher<string> = { neq: 'Romance' }\n *\n * // Greater than (numeric values only)\n * const greaterThan: QueryValueMatcher<number> = { gt: 2020 }\n * ```\n *\n * @public\n */\nexport type QueryValueMatcher<T> = { eq: T } | { neq: T } | { gt: number }\n\n/**\n * Query expression for filtering records by their property values. Maps record property names\n * to matching criteria.\n *\n * @example\n * ```ts\n * // Query for books published after 2020 that are in stock\n * const bookQuery: QueryExpression<Book> = {\n *   publishedYear: { gt: 2020 },\n *   inStock: { eq: true }\n * }\n *\n * // Query for books not by a specific author\n * const notByAuthor: QueryExpression<Book> = {\n *   authorId: { neq: 'author:tolkien' }\n * }\n * ```\n *\n * @public\n */\nexport type QueryExpression<R extends object> = {\n\t[k in keyof R & string]?: QueryValueMatcher<R[k]>\n\t// todo: handle nesting\n\t// | (R[k] extends object ? { match: QueryExpression<R[k]> } : never)\n}\n\n/**\n * Tests whether an object matches the given query expression by checking each property\n * against its corresponding matcher criteria.\n *\n * @param query - The query expression containing matching criteria for object properties\n * @param object - The object to test against the query\n * @returns True if the object matches all criteria in the query, false otherwise\n *\n * @example\n * ```ts\n * const book = { title: '1984', publishedYear: 1949, inStock: true }\n * const query = { publishedYear: { gt: 1945 }, inStock: { eq: true } }\n *\n * const matches = objectMatchesQuery(query, book) // true\n * ```\n *\n * @public\n */\nexport function objectMatchesQuery<T extends object>(query: QueryExpression<T>, object: T) {\n\tfor (const [key, _matcher] of Object.entries(query)) {\n\t\tconst matcher = _matcher as QueryValueMatcher<T>\n\t\tconst value = object[key as keyof T]\n\t\t// if you add matching logic here, make sure you also update executeQuery,\n\t\t// where initial data is pulled out of the indexes, since that requires different\n\t\t// matching logic\n\t\tif ('eq' in matcher && value !== matcher.eq) return false\n\t\tif ('neq' in matcher && value === matcher.neq) return false\n\t\tif ('gt' in matcher && (typeof value !== 'number' || value <= matcher.gt)) return false\n\t}\n\treturn true\n}\n\n/**\n * Executes a query against the store using reactive indexes to efficiently find matching record IDs.\n * Uses the store's internal indexes for optimal performance, especially for equality matches.\n *\n * @param store - The store queries interface providing access to reactive indexes\n * @param typeName - The type name of records to query (e.g., 'book', 'author')\n * @param query - Query expression defining the matching criteria\n * @returns A Set containing the IDs of all records that match the query criteria\n *\n * @example\n * ```ts\n * // Find IDs of all books published after 2020 that are in stock\n * const bookIds = executeQuery(store, 'book', {\n *   publishedYear: { gt: 2020 },\n *   inStock: { eq: true }\n * })\n *\n * // Find IDs of books not by a specific author\n * const otherBookIds = executeQuery(store, 'book', {\n *   authorId: { neq: 'author:tolkien' }\n * })\n * ```\n *\n * @public\n */\nexport function executeQuery<R extends UnknownRecord, TypeName extends R['typeName']>(\n\tstore: StoreQueries<R>,\n\ttypeName: TypeName,\n\tquery: QueryExpression<Extract<R, { typeName: TypeName }>>\n): Set<IdOf<Extract<R, { typeName: TypeName }>>> {\n\tconst matchIds = Object.fromEntries(Object.keys(query).map((key) => [key, new Set()]))\n\n\tfor (const [k, matcher] of Object.entries(query)) {\n\t\tif ('eq' in matcher) {\n\t\t\tconst index = store.index(typeName, k as any)\n\t\t\tconst ids = index.get().get(matcher.eq)\n\t\t\tif (ids) {\n\t\t\t\tfor (const id of ids) {\n\t\t\t\t\tmatchIds[k].add(id)\n\t\t\t\t}\n\t\t\t}\n\t\t} else if ('neq' in matcher) {\n\t\t\tconst index = store.index(typeName, k as any)\n\t\t\tfor (const [value, ids] of index.get()) {\n\t\t\t\tif (value !== matcher.neq) {\n\t\t\t\t\tfor (const id of ids) {\n\t\t\t\t\t\tmatchIds[k].add(id)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else if ('gt' in matcher) {\n\t\t\tconst index = store.index(typeName, k as any)\n\t\t\tfor (const [value, ids] of index.get()) {\n\t\t\t\tif (value > matcher.gt) {\n\t\t\t\t\tfor (const id of ids) {\n\t\t\t\t\t\tmatchIds[k].add(id)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn intersectSets(Object.values(matchIds)) as Set<IdOf<Extract<R, { typeName: TypeName }>>>\n}\n"],
-  "mappings": "AACA,SAAS,qBAAqB;AAkEvB,SAAS,mBAAqC,OAA2B,QAAW;AAC1F,aAAW,CAAC,KAAK,QAAQ,KAAK,OAAO,QAAQ,KAAK,GAAG;AACpD,UAAM,UAAU;AAChB,UAAM,QAAQ,OAAO,GAAc;AAInC,QAAI,QAAQ,WAAW,UAAU,QAAQ,GAAI,QAAO;AACpD,QAAI,SAAS,WAAW,UAAU,QAAQ,IAAK,QAAO;AACtD,QAAI,QAAQ,YAAY,OAAO,UAAU,YAAY,SAAS,QAAQ,IAAK,QAAO;AAAA,EACnF;AACA,SAAO;AACR;AA2BO,SAAS,aACf,OACA,UACA,OACgD;AAChD,QAAM,WAAW,OAAO,YAAY,OAAO,KAAK,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,oBAAI,IAAI,CAAC,CAAC,CAAC;AAErF,aAAW,CAAC,GAAG,OAAO,KAAK,OAAO,QAAQ,KAAK,GAAG;AACjD,QAAI,QAAQ,SAAS;AACpB,YAAM,QAAQ,MAAM,MAAM,UAAU,CAAQ;AAC5C,YAAM,MAAM,MAAM,IAAI,EAAE,IAAI,QAAQ,EAAE;AACtC,UAAI,KAAK;AACR,mBAAW,MAAM,KAAK;AACrB,mBAAS,CAAC,EAAE,IAAI,EAAE;AAAA,QACnB;AAAA,MACD;AAAA,IACD,WAAW,SAAS,SAAS;AAC5B,YAAM,QAAQ,MAAM,MAAM,UAAU,CAAQ;AAC5C,iBAAW,CAAC,OAAO,GAAG,KAAK,MAAM,IAAI,GAAG;AACvC,YAAI,UAAU,QAAQ,KAAK;AAC1B,qBAAW,MAAM,KAAK;AACrB,qBAAS,CAAC,EAAE,IAAI,EAAE;AAAA,UACnB;AAAA,QACD;AAAA,MACD;AAAA,IACD,WAAW,QAAQ,SAAS;AAC3B,YAAM,QAAQ,MAAM,MAAM,UAAU,CAAQ;AAC5C,iBAAW,CAAC,OAAO,GAAG,KAAK,MAAM,IAAI,GAAG;AACvC,YAAI,QAAQ,QAAQ,IAAI;AACvB,qBAAW,MAAM,KAAK;AACrB,qBAAS,CAAC,EAAE,IAAI,EAAE;AAAA,UACnB;AAAA,QACD;AAAA,MACD;AAAA,IACD;AAAA,EACD;AAEA,SAAO,cAAc,OAAO,OAAO,QAAQ,CAAC;AAC7C;",
+  "sourcesContent": ["import { IdOf, UnknownRecord } from './BaseRecord'\nimport { intersectSets } from './setUtils'\nimport { StoreQueries } from './StoreQueries'\n\n/**\n * Defines matching criteria for query values. Supports equality, inequality, and greater-than comparisons.\n *\n * @example\n * ```ts\n * // Exact match\n * const exactMatch: QueryValueMatcher<string> = { eq: 'Science Fiction' }\n *\n * // Not equal to\n * const notMatch: QueryValueMatcher<string> = { neq: 'Romance' }\n *\n * // Greater than (numeric values only)\n * const greaterThan: QueryValueMatcher<number> = { gt: 2020 }\n * ```\n *\n * @public\n */\nexport type QueryValueMatcher<T> = { eq: T } | { neq: T } | { gt: number }\n\n/**\n * Query expression for filtering records by their property values. Maps record property names\n * to matching criteria.\n *\n * @example\n * ```ts\n * // Query for books published after 2020 that are in stock\n * const bookQuery: QueryExpression<Book> = {\n *   publishedYear: { gt: 2020 },\n *   inStock: { eq: true }\n * }\n *\n * // Query for books not by a specific author\n * const notByAuthor: QueryExpression<Book> = {\n *   authorId: { neq: 'author:tolkien' }\n * }\n *\n * // Query with nested properties\n * const nestedQuery: QueryExpression<Book> = {\n *   metadata: { sessionId: { eq: 'session:alpha' } }\n * }\n * ```\n *\n * @public\n */\n/** @public */\nexport type QueryExpression<R extends object> = {\n\t[k in keyof R & string]?: R[k] extends string | number | boolean | null | undefined\n\t\t? QueryValueMatcher<R[k]>\n\t\t: R[k] extends object\n\t\t\t? QueryExpression<R[k]>\n\t\t\t: QueryValueMatcher<R[k]>\n}\n\nfunction isQueryValueMatcher(value: unknown): value is QueryValueMatcher<unknown> {\n\tif (typeof value !== 'object' || value === null) return false\n\treturn 'eq' in value || 'neq' in value || 'gt' in value\n}\n\nfunction extractMatcherPaths(\n\tquery: QueryExpression<any>,\n\tprefix: string = ''\n): Array<{ path: string; matcher: QueryValueMatcher<any> }> {\n\tconst paths: Array<{ path: string; matcher: QueryValueMatcher<any> }> = []\n\n\tfor (const [key, value] of Object.entries(query)) {\n\t\tconst currentPath = prefix ? `${prefix}\\\\${key}` : key\n\n\t\tif (isQueryValueMatcher(value)) {\n\t\t\t// It's a direct matcher\n\t\t\tpaths.push({ path: currentPath, matcher: value })\n\t\t} else if (typeof value === 'object' && value !== null) {\n\t\t\t// It's a nested query - recurse into it\n\t\t\tpaths.push(...extractMatcherPaths(value as QueryExpression<any>, currentPath))\n\t\t}\n\t}\n\n\treturn paths\n}\n\nexport function objectMatchesQuery<T extends object>(query: QueryExpression<T>, object: T) {\n\tfor (const [key, matcher] of Object.entries(query)) {\n\t\tconst value = object[key as keyof T]\n\n\t\t// if you add matching logic here, make sure you also update executeQuery,\n\t\t// where initial data is pulled out of the indexes, since that requires different\n\t\t// matching logic\n\t\tif (isQueryValueMatcher(matcher)) {\n\t\t\tif ('eq' in matcher && value !== matcher.eq) return false\n\t\t\tif ('neq' in matcher && value === matcher.neq) return false\n\t\t\tif ('gt' in matcher && (typeof value !== 'number' || value <= matcher.gt)) return false\n\t\t\tcontinue\n\t\t}\n\n\t\t// It's a nested query\n\t\tif (typeof value !== 'object' || value === null) return false\n\t\tif (!objectMatchesQuery(matcher as QueryExpression<any>, value as any)) {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n/**\n * Executes a query against the store using reactive indexes to efficiently find matching record IDs.\n * Uses the store's internal indexes for optimal performance, especially for equality matches.\n *\n * @param store - The store queries interface providing access to reactive indexes\n * @param typeName - The type name of records to query (e.g., 'book', 'author')\n * @param query - Query expression defining the matching criteria\n * @returns A Set containing the IDs of all records that match the query criteria\n *\n * @example\n * ```ts\n * // Find IDs of all books published after 2020 that are in stock\n * const bookIds = executeQuery(store, 'book', {\n *   publishedYear: { gt: 2020 },\n *   inStock: { eq: true }\n * })\n *\n * // Find IDs of books not by a specific author\n * const otherBookIds = executeQuery(store, 'book', {\n *   authorId: { neq: 'author:tolkien' }\n * })\n *\n * // Query with nested properties\n * const nestedQueryIds = executeQuery(store, 'book', {\n *   metadata: { sessionId: { eq: 'session:alpha' } }\n * })\n * ```\n *\n * @public\n */\nexport function executeQuery<R extends UnknownRecord, TypeName extends R['typeName']>(\n\tstore: StoreQueries<R>,\n\ttypeName: TypeName,\n\tquery: QueryExpression<Extract<R, { typeName: TypeName }>>\n): Set<IdOf<Extract<R, { typeName: TypeName }>>> {\n\ttype S = Extract<R, { typeName: TypeName }>\n\n\t// Extract all paths with matchers (flattens nested queries)\n\tconst matcherPaths = extractMatcherPaths(query)\n\n\t// Build a set of matching IDs for each path\n\tconst matchIds = Object.fromEntries(matcherPaths.map(({ path }) => [path, new Set<IdOf<S>>()]))\n\n\t// For each path, use the index to find matching IDs\n\tfor (const { path, matcher } of matcherPaths) {\n\t\tconst index = store.index(typeName, path as any)\n\n\t\tif ('eq' in matcher) {\n\t\t\tconst ids = index.get().get(matcher.eq)\n\t\t\tif (ids) {\n\t\t\t\tfor (const id of ids) {\n\t\t\t\t\tmatchIds[path].add(id)\n\t\t\t\t}\n\t\t\t}\n\t\t} else if ('neq' in matcher) {\n\t\t\tfor (const [value, ids] of index.get()) {\n\t\t\t\tif (value !== matcher.neq) {\n\t\t\t\t\tfor (const id of ids) {\n\t\t\t\t\t\tmatchIds[path].add(id)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else if ('gt' in matcher) {\n\t\t\tfor (const [value, ids] of index.get()) {\n\t\t\t\tif (typeof value === 'number' && value > matcher.gt) {\n\t\t\t\t\tfor (const id of ids) {\n\t\t\t\t\t\tmatchIds[path].add(id)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Short-circuit if this set is empty - intersection will be empty\n\t\tif (matchIds[path].size === 0) {\n\t\t\treturn new Set()\n\t\t}\n\t}\n\n\t// Intersect all the match sets\n\treturn intersectSets(Object.values(matchIds)) as Set<IdOf<S>>\n}\n"],
+  "mappings": "AACA,SAAS,qBAAqB;AAwD9B,SAAS,oBAAoB,OAAqD;AACjF,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,SAAO,QAAQ,SAAS,SAAS,SAAS,QAAQ;AACnD;AAEA,SAAS,oBACR,OACA,SAAiB,IAC0C;AAC3D,QAAM,QAAkE,CAAC;AAEzE,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAK,GAAG;AACjD,UAAM,cAAc,SAAS,GAAG,MAAM,KAAK,GAAG,KAAK;AAEnD,QAAI,oBAAoB,KAAK,GAAG;AAE/B,YAAM,KAAK,EAAE,MAAM,aAAa,SAAS,MAAM,CAAC;AAAA,IACjD,WAAW,OAAO,UAAU,YAAY,UAAU,MAAM;AAEvD,YAAM,KAAK,GAAG,oBAAoB,OAA+B,WAAW,CAAC;AAAA,IAC9E;AAAA,EACD;AAEA,SAAO;AACR;AAEO,SAAS,mBAAqC,OAA2B,QAAW;AAC1F,aAAW,CAAC,KAAK,OAAO,KAAK,OAAO,QAAQ,KAAK,GAAG;AACnD,UAAM,QAAQ,OAAO,GAAc;AAKnC,QAAI,oBAAoB,OAAO,GAAG;AACjC,UAAI,QAAQ,WAAW,UAAU,QAAQ,GAAI,QAAO;AACpD,UAAI,SAAS,WAAW,UAAU,QAAQ,IAAK,QAAO;AACtD,UAAI,QAAQ,YAAY,OAAO,UAAU,YAAY,SAAS,QAAQ,IAAK,QAAO;AAClF;AAAA,IACD;AAGA,QAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAI,CAAC,mBAAmB,SAAiC,KAAY,GAAG;AACvE,aAAO;AAAA,IACR;AAAA,EACD;AACA,SAAO;AACR;AAgCO,SAAS,aACf,OACA,UACA,OACgD;AAIhD,QAAM,eAAe,oBAAoB,KAAK;AAG9C,QAAM,WAAW,OAAO,YAAY,aAAa,IAAI,CAAC,EAAE,KAAK,MAAM,CAAC,MAAM,oBAAI,IAAa,CAAC,CAAC,CAAC;AAG9F,aAAW,EAAE,MAAM,QAAQ,KAAK,cAAc;AAC7C,UAAM,QAAQ,MAAM,MAAM,UAAU,IAAW;AAE/C,QAAI,QAAQ,SAAS;AACpB,YAAM,MAAM,MAAM,IAAI,EAAE,IAAI,QAAQ,EAAE;AACtC,UAAI,KAAK;AACR,mBAAW,MAAM,KAAK;AACrB,mBAAS,IAAI,EAAE,IAAI,EAAE;AAAA,QACtB;AAAA,MACD;AAAA,IACD,WAAW,SAAS,SAAS;AAC5B,iBAAW,CAAC,OAAO,GAAG,KAAK,MAAM,IAAI,GAAG;AACvC,YAAI,UAAU,QAAQ,KAAK;AAC1B,qBAAW,MAAM,KAAK;AACrB,qBAAS,IAAI,EAAE,IAAI,EAAE;AAAA,UACtB;AAAA,QACD;AAAA,MACD;AAAA,IACD,WAAW,QAAQ,SAAS;AAC3B,iBAAW,CAAC,OAAO,GAAG,KAAK,MAAM,IAAI,GAAG;AACvC,YAAI,OAAO,UAAU,YAAY,QAAQ,QAAQ,IAAI;AACpD,qBAAW,MAAM,KAAK;AACrB,qBAAS,IAAI,EAAE,IAAI,EAAE;AAAA,UACtB;AAAA,QACD;AAAA,MACD;AAAA,IACD;AAGA,QAAI,SAAS,IAAI,EAAE,SAAS,GAAG;AAC9B,aAAO,oBAAI,IAAI;AAAA,IAChB;AAAA,EACD;AAGA,SAAO,cAAc,OAAO,OAAO,QAAQ,CAAC;AAC7C;",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tldraw/store",
   "description": "tldraw infinite canvas SDK (store).",
-  "version": "4.2.0-next.47462e908ff5",
+  "version": "4.2.0-next.54bc357bbff2",
   "author": {
     "name": "tldraw Inc.",
     "email": "hello@tldraw.com"
@@ -44,8 +44,8 @@
     "context": "yarn run -T tsx ../../internal/scripts/context.ts"
   },
   "dependencies": {
-    "@tldraw/state": "4.2.0-next.47462e908ff5",
-    "@tldraw/utils": "4.2.0-next.47462e908ff5"
+    "@tldraw/state": "4.2.0-next.54bc357bbff2",
+    "@tldraw/utils": "4.2.0-next.54bc357bbff2"
   },
   "peerDependencies": {
     "react": "^18.2.0 || ^19.0.0"

package/src/lib/RecordType.ts

@@ -105,7 +105,7 @@ export class RecordType<
 		const ephemeralKeySet = new Set<string>()
 		if (config.ephemeralKeys) {
 			for (const [key, isEphemeral] of objectMapEntries(config.ephemeralKeys)) {
-				if (isEphemeral) ephemeralKeySet.add(key)
+				if (isEphemeral) ephemeralKeySet.add(key as string)
 			}
 		}
 		this.ephemeralKeySet = ephemeralKeySet

package/src/lib/StoreQueries.ts

@@ -31,10 +31,7 @@ import { CollectionDiff } from './Store'
  *
  * @public
  */
-export type RSIndexDiff<
-	R extends UnknownRecord,
-	Property extends string & keyof R = string & keyof R,
-> = Map<R[Property], CollectionDiff<IdOf<R>>>
+export type RSIndexDiff<R extends UnknownRecord> = Map<any, CollectionDiff<IdOf<R>>>
 
 /**
  * A type representing a reactive store index as a map from property values to sets of record IDs.
@@ -51,10 +48,7 @@ export type RSIndexDiff<
  *
  * @public
  */
-export type RSIndexMap<
-	R extends UnknownRecord,
-	Property extends string & keyof R = string & keyof R,
-> = Map<R[Property], Set<IdOf<R>>>
+export type RSIndexMap<R extends UnknownRecord> = Map<any, Set<IdOf<R>>>
 
 /**
  * A reactive computed index that provides efficient lookups of records by property values.
@@ -71,10 +65,7 @@ export type RSIndexMap<
  *
  * @public
  */
-export type RSIndex<
-	R extends UnknownRecord,
-	Property extends string & keyof R = string & keyof R,
-> = Computed<RSIndexMap<R, Property>, RSIndexDiff<R, Property>>
+export type RSIndex<R extends UnknownRecord> = Computed<RSIndexMap<R>, RSIndexDiff<R>>
 
 /**
  * A class that provides reactive querying capabilities for a record store.
@@ -121,6 +112,49 @@ export class StoreQueries<R extends UnknownRecord> {
 	 */
 	private historyCache = new Map<string, Computed<number, RecordsDiff<R>>>()
 
+	/**
+	 * @internal
+	 */
+	public getAllIdsForType<TypeName extends R['typeName']>(
+		typeName: TypeName
+	): Set<IdOf<Extract<R, { typeName: TypeName }>>> {
+		type S = Extract<R, { typeName: TypeName }>
+		const ids = new Set<IdOf<S>>()
+		for (const record of this.recordMap.values()) {
+			if (record.typeName === typeName) {
+				ids.add(record.id as IdOf<S>)
+			}
+		}
+		return ids
+	}
+
+	/**
+	 * @internal
+	 */
+	public getRecordById<TypeName extends R['typeName']>(
+		typeName: TypeName,
+		id: IdOf<Extract<R, { typeName: TypeName }>>
+	): Extract<R, { typeName: TypeName }> | undefined {
+		const record = this.recordMap.get(id as IdOf<R>)
+		if (record && record.typeName === typeName) {
+			return record as Extract<R, { typeName: TypeName }>
+		}
+		return undefined
+	}
+
+	/**
+	 * Helper to extract nested property value using pre-split path parts.
+	 * @internal
+	 */
+	private getNestedValue(obj: any, pathParts: string[]): any {
+		let current = obj
+		for (const part of pathParts) {
+			if (current == null || typeof current !== 'object') return undefined
+			current = current[part]
+		}
+		return current
+	}
+
 	/**
 	 * Creates a reactive computed that tracks the change history for records of a specific type.
 	 * The returned computed provides incremental diffs showing what records of the given type
@@ -237,8 +271,10 @@ export class StoreQueries<R extends UnknownRecord> {
 	 * The index automatically updates when records are added, updated, or removed, and results are cached
 	 * for performance.
 	 *
+	 * Supports nested property paths using backslash separator (e.g., 'metadata\\sessionId').
+	 *
 	 * @param typeName - The type name of records to index
-	 * @param property - The property name to index by
+	 * @param path - The property name or backslash-delimited path to index by
 	 * @returns A reactive computed containing the index map with change diffs
 	 *
 	 * @example
@@ -250,24 +286,24 @@ export class StoreQueries<R extends UnknownRecord> {
 	 * const authorBooks = booksByAuthor.get().get('author:leguin')
 	 * console.log(authorBooks) // Set<RecordId<Book>>
 	 *
-	 * // Index by title for quick title lookups
-	 * const booksByTitle = store.query.index('book', 'title')
-	 * const booksLatheOfHeaven = booksByTitle.get().get('The Lathe of Heaven')
+	 * // Index by nested property using backslash separator
+	 * const booksBySession = store.query.index('book', 'metadata\\sessionId')
+	 * const sessionBooks = booksBySession.get().get('session:alpha')
 	 * ```
 	 *
 	 * @public
 	 */
-	public index<
-		TypeName extends R['typeName'],
-		Property extends string & keyof Extract<R, { typeName: TypeName }>,
-	>(typeName: TypeName, property: Property): RSIndex<Extract<R, { typeName: TypeName }>, Property> {
-		const cacheKey = typeName + ':' + property
+	public index<TypeName extends R['typeName']>(
+		typeName: TypeName,
+		path: string
+	): RSIndex<Extract<R, { typeName: TypeName }>> {
+		const cacheKey = typeName + ':' + path
 
 		if (this.indexCache.has(cacheKey)) {
 			return this.indexCache.get(cacheKey) as any
 		}
 
-		const index = this.__uncached_createIndex(typeName, property)
+		const index = this.__uncached_createIndex(typeName, path)
 
 		this.indexCache.set(cacheKey, index as any)
 
@@ -278,40 +314,51 @@ export class StoreQueries<R extends UnknownRecord> {
 	 * Creates a new index without checking the cache. This method performs the actual work
 	 * of building the reactive index computation that tracks property values to record ID sets.
 	 *
+	 * Supports nested property paths using backslash separator.
+	 *
 	 * @param typeName - The type name of records to index
-	 * @param property - The property name to index by
+	 * @param path - The property name or backslash-delimited path to index by
 	 * @returns A reactive computed containing the index map with change diffs
 	 *
 	 * @internal
 	 */
-	__uncached_createIndex<
-		TypeName extends R['typeName'],
-		Property extends string & keyof Extract<R, { typeName: TypeName }>,
-	>(typeName: TypeName, property: Property): RSIndex<Extract<R, { typeName: TypeName }>, Property> {
+	__uncached_createIndex<TypeName extends R['typeName']>(
+		typeName: TypeName,
+		path: string
+	): RSIndex<Extract<R, { typeName: TypeName }>> {
 		type S = Extract<R, { typeName: TypeName }>
 
 		const typeHistory = this.filterHistory(typeName)
 
+		// Create closure for efficient property value extraction
+		const pathParts = path.split('\\')
+		const getPropertyValue =
+			pathParts.length > 1
+				? (obj: S) => this.getNestedValue(obj, pathParts)
+				: (obj: S) => obj[path as keyof S]
+
 		const fromScratch = () => {
 			// deref typeHistory early so that the first time the incremental version runs
 			// it gets a diff to work with instead of having to bail to this from-scratch version
 			typeHistory.get()
-			const res = new Map<S[Property], Set<IdOf<S>>>()
+			const res = new Map<any, Set<IdOf<S>>>()
 			for (const record of this.recordMap.values()) {
 				if (record.typeName === typeName) {
-					const value = (record as S)[property]
-					if (!res.has(value)) {
-						res.set(value, new Set())
+					const value = getPropertyValue(record as S)
+					if (value !== undefined) {
+						if (!res.has(value)) {
+							res.set(value, new Set())
+						}
+						res.get(value)!.add(record.id)
 					}
-					res.get(value)!.add(record.id)
 				}
 			}
 
 			return res
 		}
 
-		return computed<RSIndexMap<S, Property>, RSIndexDiff<S, Property>>(
-			'index:' + typeName + ':' + property,
+		return computed<RSIndexMap<S>, RSIndexDiff<S>>(
+			'index:' + typeName + ':' + path,
 			(prevValue, lastComputedEpoch) => {
 				if (isUninitialized(prevValue)) return fromScratch()
 
@@ -322,7 +369,7 @@ export class StoreQueries<R extends UnknownRecord> {
 
 				const setConstructors = new Map<any, IncrementalSetConstructor<IdOf<S>>>()
 
-				const add = (value: S[Property], id: IdOf<S>) => {
+				const add = (value: any, id: IdOf<S>) => {
 					let setConstructor = setConstructors.get(value)
 					if (!setConstructor)
 						setConstructor = new IncrementalSetConstructor<IdOf<S>>(
@@ -332,7 +379,7 @@ export class StoreQueries<R extends UnknownRecord> {
 					setConstructors.set(value, setConstructor)
 				}
 
-				const remove = (value: S[Property], id: IdOf<S>) => {
+				const remove = (value: any, id: IdOf<S>) => {
 					let set = setConstructors.get(value)
 					if (!set) set = new IncrementalSetConstructor<IdOf<S>>(prevValue.get(value) ?? new Set())
 					set.remove(id)
@@ -342,30 +389,38 @@ export class StoreQueries<R extends UnknownRecord> {
 				for (const changes of history) {
 					for (const record of objectMapValues(changes.added)) {
 						if (record.typeName === typeName) {
-							const value = (record as S)[property]
-							add(value, record.id)
+							const value = getPropertyValue(record as S)
+							if (value !== undefined) {
+								add(value, record.id)
+							}
 						}
 					}
 					for (const [from, to] of objectMapValues(changes.updated)) {
 						if (to.typeName === typeName) {
-							const prev = (from as S)[property]
-							const next = (to as S)[property]
+							const prev = getPropertyValue(from as S)
+							const next = getPropertyValue(to as S)
 							if (prev !== next) {
-								remove(prev, to.id)
-								add(next, to.id)
+								if (prev !== undefined) {
+									remove(prev, to.id)
+								}
+								if (next !== undefined) {
+									add(next, to.id)
+								}
 							}
 						}
 					}
 					for (const record of objectMapValues(changes.removed)) {
 						if (record.typeName === typeName) {
-							const value = (record as S)[property]
-							remove(value, record.id)
+							const value = getPropertyValue(record as S)
+							if (value !== undefined) {
+								remove(value, record.id)
+							}
 						}
 					}
 				}
 
-				let nextValue: undefined | RSIndexMap<S, Property> = undefined
-				let nextDiff: undefined | RSIndexDiff<S, Property> = undefined
+				let nextValue: undefined | RSIndexMap<S> = undefined
+				let nextDiff: undefined | RSIndexDiff<S> = undefined
 
 				for (const [value, setConstructor] of setConstructors) {
 					const result = setConstructor.get()
@@ -513,11 +568,7 @@ export class StoreQueries<R extends UnknownRecord> {
 			typeHistory.get()
 			const query: QueryExpression<S> = queryCreator()
 			if (Object.keys(query).length === 0) {
-				const ids = new Set<IdOf<S>>()
-				for (const record of this.recordMap.values()) {
-					if (record.typeName === typeName) ids.add(record.id)
-				}
-				return ids
+				return this.getAllIdsForType(typeName)
 			}
 
 			return executeQuery(this, typeName, query)