tinybase 8.1.0-beta.0 → 8.1.0-beta.2

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

@@ -0,0 +1,2684 @@
+import {getContext, setContext, untrack} from 'svelte';
+import * as $ from 'svelte/internal/client';
+import 'svelte/internal/disclose-version';
+
+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';
+const ADD = 'add';
+const HAS = 'Has';
+const _HAS = 'has';
+const IDS = 'Ids';
+const TABLE = 'Table';
+const TABLES = TABLE + 's';
+const TABLE_IDS = TABLE + IDS;
+const ROW = 'Row';
+const ROW_COUNT = ROW + 'Count';
+const ROW_IDS = ROW + IDS;
+const SORTED_ROW_IDS = 'Sorted' + ROW + IDS;
+const CELL = 'Cell';
+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';
+const SLICE = 'Slice';
+const RELATIONSHIP = 'Relationship';
+const REMOTE_ROW_ID = 'Remote' + ROW + 'Id';
+const LOCAL = 'Local';
+const LINKED = 'Linked';
+const QUERY = 'Query';
+const CHECKPOINT = 'Checkpoint';
+
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  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;
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+
+const TINYBASE_CONTEXT_KEY = TINYBASE + '_uisc';
+
+/* 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 OFFSET_STORE = 0;
+const OFFSET_METRICS = 1;
+const OFFSET_INDEXES = 2;
+const OFFSET_RELATIONSHIPS = 3;
+const OFFSET_QUERIES = 4;
+const OFFSET_CHECKPOINTS = 5;
+const OFFSET_PERSISTER = 6;
+const OFFSET_SYNCHRONIZER = 7;
+const maybeGet = (thing) => (isFunction(thing) ? thing() : thing);
+const getContextValue = () => getContext(TINYBASE_CONTEXT_KEY) ?? [];
+
+const getThing = (contextValue, thingOrThingId, offset) =>
+  isUndefined(thingOrThingId)
+    ? contextValue[offset * 2]
+    : isString(thingOrThingId)
+      ? objGet(contextValue[offset * 2 + 1], thingOrThingId)
+      : thingOrThingId;
+
+const useThing = (thingOrThingId, offset) =>
+  getThing(getContextValue(), thingOrThingId, offset);
+
+const useThingOrThingById = (thingOrThingId, offset) => {
+  const contextValue = getContextValue();
+
+  return () => getThing(contextValue, maybeGet(thingOrThingId), offset);
+};
+
+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 = (
+  getThing2,
+  listenable,
+  defaultValue,
+  getArgs = () => EMPTY_ARR,
+  isHas,
+) => {
+  const getMethod = (isHas ? _HAS : GET) + listenable;
+  const addMethod = ADD + (isHas ? HAS : '') + listenable + LISTENER;
+  let value = $.state(
+    $.proxy(getThing2()?.[getMethod]?.(...getArgs()) ?? defaultValue),
+  );
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const thing = getThing2();
+      const args = getArgs();
+
+      $.set(value, thing?.[getMethod]?.(...args) ?? defaultValue, true);
+
+      const listenerId = thing?.[addMethod]?.(...args, () => {
+        $.set(value, thing[getMethod](...getArgs()) ?? defaultValue, true);
+      });
+
+      return () => thing?.delListener?.(listenerId);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(value);
+    },
+  };
+};
+
+const useListener = (
+  getThing2,
+  listenable,
+  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 useHasTables = (storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLES,
+    false,
+    () => EMPTY_ARR,
+    1,
+  );
+const useTables = (storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), TABLES, EMPTY_OBJ);
+const useTableIds = (storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), TABLE_IDS, EMPTY_ARR);
+const useHasTable = (tableId, storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE,
+    false,
+    () => [maybeGet(tableId)],
+    1,
+  );
+const useTable = (tableId, storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), TABLE, EMPTY_OBJ, () => [
+    maybeGet(tableId),
+  ]);
+const useTableCellIds = (tableId, storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE + CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(tableId)],
+  );
+const useHasTableCell = (tableId, cellId, storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    TABLE + CELL,
+    false,
+    () => [maybeGet(tableId), maybeGet(cellId)],
+    1,
+  );
+const useRowCount = (tableId, storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), ROW_COUNT, 0, () => [
+    maybeGet(tableId),
+  ]);
+const useRowIds = (tableId, storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), ROW_IDS, EMPTY_ARR, () => [
+    maybeGet(tableId),
+  ]);
+
+const useSortedRowIds = (
+  tableId,
+  cellId,
+  descending = false,
+  offset = 0,
+  limit,
+  storeOrStoreId,
+) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    SORTED_ROW_IDS,
+    EMPTY_ARR,
+    () => [
+      maybeGet(tableId),
+      maybeGet(cellId),
+      maybeGet(descending),
+      maybeGet(offset),
+      maybeGet(limit),
+    ],
+  );
+
+const useHasRow = (tableId, rowId, storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    ROW,
+    false,
+    () => [maybeGet(tableId), maybeGet(rowId)],
+    1,
+  );
+const useRow = (tableId, rowId, storeOrStoreId) =>
+  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) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    CELL,
+    false,
+    () => [maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)],
+    1,
+  );
+const useCell = (tableId, rowId, cellId, storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), CELL, void 0, () => [
+    maybeGet(tableId),
+    maybeGet(rowId),
+    maybeGet(cellId),
+  ]);
+
+const useBindableCell = (tableId, rowId, cellId, storeOrStoreId) => {
+  const getS = useStoreOrStoreById(storeOrStoreId);
+  let value = $.state(
+    $.proxy(
+      getS()?.getCell(maybeGet(tableId), maybeGet(rowId), maybeGet(cellId)),
+    ),
+  );
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const s = getS();
+
+      const t = maybeGet(tableId),
+        r = maybeGet(rowId),
+        c = maybeGet(cellId);
+
+      $.set(value, s?.getCell(t, r, c), 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 {
+    get current() {
+      return $.get(value);
+    },
+
+    set current(v) {
+      getS()?.setCell(maybeGet(tableId), maybeGet(rowId), maybeGet(cellId), v);
+    },
+  };
+};
+
+const useHasValues = (storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUES,
+    false,
+    () => EMPTY_ARR,
+    1,
+  );
+const useValues = (storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), VALUES, EMPTY_OBJ);
+const useValueIds = (storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), VALUE_IDS, EMPTY_ARR);
+const useHasValue = (valueId, storeOrStoreId) =>
+  useListenable(
+    useStoreOrStoreById(storeOrStoreId),
+    VALUE,
+    false,
+    () => [maybeGet(valueId)],
+    1,
+  );
+const useValue = (valueId, storeOrStoreId) =>
+  useListenable(useStoreOrStoreById(storeOrStoreId), VALUE, void 0, () => [
+    maybeGet(valueId),
+  ]);
+
+const useBindableValue = (valueId, storeOrStoreId) => {
+  const getS = useStoreOrStoreById(storeOrStoreId);
+  let value = $.state($.proxy(getS()?.getValue(maybeGet(valueId))));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      const s = getS();
+      const vid = maybeGet(valueId);
+
+      $.set(value, s?.getValue(vid), true);
+
+      const listenerId = s?.addValueListener(vid, (st) => {
+        $.set(value, st.getValue(maybeGet(valueId)), true);
+      });
+
+      return () => s?.delListener?.(listenerId);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(value);
+    },
+
+    set current(v) {
+      getS()?.setValue(maybeGet(valueId), v);
+    },
+  };
+};
+
+const useStore = (id) => useThing(id, OFFSET_STORE);
+
+const useStoreIds = () => {
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_STORE)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_STORE), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useMetrics = (id) => useThing(id, OFFSET_METRICS);
+
+const useMetricsIds = () => {
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_METRICS)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_METRICS), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useMetricIds = (metricsOrMetricsId) =>
+  useListenable(
+    useMetricsOrMetricsById(metricsOrMetricsId),
+    METRIC + IDS,
+    EMPTY_ARR,
+  );
+const useMetric = (metricId, metricsOrMetricsId) =>
+  useListenable(
+    useMetricsOrMetricsById(metricsOrMetricsId),
+    METRIC,
+    void 0,
+    () => [maybeGet(metricId)],
+  );
+const useIndexes = (id) => useThing(id, OFFSET_INDEXES);
+
+const useIndexesIds = () => {
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_INDEXES)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_INDEXES), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useIndexIds = (indexesOrIndexesId) =>
+  useListenable(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    INDEX + IDS,
+    EMPTY_ARR,
+  );
+const useSliceIds = (indexId, indexesOrIndexesId) =>
+  useListenable(
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    SLICE + IDS,
+    EMPTY_ARR,
+    () => [maybeGet(indexId)],
+  );
+const useSliceRowIds = (indexId, sliceId, indexesOrIndexesId) =>
+  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 contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_QUERIES)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_QUERIES), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useQueryIds = (queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    QUERY + IDS,
+    EMPTY_ARR,
+  );
+const useResultTable = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + TABLE,
+    EMPTY_OBJ,
+    () => [maybeGet(queryId)],
+  );
+const useResultTableCellIds = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + TABLE + CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(queryId)],
+  );
+const useResultRowCount = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW_COUNT,
+    0,
+    () => [maybeGet(queryId)],
+  );
+const useResultRowIds = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(queryId)],
+  );
+
+const useResultSortedRowIds = (
+  queryId,
+  cellId,
+  descending = false,
+  offset = 0,
+  limit,
+  queriesOrQueriesId,
+) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + SORTED_ROW_IDS,
+    EMPTY_ARR,
+    () => [
+      maybeGet(queryId),
+      maybeGet(cellId),
+      maybeGet(descending),
+      maybeGet(offset),
+      maybeGet(limit),
+    ],
+  );
+
+const useResultRow = (queryId, rowId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + ROW,
+    EMPTY_OBJ,
+    () => [maybeGet(queryId), maybeGet(rowId)],
+  );
+const useResultCellIds = (queryId, rowId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + CELL_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(queryId), maybeGet(rowId)],
+  );
+const useResultCell = (queryId, rowId, cellId, queriesOrQueriesId) =>
+  useListenable(
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    RESULT + CELL,
+    void 0,
+    () => [maybeGet(queryId), maybeGet(rowId), maybeGet(cellId)],
+  );
+const useRelationships = (id) => useThing(id, OFFSET_RELATIONSHIPS);
+
+const useRelationshipsIds = () => {
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_RELATIONSHIPS)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_RELATIONSHIPS), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useRelationshipIds = (relationshipsOrRelationshipsId) =>
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    RELATIONSHIP + IDS,
+    EMPTY_ARR,
+  );
+const useRemoteRowId = (
+  relationshipId,
+  localRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    REMOTE_ROW_ID,
+    void 0,
+    () => [maybeGet(relationshipId), maybeGet(localRowId)],
+  );
+const useLocalRowIds = (
+  relationshipId,
+  remoteRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    LOCAL + ROW_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(relationshipId), maybeGet(remoteRowId)],
+  );
+const useLinkedRowIds = (
+  relationshipId,
+  firstRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    LINKED + ROW_IDS,
+    EMPTY_ARR,
+    () => [maybeGet(relationshipId), maybeGet(firstRowId)],
+  );
+
+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 contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_CHECKPOINTS)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_CHECKPOINTS), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useCheckpointIds = (checkpointsOrCheckpointsId) =>
+  useListenable(
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    CHECKPOINT + IDS,
+    DEFAULT_CHECKPOINT_IDS,
+  );
+const useCheckpoint = (checkpointId, checkpointsOrCheckpointsId) =>
+  useListenable(
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    CHECKPOINT,
+    void 0,
+    () => [maybeGet(checkpointId)],
+  );
+
+const useGoBackwardCallback = (checkpointsOrCheckpointsId) => {
+  const getC = useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId);
+
+  return () => getC()?.goBackward();
+};
+
+const useGoForwardCallback = (checkpointsOrCheckpointsId) => {
+  const getC = useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId);
+
+  return () => getC()?.goForward();
+};
+
+const usePersister = (id) => useThing(id, OFFSET_PERSISTER);
+
+const usePersisterIds = () => {
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_PERSISTER)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_PERSISTER), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const usePersisterStatus = (persisterOrPersisterId) =>
+  useListenable(usePersisterOrPersisterById(persisterOrPersisterId), STATUS, 0);
+const useSynchronizer = (id) => useThing(id, OFFSET_SYNCHRONIZER);
+
+const useSynchronizerIds = () => {
+  const contextValue = getContextValue();
+  let ids = $.state($.proxy(getThingIds(contextValue, OFFSET_SYNCHRONIZER)));
+
+  if (typeof window !== 'undefined') {
+    $.user_effect(() => {
+      $.set(ids, getThingIds(contextValue, OFFSET_SYNCHRONIZER), true);
+    });
+  }
+
+  return {
+    get current() {
+      return $.get(ids);
+    },
+  };
+};
+
+const useSynchronizerStatus = (synchronizerOrSynchronizerId) =>
+  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 useLinkedRowIdsListener = (
+  relationshipId,
+  firstRowId,
+  listener,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    LINKED + ROW_IDS,
+    listener,
+    () => [maybeGet(relationshipId), maybeGet(firstRowId)],
+  );
+
+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),
+    ],
+  );
+
+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) =>
+  provideThing(storeId, store, OFFSET_STORE);
+const provideMetrics = (metricsId, metrics) =>
+  provideThing(metricsId, metrics, OFFSET_METRICS);
+const provideIndexes = (indexesId, indexes) =>
+  provideThing(indexesId, indexes, OFFSET_INDEXES);
+const provideRelationships = (relationshipsId, relationships) =>
+  provideThing(relationshipsId, relationships, OFFSET_RELATIONSHIPS);
+const provideQueries = (queriesId, queries) =>
+  provideThing(queriesId, queries, OFFSET_QUERIES);
+const provideCheckpoints = (checkpointsId, checkpoints) =>
+  provideThing(checkpointsId, checkpoints, OFFSET_CHECKPOINTS);
+const providePersister = (persisterId, persister) =>
+  provideThing(persisterId, persister, OFFSET_PERSISTER);
+const provideSynchronizer = (synchronizerId, synchronizer) =>
+  provideThing(synchronizerId, synchronizer, OFFSET_SYNCHRONIZER);
+
+function CheckpointView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const checkpoint = useCheckpoint(
+    () => $$props.checkpointId,
+    () => $$props.checkpoints,
+  );
+  const display = $.derived(() => '' + (checkpoint.current ?? ''));
+
+  const output = $.derived(() =>
+    $$props.debugIds
+      ? `${$$props.checkpointId}:{${$.get(display)}}`
+      : $.get(display),
+  );
+
+  $.next();
+
+  var text = $.text();
+
+  $.template_effect(() => $.set_text(text, $.get(output)));
+  $.append($$anchor, text);
+  $.pop();
+}
+
+var root_2 = $.from_html(`<!><!>`, 1);
+var root$1 = $.from_html(`<!><!><!>`, 1);
+
+function Wrap($$anchor, $$props) {
+  $.push($$props, true);
+
+  var fragment = root$1();
+  var node = $.first_child(fragment);
+
+  {
+    var consequent = ($$anchor) => {
+      var text = $.text();
+
+      $.template_effect(() => $.set_text(text, `${$$props.id ?? ''}:{`));
+      $.append($$anchor, text);
+    };
+
+    var d = $.derived(() => $$props.debugIds && !isUndefined($$props.id));
+
+    $.if(node, ($$render) => {
+      if ($.get(d)) $$render(consequent);
+    });
+  }
+
+  var node_1 = $.sibling(node);
+
+  $.each(
+    node_1,
+    18,
+    () => $$props.ids,
+    (itemId) => itemId,
+    ($$anchor, itemId, i) => {
+      var fragment_2 = root_2();
+      var node_2 = $.first_child(fragment_2);
+
+      {
+        var consequent_1 = ($$anchor) => {
+          var fragment_3 = $.comment();
+          var node_3 = $.first_child(fragment_3);
+
+          $.snippet(node_3, () => $$props.separator);
+          $.append($$anchor, fragment_3);
+        };
+
+        $.if(node_2, ($$render) => {
+          if ($.get(i) > 0 && $$props.separator) $$render(consequent_1);
+        });
+      }
+
+      var node_4 = $.sibling(node_2);
+
+      {
+        var consequent_2 = ($$anchor) => {
+          var fragment_4 = $.comment();
+          var node_5 = $.first_child(fragment_4);
+
+          $.snippet(
+            node_5,
+            () => $$props.custom,
+            () => itemId,
+          );
+          $.append($$anchor, fragment_4);
+        };
+
+        var alternate = ($$anchor) => {
+          var fragment_5 = $.comment();
+          var node_6 = $.first_child(fragment_5);
+
+          $.snippet(
+            node_6,
+            () => $$props.children,
+            () => itemId,
+          );
+          $.append($$anchor, fragment_5);
+        };
+
+        $.if(node_4, ($$render) => {
+          if ($$props.custom) $$render(consequent_2);
+          else $$render(alternate, -1);
+        });
+      }
+
+      $.append($$anchor, fragment_2);
+    },
+  );
+
+  var node_7 = $.sibling(node_1);
+
+  {
+    var consequent_3 = ($$anchor) => {
+      var text_1 = $.text();
+
+      text_1.nodeValue = '}';
+      $.append($$anchor, text_1);
+    };
+
+    var d_1 = $.derived(() => $$props.debugIds && !isUndefined($$props.id));
+
+    $.if(node_7, ($$render) => {
+      if ($.get(d_1)) $$render(consequent_3);
+    });
+  }
+
+  $.append($$anchor, fragment);
+  $.pop();
+}
+
+function BackwardCheckpointsView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const checkpointIds = useCheckpointIds(() => $$props.checkpoints);
+  const ids = $.derived(() => checkpointIds.current[0]);
+
+  {
+    const children = ($$anchor, checkpointId = $.noop) => {
+      CheckpointView($$anchor, {
+        get checkpointId() {
+          return checkpointId();
+        },
+
+        get checkpoints() {
+          return $$props.checkpoints;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return $.get(ids);
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get custom() {
+        return $$props.checkpoint;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function CellView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const cell = useCell(
+    () => $$props.tableId,
+    () => $$props.rowId,
+    () => $$props.cellId,
+    () => $$props.store,
+  );
+  const display = $.derived(() => '' + (cell.current ?? ''));
+
+  const output = $.derived(() =>
+    $$props.debugIds ? `${$$props.cellId}:{${$.get(display)}}` : $.get(display),
+  );
+
+  $.next();
+
+  var text = $.text();
+
+  $.template_effect(() => $.set_text(text, $.get(output)));
+  $.append($$anchor, text);
+  $.pop();
+}
+
+function CurrentCheckpointView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const checkpointIds = useCheckpointIds(() => $$props.checkpoints);
+  const currentId = $.derived(() => checkpointIds.current[1]);
+  var fragment = $.comment();
+  var node = $.first_child(fragment);
+
+  {
+    var consequent_1 = ($$anchor) => {
+      var fragment_1 = $.comment();
+      var node_1 = $.first_child(fragment_1);
+
+      {
+        var consequent = ($$anchor) => {
+          var fragment_2 = $.comment();
+          var node_2 = $.first_child(fragment_2);
+
+          $.snippet(
+            node_2,
+            () => $$props.checkpoint,
+            () => $.get(currentId),
+          );
+          $.append($$anchor, fragment_2);
+        };
+
+        var alternate = ($$anchor) => {
+          CheckpointView($$anchor, {
+            get checkpointId() {
+              return $.get(currentId);
+            },
+
+            get checkpoints() {
+              return $$props.checkpoints;
+            },
+
+            get debugIds() {
+              return $$props.debugIds;
+            },
+          });
+        };
+
+        $.if(node_1, ($$render) => {
+          if ($$props.checkpoint) $$render(consequent);
+          else $$render(alternate, -1);
+        });
+      }
+
+      $.append($$anchor, fragment_1);
+    };
+
+    var d = $.derived(() => !isUndefined($.get(currentId)));
+
+    $.if(node, ($$render) => {
+      if ($.get(d)) $$render(consequent_1);
+    });
+  }
+
+  $.append($$anchor, fragment);
+  $.pop();
+}
+
+function ForwardCheckpointsView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const checkpointIds = useCheckpointIds(() => $$props.checkpoints);
+  const ids = $.derived(() => checkpointIds.current[2]);
+
+  {
+    const children = ($$anchor, checkpointId = $.noop) => {
+      CheckpointView($$anchor, {
+        get checkpointId() {
+          return checkpointId();
+        },
+
+        get checkpoints() {
+          return $$props.checkpoints;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return $.get(ids);
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get custom() {
+        return $$props.checkpoint;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function RowView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const defaultCellIds = useCellIds(
+    () => $$props.tableId,
+    () => $$props.rowId,
+    () => $$props.store,
+  );
+  const activeCellIds = $.derived(
+    () => $$props.customCellIds ?? defaultCellIds.current,
+  );
+
+  {
+    const children = ($$anchor, cellId = $.noop) => {
+      CellView($$anchor, {
+        get tableId() {
+          return $$props.tableId;
+        },
+
+        get rowId() {
+          return $$props.rowId;
+        },
+
+        get cellId() {
+          return cellId();
+        },
+
+        get store() {
+          return $$props.store;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return $.get(activeCellIds);
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.rowId;
+      },
+
+      get custom() {
+        return $$props.cell;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function SliceView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const {store, tableId} = useIndexStoreTableId(
+    () => $$props.indexes,
+    () => $$props.indexId,
+  );
+  const rowIds = useSliceRowIds(
+    () => $$props.indexId,
+    () => $$props.sliceId,
+    () => $$props.indexes,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      var fragment_1 = $.comment();
+      var node = $.first_child(fragment_1);
+
+      {
+        var consequent = ($$anchor) => {
+          RowView($$anchor, {
+            get tableId() {
+              return tableId;
+            },
+
+            get rowId() {
+              return rowId();
+            },
+
+            get store() {
+              return store;
+            },
+
+            get debugIds() {
+              return $$props.debugIds;
+            },
+          });
+        };
+
+        $.if(node, ($$render) => {
+          if (tableId) $$render(consequent);
+        });
+      }
+
+      $.append($$anchor, fragment_1);
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.sliceId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function IndexView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const sliceIds = useSliceIds(
+    () => $$props.indexId,
+    () => $$props.indexes,
+  );
+
+  {
+    const children = ($$anchor, sliceId = $.noop) => {
+      SliceView($$anchor, {
+        get indexId() {
+          return $$props.indexId;
+        },
+
+        get sliceId() {
+          return sliceId();
+        },
+
+        get indexes() {
+          return $$props.indexes;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return sliceIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.indexId;
+      },
+
+      get custom() {
+        return $$props.slice;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function LinkedRowsView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const {store, localTableId} = useRelationshipsStoreTableIds(
+    () => $$props.relationships,
+    () => $$props.relationshipId,
+  );
+  const rowIds = useLinkedRowIds(
+    () => $$props.relationshipId,
+    () => $$props.firstRowId,
+    () => $$props.relationships,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      var fragment_1 = $.comment();
+      var node = $.first_child(fragment_1);
+
+      {
+        var consequent = ($$anchor) => {
+          RowView($$anchor, {
+            get tableId() {
+              return localTableId;
+            },
+
+            get rowId() {
+              return rowId();
+            },
+
+            get store() {
+              return store;
+            },
+
+            get debugIds() {
+              return $$props.debugIds;
+            },
+          });
+        };
+
+        $.if(node, ($$render) => {
+          if (localTableId) $$render(consequent);
+        });
+      }
+
+      $.append($$anchor, fragment_1);
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.firstRowId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function LocalRowsView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const {store, localTableId} = useRelationshipsStoreTableIds(
+    () => $$props.relationships,
+    () => $$props.relationshipId,
+  );
+  const rowIds = useLocalRowIds(
+    () => $$props.relationshipId,
+    () => $$props.remoteRowId,
+    () => $$props.relationships,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      var fragment_1 = $.comment();
+      var node = $.first_child(fragment_1);
+
+      {
+        var consequent = ($$anchor) => {
+          RowView($$anchor, {
+            get tableId() {
+              return localTableId;
+            },
+
+            get rowId() {
+              return rowId();
+            },
+
+            get store() {
+              return store;
+            },
+
+            get debugIds() {
+              return $$props.debugIds;
+            },
+          });
+        };
+
+        $.if(node, ($$render) => {
+          if (localTableId) $$render(consequent);
+        });
+      }
+
+      $.append($$anchor, fragment_1);
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.remoteRowId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function MetricView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const metric = useMetric(
+    () => $$props.metricId,
+    () => $$props.metrics,
+  );
+  const display = $.derived(() => '' + (metric.current ?? ''));
+
+  const output = $.derived(() =>
+    $$props.debugIds
+      ? `${$$props.metricId}:{${$.get(display)}}`
+      : $.get(display),
+  );
+
+  $.next();
+
+  var text = $.text();
+
+  $.template_effect(() => $.set_text(text, $.get(output)));
+  $.append($$anchor, text);
+  $.pop();
+}
+
+function Provider($$anchor, $$props) {
+  $.push($$props, true);
+
+  const parentCtx = getContext(TINYBASE_CONTEXT_KEY) ?? [];
+  let extras = $.proxy(Array.from({length: 8}, () => ({})));
+
+  const addThing = (offset, id, thing) => {
+    extras[offset] = {...untrack(() => extras[offset]), [id]: thing};
+  };
+
+  const delThing = (offset, id) => {
+    const {[id]: _, ...rest} = untrack(() => extras[offset]);
+
+    extras[offset] = rest;
+  };
+
+  const ctx = {
+    get [0]() {
+      return $$props.store ?? parentCtx[0];
+    },
+
+    get [1]() {
+      return {...(parentCtx[1] ?? {}), ...$$props.storesById, ...extras[0]};
+    },
+
+    get [2]() {
+      return $$props.metrics ?? parentCtx[2];
+    },
+
+    get [3]() {
+      return {...(parentCtx[3] ?? {}), ...$$props.metricsById, ...extras[1]};
+    },
+
+    get [4]() {
+      return $$props.indexes ?? parentCtx[4];
+    },
+
+    get [5]() {
+      return {...(parentCtx[5] ?? {}), ...$$props.indexesById, ...extras[2]};
+    },
+
+    get [6]() {
+      return $$props.relationships ?? parentCtx[6];
+    },
+
+    get [7]() {
+      return {
+        ...(parentCtx[7] ?? {}),
+        ...$$props.relationshipsById,
+        ...extras[3],
+      };
+    },
+
+    get [8]() {
+      return $$props.queries ?? parentCtx[8];
+    },
+
+    get [9]() {
+      return {...(parentCtx[9] ?? {}), ...$$props.queriesById, ...extras[4]};
+    },
+
+    get [10]() {
+      return $$props.checkpoints ?? parentCtx[10];
+    },
+
+    get [11]() {
+      return {
+        ...(parentCtx[11] ?? {}),
+        ...$$props.checkpointsById,
+        ...extras[5],
+      };
+    },
+
+    get [12]() {
+      return $$props.persister ?? parentCtx[12];
+    },
+
+    get [13]() {
+      return {
+        ...(parentCtx[13] ?? {}),
+        ...$$props.persistersById,
+        ...extras[6],
+      };
+    },
+
+    get [14]() {
+      return $$props.synchronizer ?? parentCtx[14];
+    },
+
+    get [15]() {
+      return {
+        ...(parentCtx[15] ?? {}),
+        ...$$props.synchronizersById,
+        ...extras[7],
+      };
+    },
+
+    get [16]() {
+      return addThing;
+    },
+
+    get [17]() {
+      return delThing;
+    },
+  };
+
+  setContext(TINYBASE_CONTEXT_KEY, ctx);
+
+  var fragment = $.comment();
+  var node = $.first_child(fragment);
+
+  $.snippet(node, () => $$props.children);
+  $.append($$anchor, fragment);
+  $.pop();
+}
+
+var root = $.from_html(`<!><!><!>`, 1);
+
+function RemoteRowView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const {store, remoteTableId} = useRelationshipsStoreTableIds(
+    () => $$props.relationships,
+    () => $$props.relationshipId,
+  );
+  const remoteRowId = useRemoteRowId(
+    () => $$props.relationshipId,
+    () => $$props.localRowId,
+    () => $$props.relationships,
+  );
+  var fragment = root();
+  var node = $.first_child(fragment);
+
+  {
+    var consequent = ($$anchor) => {
+      var text = $.text();
+
+      $.template_effect(() =>
+        $.set_text(text, `${$$props.localRowId ?? ''}:{`),
+      );
+      $.append($$anchor, text);
+    };
+
+    $.if(node, ($$render) => {
+      if ($$props.debugIds) $$render(consequent);
+    });
+  }
+
+  var node_1 = $.sibling(node);
+
+  {
+    var consequent_3 = ($$anchor) => {
+      var fragment_2 = $.comment();
+      var node_2 = $.first_child(fragment_2);
+
+      {
+        var consequent_1 = ($$anchor) => {
+          var fragment_3 = $.comment();
+          var node_3 = $.first_child(fragment_3);
+
+          $.snippet(
+            node_3,
+            () => $$props.row,
+            () => remoteRowId.current,
+          );
+          $.append($$anchor, fragment_3);
+        };
+
+        var consequent_2 = ($$anchor) => {
+          RowView($$anchor, {
+            get tableId() {
+              return remoteTableId;
+            },
+
+            get rowId() {
+              return remoteRowId.current;
+            },
+
+            get store() {
+              return store;
+            },
+
+            get debugIds() {
+              return $$props.debugIds;
+            },
+          });
+        };
+
+        $.if(node_2, ($$render) => {
+          if ($$props.row) $$render(consequent_1);
+          else if (remoteTableId) $$render(consequent_2, 1);
+        });
+      }
+
+      $.append($$anchor, fragment_2);
+    };
+
+    var d = $.derived(() => !isUndefined(remoteRowId.current));
+
+    $.if(node_1, ($$render) => {
+      if ($.get(d)) $$render(consequent_3);
+    });
+  }
+
+  var node_4 = $.sibling(node_1);
+
+  {
+    var consequent_4 = ($$anchor) => {
+      var text_1 = $.text();
+
+      text_1.nodeValue = '}';
+      $.append($$anchor, text_1);
+    };
+
+    $.if(node_4, ($$render) => {
+      if ($$props.debugIds) $$render(consequent_4);
+    });
+  }
+
+  $.append($$anchor, fragment);
+  $.pop();
+}
+
+function ResultCellView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const cell = useResultCell(
+    () => $$props.queryId,
+    () => $$props.rowId,
+    () => $$props.cellId,
+    () => $$props.queries,
+  );
+  const display = $.derived(() => '' + (cell.current ?? ''));
+
+  const output = $.derived(() =>
+    $$props.debugIds ? `${$$props.cellId}:{${$.get(display)}}` : $.get(display),
+  );
+
+  $.next();
+
+  var text = $.text();
+
+  $.template_effect(() => $.set_text(text, $.get(output)));
+  $.append($$anchor, text);
+  $.pop();
+}
+
+function ResultRowView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const cellIds = useResultCellIds(
+    () => $$props.queryId,
+    () => $$props.rowId,
+    () => $$props.queries,
+  );
+
+  {
+    const children = ($$anchor, cellId = $.noop) => {
+      ResultCellView($$anchor, {
+        get queryId() {
+          return $$props.queryId;
+        },
+
+        get rowId() {
+          return $$props.rowId;
+        },
+
+        get cellId() {
+          return cellId();
+        },
+
+        get queries() {
+          return $$props.queries;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return cellIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.rowId;
+      },
+
+      get custom() {
+        return $$props.cell;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function ResultSortedTableView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const rowIds = useResultSortedRowIds(
+    () => $$props.queryId,
+    () => $$props.cellId,
+    () => $$props.descending ?? false,
+    () => $$props.offset ?? 0,
+    () => $$props.limit,
+    () => $$props.queries,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      ResultRowView($$anchor, {
+        get queryId() {
+          return $$props.queryId;
+        },
+
+        get rowId() {
+          return rowId();
+        },
+
+        get queries() {
+          return $$props.queries;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.queryId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function ResultTableView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const rowIds = useResultRowIds(
+    () => $$props.queryId,
+    () => $$props.queries,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      ResultRowView($$anchor, {
+        get queryId() {
+          return $$props.queryId;
+        },
+
+        get rowId() {
+          return rowId();
+        },
+
+        get queries() {
+          return $$props.queries;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.queryId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function SortedTableView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const rowIds = useSortedRowIds(
+    () => $$props.tableId,
+    () => $$props.cellId,
+    () => $$props.descending ?? false,
+    () => $$props.offset ?? 0,
+    () => $$props.limit,
+    () => $$props.store,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      RowView($$anchor, {
+        get tableId() {
+          return $$props.tableId;
+        },
+
+        get rowId() {
+          return rowId();
+        },
+
+        get store() {
+          return $$props.store;
+        },
+
+        get customCellIds() {
+          return $$props.customCellIds;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.tableId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function TableView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const rowIds = useRowIds(
+    () => $$props.tableId,
+    () => $$props.store,
+  );
+
+  {
+    const children = ($$anchor, rowId = $.noop) => {
+      RowView($$anchor, {
+        get tableId() {
+          return $$props.tableId;
+        },
+
+        get rowId() {
+          return rowId();
+        },
+
+        get store() {
+          return $$props.store;
+        },
+
+        get customCellIds() {
+          return $$props.customCellIds;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return rowIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get id() {
+        return $$props.tableId;
+      },
+
+      get custom() {
+        return $$props.row;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function TablesView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const tableIds = useTableIds(() => $$props.store);
+
+  {
+    const children = ($$anchor, tableId = $.noop) => {
+      TableView($$anchor, {
+        get tableId() {
+          return tableId();
+        },
+
+        get store() {
+          return $$props.store;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return tableIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get custom() {
+        return $$props.table;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+function ValueView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const value = useValue(
+    () => $$props.valueId,
+    () => $$props.store,
+  );
+  const display = $.derived(() => '' + (value.current ?? ''));
+
+  const output = $.derived(() =>
+    $$props.debugIds
+      ? `${$$props.valueId}:{${$.get(display)}}`
+      : $.get(display),
+  );
+
+  $.next();
+
+  var text = $.text();
+
+  $.template_effect(() => $.set_text(text, $.get(output)));
+  $.append($$anchor, text);
+  $.pop();
+}
+
+function ValuesView($$anchor, $$props) {
+  $.push($$props, true);
+
+  const valueIds = useValueIds(() => $$props.store);
+
+  {
+    const children = ($$anchor, valueId = $.noop) => {
+      ValueView($$anchor, {
+        get valueId() {
+          return valueId();
+        },
+
+        get store() {
+          return $$props.store;
+        },
+
+        get debugIds() {
+          return $$props.debugIds;
+        },
+      });
+    };
+
+    Wrap($$anchor, {
+      get ids() {
+        return valueIds.current;
+      },
+
+      get separator() {
+        return $$props.separator;
+      },
+
+      get debugIds() {
+        return $$props.debugIds;
+      },
+
+      get custom() {
+        return $$props.value;
+      },
+      children,
+      $$slots: {default: true},
+    });
+  }
+
+  $.pop();
+}
+
+export {
+  BackwardCheckpointsView,
+  CellView,
+  CheckpointView,
+  CurrentCheckpointView,
+  ForwardCheckpointsView,
+  IndexView,
+  LinkedRowsView,
+  LocalRowsView,
+  MetricView,
+  provideCheckpoints,
+  provideIndexes,
+  provideMetrics,
+  providePersister,
+  provideQueries,
+  Provider,
+  provideRelationships,
+  provideStore,
+  provideSynchronizer,
+  RemoteRowView,
+  ResultCellView,
+  ResultRowView,
+  ResultSortedTableView,
+  ResultTableView,
+  RowView,
+  SliceView,
+  SortedTableView,
+  TablesView,
+  TableView,
+  useBindableCell,
+  useBindableValue,
+  useCell,
+  useCellIds,
+  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,
+  useValuesListener,
+  useWillFinishTransactionListener,
+  ValuesView,
+  ValueView,
+};