tinybase 8.1.0-beta.1 → 8.1.0-beta.2

package/ui-svelte/with-schemas/index.js

@@ -1,4 +1,4 @@
-import {getContext, setContext} from 'svelte';
+import {getContext, setContext, untrack} from 'svelte';
 import * as $ from 'svelte/internal/client';
 import 'svelte/internal/disclose-version';
 
@@ -6,6 +6,7 @@ const getTypeOf = (thing) => typeof thing;
 const TINYBASE = 'tinybase';
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
+const FUNCTION = getTypeOf(getTypeOf);
 const LISTENER = 'Listener';
 const RESULT = 'Result';
 const GET = 'get';
@@ -25,6 +26,8 @@ const CELL_IDS = CELL + IDS;
 const VALUE = 'Value';
 const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
+const TRANSACTION = 'Transaction';
+const FINISH = 'Finish';
 const STATUS = 'Status';
 const METRIC = 'Metric';
 const INDEX = 'Index';
@@ -37,10 +40,14 @@ const QUERY = 'Query';
 const CHECKPOINT = 'Checkpoint';
 
 const getIfNotFunction = (predicate) => (value, then, otherwise) =>
-  predicate(value) ? otherwise?.() : then(value);
+  predicate(value)
+    ? /* istanbul ignore next */
+      otherwise?.()
+    : then(value);
 const isUndefined = (thing) => thing === void 0;
 const ifNotUndefined = getIfNotFunction(isUndefined);
 const isString = (thing) => getTypeOf(thing) == STRING;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
 
 const object = Object;
 const objIds = object.keys;
@@ -48,12 +55,11 @@ const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
 
 const TINYBASE_CONTEXT_KEY = TINYBASE + '_uisc';
 
-/* hooks.svelte.ts generated by Svelte v5.53.8 */
+/* hooks.svelte.ts generated by Svelte v5.53.11 */
 
 const EMPTY_ARR = [];
 const EMPTY_OBJ = {};
 const DEFAULT_CHECKPOINT_IDS = [EMPTY_ARR, void 0, EMPTY_ARR];
-const rv = (v) => (typeof v === 'function' ? v() : v);
 const OFFSET_STORE = 0;
 const OFFSET_METRICS = 1;
 const OFFSET_INDEXES = 2;
@@ -62,63 +68,72 @@ const OFFSET_QUERIES = 4;
 const OFFSET_CHECKPOINTS = 5;
 const OFFSET_PERSISTER = 6;
 const OFFSET_SYNCHRONIZER = 7;
-const getCtx = () => getContext(TINYBASE_CONTEXT_KEY) ?? [];
+const maybeGet = (thing) => (isFunction(thing) ? thing() : thing);
+const getContextValue = () => getContext(TINYBASE_CONTEXT_KEY) ?? [];
 
-const resolveWithCtx = (ctx, thingOrId, offset) => {
-  if (!isUndefined(thingOrId) && !isString(thingOrId)) return thingOrId;
+const getThing = (contextValue, thingOrThingId, offset) =>
+  isUndefined(thingOrThingId)
+    ? contextValue[offset * 2]
+    : isString(thingOrThingId)
+      ? objGet(contextValue[offset * 2 + 1], thingOrThingId)
+      : thingOrThingId;
 
-  return isUndefined(thingOrId)
-    ? ctx[offset * 2]
-    : objGet(ctx[offset * 2 + 1], thingOrId);
-};
-
-const resolveByOffset = (thingOrId, offset) =>
-  resolveWithCtx(getCtx(), thingOrId, offset);
+const useThing = (thingOrThingId, offset) =>
+  getThing(getContextValue(), thingOrThingId, offset);
 
-const mkGetter = (offset, thingOrId) => {
-  const ctx = getCtx();
+const useThingOrThingById = (thingOrThingId, offset) => {
+  const contextValue = getContextValue();
 
-  return () =>
-    resolveWithCtx(
-      ctx,
-      typeof thingOrId === 'function' ? thingOrId() : thingOrId,
-      offset,
-    );
+  return () => getThing(contextValue, maybeGet(thingOrThingId), offset);
 };
 
-const getThingIds = (ctx, offset) => objIds(ctx[offset * 2 + 1] ?? EMPTY_OBJ);
-const sg = (s) => mkGetter(OFFSET_STORE, s);
-const mg = (m) => mkGetter(OFFSET_METRICS, m);
-const ig = (i) => mkGetter(OFFSET_INDEXES, i);
-const rg = (r) => mkGetter(OFFSET_RELATIONSHIPS, r);
-const qg = (q) => mkGetter(OFFSET_QUERIES, q);
-const cg = (c) => mkGetter(OFFSET_CHECKPOINTS, c);
-const pg = (p) => mkGetter(OFFSET_PERSISTER, p);
-const syg = (sy) => mkGetter(OFFSET_SYNCHRONIZER, sy);
+const getThingIds = (contextValue, offset) =>
+  objIds(contextValue[offset * 2 + 1] ?? EMPTY_OBJ);
+
+const useStoreOrStoreById = (storeOrStoreId) =>
+  useThingOrThingById(storeOrStoreId, OFFSET_STORE);
+const useMetricsOrMetricsById = (metricsOrMetricsId) =>
+  useThingOrThingById(metricsOrMetricsId, OFFSET_METRICS);
+const useIndexesOrIndexesById = (indexesOrIndexesId) =>
+  useThingOrThingById(indexesOrIndexesId, OFFSET_INDEXES);
+const useRelationshipsOrRelationshipsById = (relationshipsOrRelationshipsId) =>
+  useThingOrThingById(relationshipsOrRelationshipsId, OFFSET_RELATIONSHIPS);
+const useQueriesOrQueriesById = (queriesOrQueriesId) =>
+  useThingOrThingById(queriesOrQueriesId, OFFSET_QUERIES);
+const useCheckpointsOrCheckpointsById = (checkpointsOrCheckpointsId) =>
+  useThingOrThingById(checkpointsOrCheckpointsId, OFFSET_CHECKPOINTS);
+const usePersisterOrPersisterById = (persisterOrPersisterId) =>
+  useThingOrThingById(persisterOrPersisterId, OFFSET_PERSISTER);
+const useSynchronizerOrSynchronizerById = (synchronizerOrSynchronizerId) =>
+  useThingOrThingById(synchronizerOrSynchronizerId, OFFSET_SYNCHRONIZER);
 
 const useListenable = (
-  getThing,
-  getMethod,
-  addMethod,
+  getThing2,
+  listenable,
   defaultValue,
-  getArgs,
+  getArgs = () => EMPTY_ARR,
+  isHas,
 ) => {
+  const getMethod = (isHas ? _HAS : GET) + listenable;
+  const addMethod = ADD + (isHas ? HAS : '') + listenable + LISTENER;
   let value = $.state(
-    $.proxy(getThing()?.[getMethod]?.(...getArgs()) ?? defaultValue),
+    $.proxy(getThing2()?.[getMethod]?.(...getArgs()) ?? defaultValue),
   );
 
-  $.user_effect(() => {
-    const thing = getThing();
-    const args = getArgs();
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const thing = getThing2();
+      const args = getArgs();
 
-    $.set(value, thing?.[getMethod]?.(...args) ?? defaultValue, true);
+      $.set(value, thing?.[getMethod]?.(...args) ?? defaultValue, true);
 
-    const listenerId = thing?.[addMethod]?.(...args, () => {
-      $.set(value, thing[getMethod](...getArgs()) ?? defaultValue, true);
-    });
+      const listenerId = thing?.[addMethod]?.(...args, () => {
+        $.set(value, thing[getMethod](...getArgs()) ?? defaultValue, true);
+      });
 
-    return () => thing?.delListener?.(listenerId);
-  });
+      return () => thing?.delListener?.(listenerId);
+    });
+  }
 
   return {
     get current() {
@@ -127,46 +142,75 @@ const useListenable = (
   };
 };
 
-const useGet = (
-  getThing,
+const useListener = (
+  getThing2,
   listenable,
-  defaultValue,
-  getArgs = () => EMPTY_ARR,
-) =>
-  useListenable(
-    getThing,
-    GET + listenable,
-    ADD + listenable + LISTENER,
-    defaultValue,
-    getArgs,
-  );
+  listener,
+  getPreArgs = () => EMPTY_ARR,
+  mutator,
+) => {
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const thing = getThing2();
+      const preArgs = getPreArgs();
+      const listenerId = thing?.[ADD + listenable + LISTENER]?.(
+        ...preArgs,
+        listener,
+        ...(mutator !== void 0 ? [mutator] : EMPTY_ARR),
+      );
+
+      return () => thing?.delListener?.(listenerId);
+    });
+  }
+};
 
-const useHas = (getThing, listenable, getArgs = () => EMPTY_ARR) =>
+const useHasTables = (storeOrStoreId) =>
   useListenable(
-    getThing,
-    _HAS + listenable,
-    ADD + HAS + listenable + LISTENER,
+    useStoreOrStoreById(storeOrStoreId),
+    TABLES,
     false,
-    getArgs,
+    () => EMPTY_ARR,
+    1,
   );
-
-const useHasTables = (storeOrStoreId) => useHas(sg(storeOrStoreId), TABLES);
 const useTables = (storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), TABLES, EMPTY_OBJ);
+  useListenable(useStoreOrStoreById(storeOrStoreId), TABLES, EMPTY_OBJ);
 const useTableIds = (storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), TABLE_IDS, EMPTY_ARR);
+  useListenable(useStoreOrStoreById(storeOrStoreId), TABLE_IDS, EMPTY_ARR);
 const useHasTable = (tableId, storeOrStoreId) =>
-  useHas(sg(storeOrStoreId), TABLE, () => [rv(tableId)]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE,
+    false,
+    () => [maybeGet(tableId)],
+    1,
+  );
 const useTable = (tableId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), TABLE, EMPTY_OBJ, () => [rv(tableId)]);
+  useListenable(useStoreOrStoreById(storeOrStoreId), TABLE, EMPTY_OBJ, () => [
+    maybeGet(tableId),
+  ]);
 const useTableCellIds = (tableId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), TABLE + CELL_IDS, EMPTY_ARR, () => [rv(tableId)]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE + CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(tableId)],
+  );
 const useHasTableCell = (tableId, cellId, storeOrStoreId) =>
-  useHas(sg(storeOrStoreId), TABLE + CELL, () => [rv(tableId), rv(cellId)]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE + CELL,
+    false,
+    () => [maybeGet(tableId), maybeGet(cellId)],
+    1,
+  );
 const useRowCount = (tableId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), ROW_COUNT, 0, () => [rv(tableId)]);
+  useListenable(useStoreOrStoreById(storeOrStoreId), ROW_COUNT, 0, () => [
+    maybeGet(tableId),
+  ]);
 const useRowIds = (tableId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), ROW_IDS, EMPTY_ARR, () => [rv(tableId)]);
+  useListenable(useStoreOrStoreById(storeOrStoreId), ROW_IDS, EMPTY_ARR, () => [
+    maybeGet(tableId),
+  ]);
 
 const useSortedRowIds = (
   tableId,
@@ -176,53 +220,83 @@ const useSortedRowIds = (
   limit,
   storeOrStoreId,
 ) =>
-  useGet(sg(storeOrStoreId), SORTED_ROW_IDS, EMPTY_ARR, () => [
-    rv(tableId),
-    rv(cellId),
-    rv(descending),
-    rv(offset),
-    rv(limit),
-  ]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    SORTED_ROW_IDS,
+    EMPTY_ARR,
+    () => [
+      maybeGet(tableId),
+      maybeGet(cellId),
+      maybeGet(descending),
+      maybeGet(offset),
+      maybeGet(limit),
+    ],
+  );
 
 const useHasRow = (tableId, rowId, storeOrStoreId) =>
-  useHas(sg(storeOrStoreId), ROW, () => [rv(tableId), rv(rowId)]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    ROW,
+    false,
+    () => [maybeGet(tableId), maybeGet(rowId)],
+    1,
+  );
 const useRow = (tableId, rowId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), ROW, EMPTY_OBJ, () => [rv(tableId), rv(rowId)]);
-const useCellIds = (tableId, rowId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), CELL_IDS, EMPTY_ARR, () => [
-    rv(tableId),
-    rv(rowId),
+  useListenable(useStoreOrStoreById(storeOrStoreId), ROW, EMPTY_OBJ, () => [
+    maybeGet(tableId),
+    maybeGet(rowId),
   ]);
+const useCellIds = (tableId, rowId, storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(tableId), maybeGet(rowId)],
+  );
 const useHasCell = (tableId, rowId, cellId, storeOrStoreId) =>
-  useHas(sg(storeOrStoreId), CELL, () => [rv(tableId), rv(rowId), rv(cellId)]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    CELL,
+    false,
+    () => [maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)],
+    1,
+  );
 const useCell = (tableId, rowId, cellId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), CELL, void 0, () => [
-    rv(tableId),
-    rv(rowId),
-    rv(cellId),
+  useListenable(useStoreOrStoreById(storeOrStoreId), CELL, void 0, () => [
+    maybeGet(tableId),
+    maybeGet(rowId),
+    maybeGet(cellId),
   ]);
 
-const useCellState = (tableId, rowId, cellId, storeOrStoreId) => {
-  const getS = sg(storeOrStoreId);
+const useBindableCell = (tableId, rowId, cellId, storeOrStoreId) => {
+  const getS = useStoreOrStoreById(storeOrStoreId);
   let value = $.state(
-    $.proxy(getS()?.getCell(rv(tableId), rv(rowId), rv(cellId))),
+    $.proxy(
+      getS()?.getCell(maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)),
+    ),
   );
 
-  $.user_effect(() => {
-    const s = getS();
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const s = getS();
 
-    const t = rv(tableId),
-      r = rv(rowId),
-      c = rv(cellId);
+      const t = maybeGet(tableId),
+        r = maybeGet(rowId),
+        c = maybeGet(cellId);
 
-    $.set(value, s?.getCell(t, r, c), true);
+      $.set(value, s?.getCell(t, r, c), true);
 
-    const listenerId = s?.addCellListener(t, r, c, (st) => {
-      $.set(value, st.getCell(rv(tableId), rv(rowId), rv(cellId)), true);
-    });
+      const listenerId = s?.addCellListener(t, r, c, (st) => {
+        $.set(
+          value,
+          st.getCell(maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)),
+          true,
+        );
+      });
 
-    return () => s?.delListener?.(listenerId);
-  });
+      return () => s?.delListener?.(listenerId);
+    });
+  }
 
   return {
     get current() {
@@ -230,37 +304,54 @@ const useCellState = (tableId, rowId, cellId, storeOrStoreId) => {
     },
 
     set current(v) {
-      getS()?.setCell(rv(tableId), rv(rowId), rv(cellId), v);
+      getS()?.setCell(maybeGet(tableId), maybeGet(rowId), maybeGet(cellId), v);
     },
   };
 };
 
-const useHasValues = (storeOrStoreId) => useHas(sg(storeOrStoreId), VALUES);
+const useHasValues = (storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUES,
+    false,
+    () => EMPTY_ARR,
+    1,
+  );
 const useValues = (storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), VALUES, EMPTY_OBJ);
+  useListenable(useStoreOrStoreById(storeOrStoreId), VALUES, EMPTY_OBJ);
 const useValueIds = (storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), VALUE_IDS, EMPTY_ARR);
+  useListenable(useStoreOrStoreById(storeOrStoreId), VALUE_IDS, EMPTY_ARR);
 const useHasValue = (valueId, storeOrStoreId) =>
-  useHas(sg(storeOrStoreId), VALUE, () => [rv(valueId)]);
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUE,
+    false,
+    () => [maybeGet(valueId)],
+    1,
+  );
 const useValue = (valueId, storeOrStoreId) =>
-  useGet(sg(storeOrStoreId), VALUE, void 0, () => [rv(valueId)]);
+  useListenable(useStoreOrStoreById(storeOrStoreId), VALUE, void 0, () => [
+    maybeGet(valueId),
+  ]);
 
-const useValueState = (valueId, storeOrStoreId) => {
-  const getS = sg(storeOrStoreId);
-  let value = $.state($.proxy(getS()?.getValue(rv(valueId))));
+const useBindableValue = (valueId, storeOrStoreId) => {
+  const getS = useStoreOrStoreById(storeOrStoreId);
+  let value = $.state($.proxy(getS()?.getValue(maybeGet(valueId))));
 
-  $.user_effect(() => {
-    const s = getS();
-    const vid = rv(valueId);
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const s = getS();
+      const vid = maybeGet(valueId);
 
-    $.set(value, s?.getValue(vid), true);
+      $.set(value, s?.getValue(vid), true);
 
-    const listenerId = s?.addValueListener(vid, (st) => {
-      $.set(value, st.getValue(rv(valueId)), true);
-    });
+      const listenerId = s?.addValueListener(vid, (st) => {
+        $.set(value, st.getValue(maybeGet(valueId)), true);
+      });
 
-    return () => s?.delListener?.(listenerId);
-  });
+      return () => s?.delListener?.(listenerId);
+    });
+  }
 
   return {
     get current() {
@@ -268,20 +359,22 @@ const useValueState = (valueId, storeOrStoreId) => {
     },
 
     set current(v) {
-      getS()?.setValue(rv(valueId), v);
+      getS()?.setValue(maybeGet(valueId), v);
     },
   };
 };
 
-const useStore = (id) => resolveByOffset(id, OFFSET_STORE);
+const useStore = (id) => useThing(id, OFFSET_STORE);
 
 const useStoreIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_STORE)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_STORE)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_STORE), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_STORE), true);
+    });
+  }
 
   return {
     get current() {
@@ -290,15 +383,17 @@ const useStoreIds = () => {
   };
 };
 
-const useMetrics = (id) => resolveByOffset(id, OFFSET_METRICS);
+const useMetrics = (id) => useThing(id, OFFSET_METRICS);
 
 const useMetricsIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_METRICS)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_METRICS)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_METRICS), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_METRICS), true);
+    });
+  }
 
   return {
     get current() {
@@ -308,18 +403,29 @@ const useMetricsIds = () => {
 };
 
 const useMetricIds = (metricsOrMetricsId) =>
-  useGet(mg(metricsOrMetricsId), METRIC + IDS, EMPTY_ARR);
+  useListenable(
+    useMetricsOrMetricsById(metricsOrMetricsId),
+    METRIC + IDS,
+    EMPTY_ARR,
+  );
 const useMetric = (metricId, metricsOrMetricsId) =>
-  useGet(mg(metricsOrMetricsId), METRIC, void 0, () => [rv(metricId)]);
-const useIndexes = (id) => resolveByOffset(id, OFFSET_INDEXES);
+  useListenable(
+    useMetricsOrMetricsById(metricsOrMetricsId),
+    METRIC,
+    void 0,
+    () => [maybeGet(metricId)],
+  );
+const useIndexes = (id) => useThing(id, OFFSET_INDEXES);
 
 const useIndexesIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_INDEXES)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_INDEXES)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_INDEXES), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_INDEXES), true);
+    });
+  }
 
   return {
     get current() {
@@ -329,23 +435,51 @@ const useIndexesIds = () => {
 };
 
 const useIndexIds = (indexesOrIndexesId) =>
-  useGet(ig(indexesOrIndexesId), INDEX + IDS, EMPTY_ARR);
+  useListenable(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    INDEX + IDS,
+    EMPTY_ARR,
+  );
 const useSliceIds = (indexId, indexesOrIndexesId) =>
-  useGet(ig(indexesOrIndexesId), SLICE + IDS, EMPTY_ARR, () => [rv(indexId)]);
+  useListenable(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    SLICE + IDS,
+    EMPTY_ARR,
+    () => [maybeGet(indexId)],
+  );
 const useSliceRowIds = (indexId, sliceId, indexesOrIndexesId) =>
-  useGet(ig(indexesOrIndexesId), SLICE + ROW_IDS, EMPTY_ARR, () => [
-    rv(indexId),
-    rv(sliceId),
-  ]);
-const useQueries = (id) => resolveByOffset(id, OFFSET_QUERIES);
+  useListenable(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    SLICE + ROW_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(indexId), maybeGet(sliceId)],
+  );
+
+const useIndexStoreTableId = (indexesOrId, indexId) => {
+  const getI = useIndexesOrIndexesById(indexesOrId);
+
+  return {
+    get store() {
+      return getI()?.getStore();
+    },
+
+    get tableId() {
+      return getI()?.getTableId(maybeGet(indexId));
+    },
+  };
+};
+
+const useQueries = (id) => useThing(id, OFFSET_QUERIES);
 
 const useQueriesIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_QUERIES)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_QUERIES)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_QUERIES), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_QUERIES), true);
+    });
+  }
 
   return {
     get current() {
@@ -355,21 +489,39 @@ const useQueriesIds = () => {
 };
 
 const useQueryIds = (queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), QUERY + IDS, EMPTY_ARR);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    QUERY + IDS,
+    EMPTY_ARR,
+  );
 const useResultTable = (queryId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + TABLE, EMPTY_OBJ, () => [
-    rv(queryId),
-  ]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + TABLE,
+    EMPTY_OBJ,
+    () => [maybeGet(queryId)],
+  );
 const useResultTableCellIds = (queryId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + TABLE + CELL_IDS, EMPTY_ARR, () => [
-    rv(queryId),
-  ]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + TABLE + CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(queryId)],
+  );
 const useResultRowCount = (queryId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + ROW_COUNT, 0, () => [rv(queryId)]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW_COUNT,
+    0,
+    () => [maybeGet(queryId)],
+  );
 const useResultRowIds = (queryId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + ROW_IDS, EMPTY_ARR, () => [
-    rv(queryId),
-  ]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(queryId)],
+  );
 
 const useResultSortedRowIds = (
   queryId,
@@ -379,39 +531,51 @@ const useResultSortedRowIds = (
   limit,
   queriesOrQueriesId,
 ) =>
-  useGet(qg(queriesOrQueriesId), RESULT + SORTED_ROW_IDS, EMPTY_ARR, () => [
-    rv(queryId),
-    rv(cellId),
-    rv(descending),
-    rv(offset),
-    rv(limit),
-  ]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + SORTED_ROW_IDS,
+    EMPTY_ARR,
+    () => [
+      maybeGet(queryId),
+      maybeGet(cellId),
+      maybeGet(descending),
+      maybeGet(offset),
+      maybeGet(limit),
+    ],
+  );
 
 const useResultRow = (queryId, rowId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + ROW, EMPTY_OBJ, () => [
-    rv(queryId),
-    rv(rowId),
-  ]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW,
+    EMPTY_OBJ,
+    () => [maybeGet(queryId), maybeGet(rowId)],
+  );
 const useResultCellIds = (queryId, rowId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + CELL_IDS, EMPTY_ARR, () => [
-    rv(queryId),
-    rv(rowId),
-  ]);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(queryId), maybeGet(rowId)],
+  );
 const useResultCell = (queryId, rowId, cellId, queriesOrQueriesId) =>
-  useGet(qg(queriesOrQueriesId), RESULT + CELL, void 0, () => [
-    rv(queryId),
-    rv(rowId),
-    rv(cellId),
-  ]);
-const useRelationships = (id) => resolveByOffset(id, OFFSET_RELATIONSHIPS);
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + CELL,
+    void 0,
+    () => [maybeGet(queryId), maybeGet(rowId), maybeGet(cellId)],
+  );
+const useRelationships = (id) => useThing(id, OFFSET_RELATIONSHIPS);
 
 const useRelationshipsIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_RELATIONSHIPS)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_RELATIONSHIPS)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_RELATIONSHIPS), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_RELATIONSHIPS), true);
+    });
+  }
 
   return {
     get current() {
@@ -421,45 +585,74 @@ const useRelationshipsIds = () => {
 };
 
 const useRelationshipIds = (relationshipsOrRelationshipsId) =>
-  useGet(rg(relationshipsOrRelationshipsId), RELATIONSHIP + IDS, EMPTY_ARR);
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    RELATIONSHIP + IDS,
+    EMPTY_ARR,
+  );
 const useRemoteRowId = (
   relationshipId,
   localRowId,
   relationshipsOrRelationshipsId,
 ) =>
-  useGet(rg(relationshipsOrRelationshipsId), REMOTE_ROW_ID, void 0, () => [
-    rv(relationshipId),
-    rv(localRowId),
-  ]);
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    REMOTE_ROW_ID,
+    void 0,
+    () => [maybeGet(relationshipId), maybeGet(localRowId)],
+  );
 const useLocalRowIds = (
   relationshipId,
   remoteRowId,
   relationshipsOrRelationshipsId,
 ) =>
-  useGet(rg(relationshipsOrRelationshipsId), LOCAL + ROW_IDS, EMPTY_ARR, () => [
-    rv(relationshipId),
-    rv(remoteRowId),
-  ]);
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    LOCAL + ROW_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(relationshipId), maybeGet(remoteRowId)],
+  );
 const useLinkedRowIds = (
   relationshipId,
   firstRowId,
   relationshipsOrRelationshipsId,
 ) =>
-  useGet(
-    rg(relationshipsOrRelationshipsId),
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
     LINKED + ROW_IDS,
     EMPTY_ARR,
-    () => [rv(relationshipId), rv(firstRowId)],
+    () => [maybeGet(relationshipId), maybeGet(firstRowId)],
   );
-const useCheckpoints = (id) => resolveByOffset(id, OFFSET_CHECKPOINTS);
+
+const useRelationshipsStoreTableIds = (relationshipsOrId, relationshipId) => {
+  const getR = useRelationshipsOrRelationshipsById(relationshipsOrId);
+
+  return {
+    get store() {
+      return getR()?.getStore();
+    },
+
+    get localTableId() {
+      return getR()?.getLocalTableId(maybeGet(relationshipId));
+    },
+
+    get remoteTableId() {
+      return getR()?.getRemoteTableId(maybeGet(relationshipId));
+    },
+  };
+};
+
+const useCheckpoints = (id) => useThing(id, OFFSET_CHECKPOINTS);
 
 const useCheckpointsIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_CHECKPOINTS)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_CHECKPOINTS)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_CHECKPOINTS), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_CHECKPOINTS), true);
+    });
+  }
 
   return {
     get current() {
@@ -469,37 +662,42 @@ const useCheckpointsIds = () => {
 };
 
 const useCheckpointIds = (checkpointsOrCheckpointsId) =>
-  useGet(
-    cg(checkpointsOrCheckpointsId),
+  useListenable(
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
     CHECKPOINT + IDS,
     DEFAULT_CHECKPOINT_IDS,
   );
 const useCheckpoint = (checkpointId, checkpointsOrCheckpointsId) =>
-  useGet(cg(checkpointsOrCheckpointsId), CHECKPOINT, void 0, () => [
-    rv(checkpointId),
-  ]);
+  useListenable(
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    CHECKPOINT,
+    void 0,
+    () => [maybeGet(checkpointId)],
+  );
 
 const useGoBackwardCallback = (checkpointsOrCheckpointsId) => {
-  const getC = cg(checkpointsOrCheckpointsId);
+  const getC = useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId);
 
   return () => getC()?.goBackward();
 };
 
 const useGoForwardCallback = (checkpointsOrCheckpointsId) => {
-  const getC = cg(checkpointsOrCheckpointsId);
+  const getC = useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId);
 
   return () => getC()?.goForward();
 };
 
-const usePersister = (id) => resolveByOffset(id, OFFSET_PERSISTER);
+const usePersister = (id) => useThing(id, OFFSET_PERSISTER);
 
 const usePersisterIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_PERSISTER)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_PERSISTER)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_PERSISTER), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_PERSISTER), true);
+    });
+  }
 
   return {
     get current() {
@@ -509,16 +707,18 @@ const usePersisterIds = () => {
 };
 
 const usePersisterStatus = (persisterOrPersisterId) =>
-  useGet(pg(persisterOrPersisterId), STATUS, 0);
-const useSynchronizer = (id) => resolveByOffset(id, OFFSET_SYNCHRONIZER);
+  useListenable(usePersisterOrPersisterById(persisterOrPersisterId), STATUS, 0);
+const useSynchronizer = (id) => useThing(id, OFFSET_SYNCHRONIZER);
 
 const useSynchronizerIds = () => {
-  const ctx = getCtx();
-  let ids = $.state($.proxy(getThingIds(ctx, OFFSET_SYNCHRONIZER)));
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_SYNCHRONIZER)));
 
-  $.user_effect(() => {
-    $.set(ids, getThingIds(ctx, OFFSET_SYNCHRONIZER), true);
-  });
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_SYNCHRONIZER), true);
+    });
+  }
 
   return {
     get current() {
@@ -528,34 +728,461 @@ const useSynchronizerIds = () => {
 };
 
 const useSynchronizerStatus = (synchronizerOrSynchronizerId) =>
-  useGet(syg(synchronizerOrSynchronizerId), STATUS, 0);
+  useListenable(
+    useSynchronizerOrSynchronizerById(synchronizerOrSynchronizerId),
+    STATUS,
+    0,
+  );
+const useHasTablesListener = (listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + TABLES,
+    listener,
+    () => EMPTY_ARR,
+    mutator,
+  );
+const useTablesListener = (listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLES,
+    listener,
+    () => EMPTY_ARR,
+    mutator,
+  );
+const useTableIdsListener = (listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE_IDS,
+    listener,
+    () => EMPTY_ARR,
+    mutator,
+  );
+const useHasTableListener = (tableId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + TABLE,
+    listener,
+    () => [maybeGet(tableId)],
+    mutator,
+  );
+const useTableListener = (tableId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE,
+    listener,
+    () => [maybeGet(tableId)],
+    mutator,
+  );
+const useTableCellIdsListener = (tableId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE + CELL_IDS,
+    listener,
+    () => [maybeGet(tableId)],
+    mutator,
+  );
+const useHasTableCellListener = (
+  tableId,
+  cellId,
+  listener,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + TABLE + CELL,
+    listener,
+    () => [maybeGet(tableId), maybeGet(cellId)],
+    mutator,
+  );
+const useRowCountListener = (tableId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    ROW_COUNT,
+    listener,
+    () => [maybeGet(tableId)],
+    mutator,
+  );
+const useRowIdsListener = (tableId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    ROW_IDS,
+    listener,
+    () => [maybeGet(tableId)],
+    mutator,
+  );
+
+const useSortedRowIdsListener = (
+  tableId,
+  cellId,
+  descending,
+  offset,
+  limit,
+  listener,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    SORTED_ROW_IDS,
+    listener,
+    () => [
+      maybeGet(tableId),
+      maybeGet(cellId),
+      maybeGet(descending),
+      maybeGet(offset),
+      maybeGet(limit),
+    ],
+    mutator,
+  );
+
+const useHasRowListener = (tableId, rowId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + ROW,
+    listener,
+    () => [maybeGet(tableId), maybeGet(rowId)],
+    mutator,
+  );
+const useRowListener = (tableId, rowId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    ROW,
+    listener,
+    () => [maybeGet(tableId), maybeGet(rowId)],
+    mutator,
+  );
+const useCellIdsListener = (
+  tableId,
+  rowId,
+  listener,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    CELL_IDS,
+    listener,
+    () => [maybeGet(tableId), maybeGet(rowId)],
+    mutator,
+  );
+const useHasCellListener = (
+  tableId,
+  rowId,
+  cellId,
+  listener,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + CELL,
+    listener,
+    () => [maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)],
+    mutator,
+  );
+const useCellListener = (
+  tableId,
+  rowId,
+  cellId,
+  listener,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    CELL,
+    listener,
+    () => [maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)],
+    mutator,
+  );
+const useHasValuesListener = (listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + VALUES,
+    listener,
+    () => EMPTY_ARR,
+    mutator,
+  );
+const useValuesListener = (listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUES,
+    listener,
+    () => EMPTY_ARR,
+    mutator,
+  );
+const useValueIdsListener = (listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUE_IDS,
+    listener,
+    () => EMPTY_ARR,
+    mutator,
+  );
+const useHasValueListener = (valueId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    HAS + VALUE,
+    listener,
+    () => [maybeGet(valueId)],
+    mutator,
+  );
+const useValueListener = (valueId, listener, mutator, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUE,
+    listener,
+    () => [maybeGet(valueId)],
+    mutator,
+  );
+const useStartTransactionListener = (listener, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    'Start' + TRANSACTION,
+    listener,
+  );
+const useWillFinishTransactionListener = (listener, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    'Will' + FINISH + TRANSACTION,
+    listener,
+  );
+const useDidFinishTransactionListener = (listener, storeOrStoreId) =>
+  useListener(
+    useStoreOrStoreById(storeOrStoreId),
+    'Did' + FINISH + TRANSACTION,
+    listener,
+  );
+const useMetricListener = (metricId, listener, metricsOrMetricsId) =>
+  useListener(
+    useMetricsOrMetricsById(metricsOrMetricsId),
+    METRIC,
+    listener,
+    () => [maybeGet(metricId)],
+  );
+const useSliceIdsListener = (indexId, listener, indexesOrIndexesId) =>
+  useListener(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    SLICE + IDS,
+    listener,
+    () => [maybeGet(indexId)],
+  );
+const useSliceRowIdsListener = (
+  indexId,
+  sliceId,
+  listener,
+  indexesOrIndexesId,
+) =>
+  useListener(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    SLICE + ROW_IDS,
+    listener,
+    () => [maybeGet(indexId), maybeGet(sliceId)],
+  );
+
+const useRemoteRowIdListener = (
+  relationshipId,
+  localRowId,
+  listener,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    REMOTE_ROW_ID,
+    listener,
+    () => [maybeGet(relationshipId), maybeGet(localRowId)],
+  );
+
+const useLocalRowIdsListener = (
+  relationshipId,
+  remoteRowId,
+  listener,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    LOCAL + ROW_IDS,
+    listener,
+    () => [maybeGet(relationshipId), maybeGet(remoteRowId)],
+  );
 
-const injectThing = (offset, id, thing) => {
-  const ctx = getCtx();
+const useLinkedRowIdsListener = (
+  relationshipId,
+  firstRowId,
+  listener,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    LINKED + ROW_IDS,
+    listener,
+    () => [maybeGet(relationshipId), maybeGet(firstRowId)],
+  );
 
-  $.user_effect(() => {
-    ctx[16]?.(offset, id, thing);
+const useResultTableListener = (queryId, listener, queriesOrQueriesId) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + TABLE,
+    listener,
+    () => [maybeGet(queryId)],
+  );
+const useResultTableCellIdsListener = (queryId, listener, queriesOrQueriesId) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + TABLE + CELL_IDS,
+    listener,
+    () => [maybeGet(queryId)],
+  );
+const useResultRowCountListener = (queryId, listener, queriesOrQueriesId) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW_COUNT,
+    listener,
+    () => [maybeGet(queryId)],
+  );
+const useResultRowIdsListener = (queryId, listener, queriesOrQueriesId) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW_IDS,
+    listener,
+    () => [maybeGet(queryId)],
+  );
+
+const useResultSortedRowIdsListener = (
+  queryId,
+  cellId,
+  descending,
+  offset,
+  limit,
+  listener,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + SORTED_ROW_IDS,
+    listener,
+    () => [
+      maybeGet(queryId),
+      maybeGet(cellId),
+      maybeGet(descending),
+      maybeGet(offset),
+      maybeGet(limit),
+    ],
+  );
 
-    return () => ctx[17]?.(offset, id);
-  });
+const useResultRowListener = (queryId, rowId, listener, queriesOrQueriesId) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW,
+    listener,
+    () => [maybeGet(queryId), maybeGet(rowId)],
+  );
+const useResultCellIdsListener = (
+  queryId,
+  rowId,
+  listener,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + CELL_IDS,
+    listener,
+    () => [maybeGet(queryId), maybeGet(rowId)],
+  );
+const useResultCellListener = (
+  queryId,
+  rowId,
+  cellId,
+  listener,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + CELL,
+    listener,
+    () => [maybeGet(queryId), maybeGet(rowId), maybeGet(cellId)],
+  );
+const useParamValuesListener = (queryId, listener, queriesOrQueriesId) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    'ParamValues',
+    listener,
+    () => [maybeGet(queryId)],
+  );
+const useParamValueListener = (
+  queryId,
+  paramId,
+  listener,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    'ParamValue',
+    listener,
+    () => [maybeGet(queryId), maybeGet(paramId)],
+  );
+const useCheckpointIdsListener = (listener, checkpointsOrCheckpointsId) =>
+  useListener(
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    CHECKPOINT + IDS,
+    listener,
+  );
+const useCheckpointListener = (
+  checkpointId,
+  listener,
+  checkpointsOrCheckpointsId,
+) =>
+  useListener(
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    CHECKPOINT,
+    listener,
+    () => [maybeGet(checkpointId)],
+  );
+const usePersisterStatusListener = (listener, persisterOrPersisterId) =>
+  useListener(
+    usePersisterOrPersisterById(persisterOrPersisterId),
+    STATUS,
+    listener,
+  );
+const useSynchronizerStatusListener = (
+  listener,
+  synchronizerOrSynchronizerId,
+) =>
+  useListener(
+    useSynchronizerOrSynchronizerById(synchronizerOrSynchronizerId),
+    STATUS,
+    listener,
+  );
+
+const provideThing = (thingId, thing, offset) => {
+  const contextValue = getContextValue();
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      contextValue[16]?.(offset, thingId, thing);
+
+      return () => contextValue[17]?.(offset, thingId);
+    });
+  }
 };
 
 const provideStore = (storeId, store) =>
-  injectThing(OFFSET_STORE, storeId, store);
+  provideThing(storeId, store, OFFSET_STORE);
 const provideMetrics = (metricsId, metrics) =>
-  injectThing(OFFSET_METRICS, metricsId, metrics);
+  provideThing(metricsId, metrics, OFFSET_METRICS);
 const provideIndexes = (indexesId, indexes) =>
-  injectThing(OFFSET_INDEXES, indexesId, indexes);
+  provideThing(indexesId, indexes, OFFSET_INDEXES);
 const provideRelationships = (relationshipsId, relationships) =>
-  injectThing(OFFSET_RELATIONSHIPS, relationshipsId, relationships);
+  provideThing(relationshipsId, relationships, OFFSET_RELATIONSHIPS);
 const provideQueries = (queriesId, queries) =>
-  injectThing(OFFSET_QUERIES, queriesId, queries);
+  provideThing(queriesId, queries, OFFSET_QUERIES);
 const provideCheckpoints = (checkpointsId, checkpoints) =>
-  injectThing(OFFSET_CHECKPOINTS, checkpointsId, checkpoints);
+  provideThing(checkpointsId, checkpoints, OFFSET_CHECKPOINTS);
 const providePersister = (persisterId, persister) =>
-  injectThing(OFFSET_PERSISTER, persisterId, persister);
+  provideThing(persisterId, persister, OFFSET_PERSISTER);
 const provideSynchronizer = (synchronizerId, synchronizer) =>
-  injectThing(OFFSET_SYNCHRONIZER, synchronizerId, synchronizer);
+  provideThing(synchronizerId, synchronizer, OFFSET_SYNCHRONIZER);
 
 function CheckpointView($$anchor, $$props) {
   $.push($$props, true);
@@ -584,7 +1211,9 @@ function CheckpointView($$anchor, $$props) {
 var root_2 = $.from_html(`<!><!>`, 1);
 var root$1 = $.from_html(`<!><!><!>`, 1);
 
-function ItemsView($$anchor, $$props) {
+function Wrap($$anchor, $$props) {
+  $.push($$props, true);
+
   var fragment = root$1();
   var node = $.first_child(fragment);
 
@@ -596,8 +1225,10 @@ function ItemsView($$anchor, $$props) {
       $.append($$anchor, text);
     };
 
+    var d = $.derived(() => $$props.debugIds && !isUndefined($$props.id));
+
     $.if(node, ($$render) => {
-      if ($$props.debugIds && $$props.id !== undefined) $$render(consequent);
+      if ($.get(d)) $$render(consequent);
     });
   }
 
@@ -605,9 +1236,9 @@ function ItemsView($$anchor, $$props) {
 
   $.each(
     node_1,
-    17,
+    18,
     () => $$props.ids,
-    $.index,
+    (itemId) => itemId,
     ($$anchor, itemId, i) => {
       var fragment_2 = root_2();
       var node_2 = $.first_child(fragment_2);
@@ -622,7 +1253,7 @@ function ItemsView($$anchor, $$props) {
         };
 
         $.if(node_2, ($$render) => {
-          if (i > 0 && $$props.separator) $$render(consequent_1);
+          if ($.get(i) > 0 && $$props.separator) $$render(consequent_1);
         });
       }
 
@@ -636,7 +1267,7 @@ function ItemsView($$anchor, $$props) {
           $.snippet(
             node_5,
             () => $$props.custom,
-            () => $.get(itemId),
+            () => itemId,
           );
           $.append($$anchor, fragment_4);
         };
@@ -648,7 +1279,7 @@ function ItemsView($$anchor, $$props) {
           $.snippet(
             node_6,
             () => $$props.children,
-            () => $.get(itemId),
+            () => itemId,
           );
           $.append($$anchor, fragment_5);
         };
@@ -673,12 +1304,15 @@ function ItemsView($$anchor, $$props) {
       $.append($$anchor, text_1);
     };
 
+    var d_1 = $.derived(() => $$props.debugIds && !isUndefined($$props.id));
+
     $.if(node_7, ($$render) => {
-      if ($$props.debugIds && $$props.id !== undefined) $$render(consequent_3);
+      if ($.get(d_1)) $$render(consequent_3);
     });
   }
 
   $.append($$anchor, fragment);
+  $.pop();
 }
 
 function BackwardCheckpointsView($$anchor, $$props) {
@@ -704,7 +1338,7 @@ function BackwardCheckpointsView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return $.get(ids);
       },
@@ -721,6 +1355,7 @@ function BackwardCheckpointsView($$anchor, $$props) {
         return $$props.checkpoint;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -802,8 +1437,10 @@ function CurrentCheckpointView($$anchor, $$props) {
       $.append($$anchor, fragment_1);
     };
 
+    var d = $.derived(() => !isUndefined($.get(currentId)));
+
     $.if(node, ($$render) => {
-      if ($.get(currentId) !== undefined) $$render(consequent_1);
+      if ($.get(d)) $$render(consequent_1);
     });
   }
 
@@ -834,7 +1471,7 @@ function ForwardCheckpointsView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return $.get(ids);
       },
@@ -851,6 +1488,7 @@ function ForwardCheckpointsView($$anchor, $$props) {
         return $$props.checkpoint;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -894,7 +1532,7 @@ function RowView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return $.get(activeCellIds);
       },
@@ -915,6 +1553,7 @@ function RowView($$anchor, $$props) {
         return $$props.cell;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -924,18 +1563,9 @@ function RowView($$anchor, $$props) {
 function SliceView($$anchor, $$props) {
   $.push($$props, true);
 
-  // Capture context at init to resolve Indexes → store/tableId
-  const _ctx = getContext(TINYBASE_CONTEXT_KEY) ?? [];
-
-  const _resolvedIndexes = $.derived(() =>
-    isString($$props.indexes)
-      ? objGet(_ctx[5], $$props.indexes)
-      : ($$props.indexes ?? _ctx[4]),
-  );
-
-  const _store = $.derived(() => $.get(_resolvedIndexes)?.getStore());
-  const _tableId = $.derived(() =>
-    $.get(_resolvedIndexes)?.getTableId($$props.indexId),
+  const {store, tableId} = useIndexStoreTableId(
+    () => $$props.indexes,
+    () => $$props.indexId,
   );
   const rowIds = useSliceRowIds(
     () => $$props.indexId,
@@ -952,7 +1582,7 @@ function SliceView($$anchor, $$props) {
         var consequent = ($$anchor) => {
           RowView($$anchor, {
             get tableId() {
-              return $.get(_tableId);
+              return tableId;
             },
 
             get rowId() {
@@ -960,7 +1590,7 @@ function SliceView($$anchor, $$props) {
             },
 
             get store() {
-              return $.get(_store);
+              return store;
             },
 
             get debugIds() {
@@ -970,14 +1600,14 @@ function SliceView($$anchor, $$props) {
         };
 
         $.if(node, ($$render) => {
-          if ($.get(_tableId)) $$render(consequent);
+          if (tableId) $$render(consequent);
         });
       }
 
       $.append($$anchor, fragment_1);
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -998,6 +1628,7 @@ function SliceView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1033,7 +1664,7 @@ function IndexView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return sliceIds.current;
       },
@@ -1054,6 +1685,7 @@ function IndexView($$anchor, $$props) {
         return $$props.slice;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1063,18 +1695,9 @@ function IndexView($$anchor, $$props) {
 function LinkedRowsView($$anchor, $$props) {
   $.push($$props, true);
 
-  // Capture context at init to resolve Relationships → store/tableId
-  const _ctx = getContext(TINYBASE_CONTEXT_KEY) ?? [];
-
-  const _resolvedRelationships = $.derived(() =>
-    isString($$props.relationships)
-      ? objGet(_ctx[7], $$props.relationships)
-      : ($$props.relationships ?? _ctx[6]),
-  );
-
-  const _store = $.derived(() => $.get(_resolvedRelationships)?.getStore());
-  const _tableId = $.derived(() =>
-    $.get(_resolvedRelationships)?.getLocalTableId($$props.relationshipId),
+  const {store, localTableId} = useRelationshipsStoreTableIds(
+    () => $$props.relationships,
+    () => $$props.relationshipId,
   );
   const rowIds = useLinkedRowIds(
     () => $$props.relationshipId,
@@ -1091,7 +1714,7 @@ function LinkedRowsView($$anchor, $$props) {
         var consequent = ($$anchor) => {
           RowView($$anchor, {
             get tableId() {
-              return $.get(_tableId);
+              return localTableId;
             },
 
             get rowId() {
@@ -1099,7 +1722,7 @@ function LinkedRowsView($$anchor, $$props) {
             },
 
             get store() {
-              return $.get(_store);
+              return store;
             },
 
             get debugIds() {
@@ -1109,14 +1732,14 @@ function LinkedRowsView($$anchor, $$props) {
         };
 
         $.if(node, ($$render) => {
-          if ($.get(_tableId)) $$render(consequent);
+          if (localTableId) $$render(consequent);
         });
       }
 
       $.append($$anchor, fragment_1);
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -1137,6 +1760,7 @@ function LinkedRowsView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1146,18 +1770,9 @@ function LinkedRowsView($$anchor, $$props) {
 function LocalRowsView($$anchor, $$props) {
   $.push($$props, true);
 
-  // Capture context at init to resolve Relationships → store/tableId
-  const _ctx = getContext(TINYBASE_CONTEXT_KEY) ?? [];
-
-  const _resolvedRelationships = $.derived(() =>
-    isString($$props.relationships)
-      ? objGet(_ctx[7], $$props.relationships)
-      : ($$props.relationships ?? _ctx[6]),
-  );
-
-  const _store = $.derived(() => $.get(_resolvedRelationships)?.getStore());
-  const _tableId = $.derived(() =>
-    $.get(_resolvedRelationships)?.getLocalTableId($$props.relationshipId),
+  const {store, localTableId} = useRelationshipsStoreTableIds(
+    () => $$props.relationships,
+    () => $$props.relationshipId,
   );
   const rowIds = useLocalRowIds(
     () => $$props.relationshipId,
@@ -1174,7 +1789,7 @@ function LocalRowsView($$anchor, $$props) {
         var consequent = ($$anchor) => {
           RowView($$anchor, {
             get tableId() {
-              return $.get(_tableId);
+              return localTableId;
             },
 
             get rowId() {
@@ -1182,7 +1797,7 @@ function LocalRowsView($$anchor, $$props) {
             },
 
             get store() {
-              return $.get(_store);
+              return store;
             },
 
             get debugIds() {
@@ -1192,14 +1807,14 @@ function LocalRowsView($$anchor, $$props) {
         };
 
         $.if(node, ($$render) => {
-          if ($.get(_tableId)) $$render(consequent);
+          if (localTableId) $$render(consequent);
         });
       }
 
       $.append($$anchor, fragment_1);
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -1220,6 +1835,7 @@ function LocalRowsView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1257,11 +1873,11 @@ function Provider($$anchor, $$props) {
   let extras = $.proxy(Array.from({length: 8}, () => ({})));
 
   const addThing = (offset, id, thing) => {
-    extras[offset] = {...extras[offset], [id]: thing};
+    extras[offset] = {...untrack(() => extras[offset]), [id]: thing};
   };
 
   const delThing = (offset, id) => {
-    const {[id]: _, ...rest} = extras[offset];
+    const {[id]: _, ...rest} = untrack(() => extras[offset]);
 
     extras[offset] = rest;
   };
@@ -1371,18 +1987,9 @@ var root = $.from_html(`<!><!><!>`, 1);
 function RemoteRowView($$anchor, $$props) {
   $.push($$props, true);
 
-  // Capture context at init to resolve Relationships → store/tableId
-  const _ctx = getContext(TINYBASE_CONTEXT_KEY) ?? [];
-
-  const _resolvedRelationships = $.derived(() =>
-    isString($$props.relationships)
-      ? objGet(_ctx[7], $$props.relationships)
-      : ($$props.relationships ?? _ctx[6]),
-  );
-
-  const _store = $.derived(() => $.get(_resolvedRelationships)?.getStore());
-  const _tableId = $.derived(() =>
-    $.get(_resolvedRelationships)?.getRemoteTableId($$props.relationshipId),
+  const {store, remoteTableId} = useRelationshipsStoreTableIds(
+    () => $$props.relationships,
+    () => $$props.relationshipId,
   );
   const remoteRowId = useRemoteRowId(
     () => $$props.relationshipId,
@@ -1430,7 +2037,7 @@ function RemoteRowView($$anchor, $$props) {
         var consequent_2 = ($$anchor) => {
           RowView($$anchor, {
             get tableId() {
-              return $.get(_tableId);
+              return remoteTableId;
             },
 
             get rowId() {
@@ -1438,7 +2045,7 @@ function RemoteRowView($$anchor, $$props) {
             },
 
             get store() {
-              return $.get(_store);
+              return store;
             },
 
             get debugIds() {
@@ -1449,15 +2056,17 @@ function RemoteRowView($$anchor, $$props) {
 
         $.if(node_2, ($$render) => {
           if ($$props.row) $$render(consequent_1);
-          else if ($.get(_tableId)) $$render(consequent_2, 1);
+          else if (remoteTableId) $$render(consequent_2, 1);
         });
       }
 
       $.append($$anchor, fragment_2);
     };
 
+    var d = $.derived(() => !isUndefined(remoteRowId.current));
+
     $.if(node_1, ($$render) => {
-      if (remoteRowId.current !== undefined) $$render(consequent_3);
+      if ($.get(d)) $$render(consequent_3);
     });
   }
 
@@ -1538,7 +2147,7 @@ function ResultRowView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return cellIds.current;
       },
@@ -1559,6 +2168,7 @@ function ResultRowView($$anchor, $$props) {
         return $$props.cell;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1598,7 +2208,7 @@ function ResultSortedTableView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -1619,6 +2229,7 @@ function ResultSortedTableView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1654,7 +2265,7 @@ function ResultTableView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -1675,6 +2286,7 @@ function ResultTableView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1718,7 +2330,7 @@ function SortedTableView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -1739,6 +2351,7 @@ function SortedTableView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1778,7 +2391,7 @@ function TableView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return rowIds.current;
       },
@@ -1799,6 +2412,7 @@ function TableView($$anchor, $$props) {
         return $$props.row;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1827,7 +2441,7 @@ function TablesView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return tableIds.current;
       },
@@ -1844,6 +2458,7 @@ function TablesView($$anchor, $$props) {
         return $$props.table;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1896,7 +2511,7 @@ function ValuesView($$anchor, $$props) {
       });
     };
 
-    ItemsView($$anchor, {
+    Wrap($$anchor, {
       get ids() {
         return valueIds.current;
       },
@@ -1913,6 +2528,7 @@ function ValuesView($$anchor, $$props) {
         return $$props.value;
       },
       children,
+      $$slots: {default: true},
     });
   }
 
@@ -1948,68 +2564,121 @@ export {
   SortedTableView,
   TablesView,
   TableView,
+  useBindableCell,
+  useBindableValue,
   useCell,
   useCellIds,
-  useCellState,
+  useCellIdsListener,
+  useCellListener,
   useCheckpoint,
   useCheckpointIds,
+  useCheckpointIdsListener,
+  useCheckpointListener,
   useCheckpoints,
   useCheckpointsIds,
+  useCheckpointsOrCheckpointsById,
+  useDidFinishTransactionListener,
   useGoBackwardCallback,
   useGoForwardCallback,
   useHasCell,
+  useHasCellListener,
   useHasRow,
+  useHasRowListener,
   useHasTable,
   useHasTableCell,
+  useHasTableCellListener,
+  useHasTableListener,
   useHasTables,
+  useHasTablesListener,
   useHasValue,
+  useHasValueListener,
   useHasValues,
+  useHasValuesListener,
   useIndexes,
   useIndexesIds,
+  useIndexesOrIndexesById,
   useIndexIds,
+  useIndexStoreTableId,
   useLinkedRowIds,
+  useLinkedRowIdsListener,
   useLocalRowIds,
+  useLocalRowIdsListener,
   useMetric,
   useMetricIds,
+  useMetricListener,
   useMetrics,
   useMetricsIds,
+  useMetricsOrMetricsById,
+  useParamValueListener,
+  useParamValuesListener,
   usePersister,
   usePersisterIds,
+  usePersisterOrPersisterById,
   usePersisterStatus,
+  usePersisterStatusListener,
   useQueries,
   useQueriesIds,
+  useQueriesOrQueriesById,
   useQueryIds,
   useRelationshipIds,
   useRelationships,
   useRelationshipsIds,
+  useRelationshipsOrRelationshipsById,
+  useRelationshipsStoreTableIds,
   useRemoteRowId,
+  useRemoteRowIdListener,
   useResultCell,
   useResultCellIds,
+  useResultCellIdsListener,
+  useResultCellListener,
   useResultRow,
   useResultRowCount,
+  useResultRowCountListener,
   useResultRowIds,
+  useResultRowIdsListener,
+  useResultRowListener,
   useResultSortedRowIds,
+  useResultSortedRowIdsListener,
   useResultTable,
   useResultTableCellIds,
+  useResultTableCellIdsListener,
+  useResultTableListener,
   useRow,
   useRowCount,
+  useRowCountListener,
   useRowIds,
+  useRowIdsListener,
+  useRowListener,
   useSliceIds,
+  useSliceIdsListener,
   useSliceRowIds,
+  useSliceRowIdsListener,
   useSortedRowIds,
+  useSortedRowIdsListener,
+  useStartTransactionListener,
   useStore,
   useStoreIds,
+  useStoreOrStoreById,
   useSynchronizer,
   useSynchronizerIds,
+  useSynchronizerOrSynchronizerById,
   useSynchronizerStatus,
+  useSynchronizerStatusListener,
   useTable,
   useTableCellIds,
+  useTableCellIdsListener,
   useTableIds,
+  useTableIdsListener,
+  useTableListener,
   useTables,
+  useTablesListener,
   useValue,
   useValueIds,
+  useValueIdsListener,
+  useValueListener,
   useValues,
-  useValueState,
+  useValuesListener,
+  useWillFinishTransactionListener,
   ValuesView,
   ValueView,
 };