@livestore/livestore 0.3.0-dev.5 → 0.3.0-dev.50

package/dist/store/store.js

@@ -1,72 +1,71 @@
-import { Devtools, getExecArgsFromMutation, getResultSchema, IntentionalShutdownCause, isQueryBuilder, liveStoreVersion, makeClientSessionSyncProcessor, prepareBindValues, QueryBuilderAstSymbol, replaceSessionIdSymbol, } from '@livestore/common';
-import { MutationEvent, SCHEMA_META_TABLE, SCHEMA_MUTATIONS_META_TABLE, SESSION_CHANGESET_META_TABLE, } from '@livestore/common/schema';
-import { assertNever, isDevEnv } from '@livestore/utils';
-import { Cause, Data, Effect, Inspectable, MutableHashMap, Runtime, Schema } from '@livestore/utils/effect';
+import { Devtools, getDurationMsFromSpan, getExecArgsFromEvent, getResultSchema, IntentionalShutdownCause, isQueryBuilder, liveStoreVersion, makeClientSessionSyncProcessor, prepareBindValues, QueryBuilderAstSymbol, replaceSessionIdSymbol, } from '@livestore/common';
+import { getEventDef, LiveStoreEvent, SystemTables } from '@livestore/common/schema';
+import { assertNever, isDevEnv, notYetImplemented } from '@livestore/utils';
+import { Cause, Effect, Fiber, Inspectable, OtelTracer, Runtime, Schema, Stream } from '@livestore/utils/effect';
 import { nanoid } from '@livestore/utils/nanoid';
 import * as otel from '@opentelemetry/api';
-import { makeExecBeforeFirstRun } from '../row-query-utils.js';
-import { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js';
+import { makeReactivityGraph } from '../live-queries/base-class.js';
+import { makeExecBeforeFirstRun } from '../live-queries/client-document-get-query.js';
+import { SqliteDbWrapper } from '../SqliteDbWrapper.js';
 import { ReferenceCountedSet } from '../utils/data-structures.js';
 import { downloadBlob, exposeDebugUtils } from '../utils/dev.js';
-import { getDurationMsFromSpan } from '../utils/otel.js';
 if (isDevEnv()) {
     exposeDebugUtils();
 }
 export class Store extends Inspectable.Class {
     storeId;
     reactivityGraph;
-    syncDbWrapper;
+    sqliteDbWrapper;
     clientSession;
     schema;
-    graphQLSchema;
-    graphQLContext;
+    context;
     otel;
     /**
      * Note we're using `Ref<null>` here as we don't care about the value but only about *that* something has changed.
      * This only works in combination with `equal: () => false` which will always trigger a refresh.
      */
     tableRefs;
-    runtime;
+    effectContext;
     /** RC-based set to see which queries are currently subscribed to */
     activeQueries;
-    // NOTE this is currently exposed for the Devtools databrowser to emit mutation events
-    __mutationEventSchema;
-    unsyncedMutationEvents;
+    // NOTE this is currently exposed for the Devtools databrowser to commit events
+    __eventSchema;
     syncProcessor;
-    lifetimeScope;
+    boot;
     // #region constructor
-    constructor({ clientSession, schema, graphQLOptions, reactivityGraph, otelOptions, disableDevtools, batchUpdates, unsyncedMutationEvents, storeId, lifetimeScope, runtime, }) {
+    constructor({ clientSession, schema, otelOptions, context, batchUpdates, storeId, effectContext, params, confirmUnsavedChanges, __runningInDevtools, }) {
         super();
         this.storeId = storeId;
-        this.unsyncedMutationEvents = unsyncedMutationEvents;
-        this.syncDbWrapper = new SynchronousDatabaseWrapper({ otel: otelOptions, db: clientSession.syncDb });
+        this.sqliteDbWrapper = new SqliteDbWrapper({ otel: otelOptions, db: clientSession.sqliteDb });
         this.clientSession = clientSession;
         this.schema = schema;
-        this.lifetimeScope = lifetimeScope;
-        this.runtime = runtime;
+        this.context = context;
+        this.effectContext = effectContext;
+        const reactivityGraph = makeReactivityGraph();
         const syncSpan = otelOptions.tracer.startSpan('LiveStore:sync', {}, otelOptions.rootSpanContext);
         this.syncProcessor = makeClientSessionSyncProcessor({
             schema,
-            initialLeaderHead: clientSession.leaderThread.mutations.initialMutationEventId,
-            // rebaseBehaviour: 'auto-rebase',
-            pushToLeader: (batch) => clientSession.leaderThread.mutations.push(batch).pipe(
-            // NOTE we don't want to shutdown in case of an invalid push error, since it will be retried
-            Effect.catchTag('InvalidPushError', Effect.ignoreLogged), this.runEffectFork),
-            pullFromLeader: clientSession.leaderThread.mutations.pull,
-            applyMutation: (mutationEventDecoded, { otelContext, withChangeset }) => {
-                const mutationDef = schema.mutations.get(mutationEventDecoded.mutation);
-                const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded });
+            clientSession,
+            runtime: effectContext.runtime,
+            materializeEvent: (eventDecoded, { otelContext, withChangeset }) => {
+                const { eventDef, materializer } = getEventDef(schema, eventDecoded.name);
+                const execArgsArr = getExecArgsFromEvent({
+                    eventDef,
+                    materializer,
+                    db: this.sqliteDbWrapper,
+                    event: { decoded: eventDecoded, encoded: undefined },
+                });
                 const writeTablesForEvent = new Set();
                 const exec = () => {
-                    for (const { statementSql, bindValues, writeTables = this.syncDbWrapper.getTablesUsed(statementSql), } of execArgsArr) {
-                        this.syncDbWrapper.execute(statementSql, bindValues, writeTables, { otelContext });
+                    for (const { statementSql, bindValues, writeTables = this.sqliteDbWrapper.getTablesUsed(statementSql), } of execArgsArr) {
+                        this.sqliteDbWrapper.execute(statementSql, bindValues, { otelContext, writeTables });
                         // durationMsTotal += durationMs
                         writeTables.forEach((table) => writeTablesForEvent.add(table));
                     }
                 };
-                let sessionChangeset;
+                let sessionChangeset = { _tag: 'unset' };
                 if (withChangeset === true) {
-                    sessionChangeset = this.syncDbWrapper.withChangeset(exec).changeset;
+                    sessionChangeset = this.sqliteDbWrapper.withChangeset(exec).changeset;
                 }
                 else {
                     exec();
@@ -74,7 +73,7 @@ export class Store extends Inspectable.Class {
                 return { writeTables: writeTablesForEvent, sessionChangeset };
             },
             rollback: (changeset) => {
-                this.syncDbWrapper.rollback(changeset);
+                this.sqliteDbWrapper.rollback(changeset);
             },
             refreshTables: (tables) => {
                 const tablesToUpdate = [];
@@ -83,51 +82,57 @@ export class Store extends Inspectable.Class {
                     assertNever(tableRef !== undefined, `No table ref found for ${tableName}`);
                     tablesToUpdate.push([tableRef, null]);
                 }
-                this.reactivityGraph.setRefs(tablesToUpdate);
+                reactivityGraph.setRefs(tablesToUpdate);
             },
             span: syncSpan,
+            params: {
+                leaderPushBatchSize: params.leaderPushBatchSize,
+            },
+            confirmUnsavedChanges,
         });
-        this.__mutationEventSchema = MutationEvent.makeMutationEventSchemaMemo(schema);
+        this.__eventSchema = LiveStoreEvent.makeEventDefSchemaMemo(schema);
         // TODO generalize the `tableRefs` concept to allow finer-grained refs
         this.tableRefs = {};
         this.activeQueries = new ReferenceCountedSet();
-        const mutationsSpan = otelOptions.tracer.startSpan('LiveStore:mutations', {}, otelOptions.rootSpanContext);
-        const otelMuationsSpanContext = otel.trace.setSpan(otel.context.active(), mutationsSpan);
+        const commitsSpan = otelOptions.tracer.startSpan('LiveStore:commits', {}, otelOptions.rootSpanContext);
+        const otelMuationsSpanContext = otel.trace.setSpan(otel.context.active(), commitsSpan);
         const queriesSpan = otelOptions.tracer.startSpan('LiveStore:queries', {}, otelOptions.rootSpanContext);
         const otelQueriesSpanContext = otel.trace.setSpan(otel.context.active(), queriesSpan);
         this.reactivityGraph = reactivityGraph;
         this.reactivityGraph.context = {
             store: this,
+            defRcMap: new Map(),
+            reactivityGraph: new WeakRef(reactivityGraph),
             otelTracer: otelOptions.tracer,
             rootOtelContext: otelQueriesSpanContext,
             effectsWrapper: batchUpdates,
         };
         this.otel = {
             tracer: otelOptions.tracer,
-            mutationsSpanContext: otelMuationsSpanContext,
+            rootSpanContext: otelOptions.rootSpanContext,
+            commitsSpanContext: otelMuationsSpanContext,
             queriesSpanContext: otelQueriesSpanContext,
         };
-        // TODO find a better way to detect if we're running LiveStore in the LiveStore devtools
-        // But for now this is a good enough approximation with little downsides
-        const isRunningInDevtools = disableDevtools === true;
         // Need a set here since `schema.tables` might contain duplicates and some componentStateTables
         const allTableNames = new Set(
-        // NOTE we're excluding the LiveStore schema and mutations tables as they are not user-facing
+        // NOTE we're excluding the LiveStore schema and events tables as they are not user-facing
         // unless LiveStore is running in the devtools
-        isRunningInDevtools
-            ? this.schema.tables.keys()
-            : Array.from(this.schema.tables.keys()).filter((_) => _ !== SCHEMA_META_TABLE && _ !== SCHEMA_MUTATIONS_META_TABLE && _ !== SESSION_CHANGESET_META_TABLE));
+        __runningInDevtools
+            ? this.schema.state.sqlite.tables.keys()
+            : Array.from(this.schema.state.sqlite.tables.keys()).filter((_) => !SystemTables.isStateSystemTable(_)));
         const existingTableRefs = new Map(Array.from(this.reactivityGraph.atoms.values())
             .filter((_) => _._tag === 'ref' && _.label?.startsWith('tableRef:') === true)
             .map((_) => [_.label.slice('tableRef:'.length), _]));
         for (const tableName of allTableNames) {
-            this.tableRefs[tableName] = existingTableRefs.get(tableName) ?? this.makeTableRef(tableName);
-        }
-        if (graphQLOptions) {
-            this.graphQLSchema = graphQLOptions.schema;
-            this.graphQLContext = graphQLOptions.makeContext(this.syncDbWrapper, this.otel.tracer, clientSession.sessionId);
+            this.tableRefs[tableName] =
+                existingTableRefs.get(tableName) ??
+                    this.reactivityGraph.makeRef(null, {
+                        equal: () => false,
+                        label: `tableRef:${tableName}`,
+                        meta: { liveStoreRefType: 'table' },
+                    });
         }
-        Effect.gen(this, function* () {
+        this.boot = Effect.gen(this, function* () {
             yield* Effect.addFinalizer(() => Effect.sync(() => {
                 // Remove all table refs from the reactivity graph
                 for (const tableRef of Object.values(this.tableRefs)) {
@@ -137,47 +142,59 @@ export class Store extends Inspectable.Class {
                 }
                 // End the otel spans
                 syncSpan.end();
-                mutationsSpan.end();
+                commitsSpan.end();
                 queriesSpan.end();
             }));
             yield* this.syncProcessor.boot;
-        }).pipe(this.runEffectFork);
+        });
     }
     // #endregion constructor
-    static createStore = (storeOptions, parentSpan) => {
-        const ctx = otel.trace.setSpan(otel.context.active(), parentSpan);
-        return storeOptions.otelOptions.tracer.startActiveSpan('LiveStore:createStore', {}, ctx, (span) => {
-            try {
-                return new Store(storeOptions);
-            }
-            finally {
-                span.end();
-            }
-        });
-    };
     get sessionId() {
         return this.clientSession.sessionId;
     }
+    get clientId() {
+        return this.clientSession.clientId;
+    }
     /**
      * Subscribe to the results of a query
      * Returns a function to cancel the subscription.
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = store.subscribe(query$, { onUpdate: (result) => console.log(result) })
+     * ```
      */
-    subscribe = (query$, onNewValue, onUnsubsubscribe, options) => this.otel.tracer.startActiveSpan(`LiveStore.subscribe`, { attributes: { label: options?.label, queryLabel: query$.label } }, options?.otelContext ?? this.otel.queriesSpanContext, (span) => {
+    subscribe = (query, options) => this.otel.tracer.startActiveSpan(`LiveStore.subscribe`, { attributes: { label: options?.label, queryLabel: query.label } }, options?.otelContext ?? this.otel.queriesSpanContext, (span) => {
         // console.debug('store sub', query$.id, query$.label)
         const otelContext = otel.trace.setSpan(otel.context.active(), span);
+        const queryRcRef = query._tag === 'def'
+            ? query.make(this.reactivityGraph.context)
+            : {
+                value: query,
+                deref: () => { },
+            };
+        const query$ = queryRcRef.value;
         const label = `subscribe:${options?.label}`;
-        const effect = this.reactivityGraph.makeEffect((get) => onNewValue(get(query$.results$)), { label });
+        const effect = this.reactivityGraph.makeEffect((get, _otelContext, debugRefreshReason) => options.onUpdate(get(query$.results$, otelContext, debugRefreshReason)), { label });
+        if (options?.stackInfo) {
+            query$.activeSubscriptions.add(options.stackInfo);
+        }
+        options?.onSubscribe?.(query$);
         this.activeQueries.add(query$);
         // Running effect right away to get initial value (unless `skipInitialRun` is set)
-        if (options?.skipInitialRun !== true) {
-            effect.doEffect(otelContext);
+        if (options?.skipInitialRun !== true && !query$.isDestroyed) {
+            effect.doEffect(otelContext, { _tag: 'subscribe.initial', label: `subscribe-initial-run:${options?.label}` });
         }
         const unsubscribe = () => {
             // console.debug('store unsub', query$.id, query$.label)
             try {
                 this.reactivityGraph.destroyNode(effect);
                 this.activeQueries.remove(query$);
-                onUnsubsubscribe?.();
+                if (options?.stackInfo) {
+                    query$.activeSubscriptions.delete(options.stackInfo);
+                }
+                queryRcRef.deref();
+                options?.onUnsubsubscribe?.();
             }
             finally {
                 span.end();
@@ -185,6 +202,15 @@ export class Store extends Inspectable.Class {
         };
         return unsubscribe;
     });
+    subscribeStream = (query$, options) => Stream.asyncPush((emit) => Effect.gen(this, function* () {
+        const otelSpan = yield* OtelTracer.currentOtelSpan.pipe(Effect.catchTag('NoSuchElementException', () => Effect.succeed(undefined)));
+        const otelContext = otelSpan ? otel.trace.setSpan(otel.context.active(), otelSpan) : otel.context.active();
+        yield* Effect.acquireRelease(Effect.sync(() => this.subscribe(query$, {
+            onUpdate: (result) => emit.single(result),
+            otelContext,
+            label: options?.label,
+        })), (unsub) => Effect.sync(() => unsub()));
+    }));
     /**
      * Synchronously queries the database without creating a LiveQuery.
      * This is useful for queries that don't need to be reactive.
@@ -201,8 +227,7 @@ export class Store extends Inspectable.Class {
      */
     query = (query, options) => {
         if (typeof query === 'object' && 'query' in query && 'bindValues' in query) {
-            return this.syncDbWrapper.select(query.query, {
-                bindValues: prepareBindValues(query.bindValues, query.query),
+            return this.sqliteDbWrapper.select(query.query, prepareBindValues(query.bindValues, query.query), {
                 otelContext: options?.otelContext,
             });
         }
@@ -212,53 +237,145 @@ export class Store extends Inspectable.Class {
                 makeExecBeforeFirstRun({
                     table: ast.tableDef,
                     id: ast.id,
-                    insertValues: ast.insertValues,
+                    explicitDefaultValues: ast.explicitDefaultValues,
                     otelContext: options?.otelContext,
                 })(this.reactivityGraph.context);
             }
             const sqlRes = query.asSql();
             const schema = getResultSchema(query);
-            const rawRes = this.syncDbWrapper.select(sqlRes.query, {
-                bindValues: sqlRes.bindValues,
+            const rawRes = this.sqliteDbWrapper.select(sqlRes.query, sqlRes.bindValues, {
                 otelContext: options?.otelContext,
                 queriedTables: new Set([query[QueryBuilderAstSymbol].tableDef.sqliteDef.name]),
             });
             return Schema.decodeSync(schema)(rawRes);
         }
+        else if (query._tag === 'def') {
+            const query$ = query.make(this.reactivityGraph.context);
+            const result = this.query(query$.value, options);
+            query$.deref();
+            return result;
+        }
+        else if (query._tag === 'signal-def') {
+            const signal$ = query.make(this.reactivityGraph.context);
+            return signal$.value.get();
+        }
         else {
-            return query.run(options?.otelContext);
+            return query.run({ otelContext: options?.otelContext, debugRefreshReason: options?.debugRefreshReason });
         }
     };
-    // #region mutate
-    mutate = (firstMutationOrTxnFnOrOptions, ...restMutations) => {
-        const { mutationsEvents, options } = this.getMutateArgs(firstMutationOrTxnFnOrOptions, restMutations);
-        for (const mutationEvent of mutationsEvents) {
-            replaceSessionIdSymbol(mutationEvent.args, this.clientSession.sessionId);
+    /**
+     * Set the value of a signal
+     *
+     * @example
+     * ```ts
+     * const count$ = signal(0, { label: 'count$' })
+     * store.setSignal(count$, 2)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const count$ = signal(0, { label: 'count$' })
+     * store.setSignal(count$, (prev) => prev + 1)
+     * ```
+     */
+    setSignal = (signalDef, value) => {
+        const signalRef = signalDef.make(this.reactivityGraph.context);
+        const newValue = typeof value === 'function' ? value(signalRef.value.get()) : value;
+        signalRef.value.set(newValue);
+        // The current implementation of signals i.e. the separation into `signal-def` and `signal`
+        // can lead to a situation where a reffed signal is immediately de-reffed when calling `store.setSignal`,
+        // in case there is nothing else holding a reference to the signal which leads to the set value being "lost".
+        // To avoid this, we don't deref the signal here if this set call is the only reference to the signal.
+        // Hopefully this won't lead to any issues in the future. 🤞
+        if (signalRef.rc > 1) {
+            signalRef.deref();
+        }
+    };
+    // #region commit
+    /**
+     * Commit a list of events to the store which will immediately update the local database
+     * and sync the events across other clients (similar to a `git commit`).
+     *
+     * @example
+     * ```ts
+     * store.commit(events.todoCreated({ id: nanoid(), text: 'Make coffee' }))
+     * ```
+     *
+     * You can call `commit` with multiple events to apply them in a single database transaction.
+     *
+     * @example
+     * ```ts
+     * const todoId = nanoid()
+     * store.commit(
+     *   events.todoCreated({ id: todoId, text: 'Make coffee' }),
+     *   events.todoCompleted({ id: todoId }))
+     * ```
+     *
+     * For more advanced transaction scenarios, you can pass a synchronous function to `commit` which will receive a callback
+     * to which you can pass multiple events to be committed in the same database transaction.
+     * Under the hood this will simply collect all events and apply them in a single database transaction.
+     *
+     * @example
+     * ```ts
+     * store.commit((commit) => {
+     *   const todoId = nanoid()
+     *   if (Math.random() > 0.5) {
+     *     commit(events.todoCreated({ id: todoId, text: 'Make coffee' }))
+     *   } else {
+     *     commit(events.todoCompleted({ id: todoId }))
+     *   }
+     * })
+     * ```
+     *
+     * When committing a large batch of events, you can also skip the database refresh to improve performance
+     * and call `store.manualRefresh()` after all events have been committed.
+     *
+     * @example
+     * ```ts
+     * const todos = [
+     *   { id: nanoid(), text: 'Make coffee' },
+     *   { id: nanoid(), text: 'Buy groceries' },
+     *   // ... 1000 more todos
+     * ]
+     * for (const todo of todos) {
+     *   store.commit({ skipRefresh: true }, events.todoCreated({ id: todo.id, text: todo.text }))
+     * }
+     * store.manualRefresh()
+     * ```
+     */
+    commit = (firstEventOrTxnFnOrOptions, ...restEvents) => {
+        const { events, options } = this.getCommitArgs(firstEventOrTxnFnOrOptions, restEvents);
+        for (const event of events) {
+            replaceSessionIdSymbol(event.args, this.clientSession.sessionId);
         }
-        if (mutationsEvents.length === 0)
+        if (events.length === 0)
             return;
-        const label = options?.label ?? 'mutate';
         const skipRefresh = options?.skipRefresh ?? false;
-        const mutationsSpan = otel.trace.getSpan(this.otel.mutationsSpanContext);
-        mutationsSpan.addEvent('mutate');
-        // console.group('LiveStore.mutate', { skipRefresh, wasSyncMessage, label })
-        // mutationsEvents.forEach((_) => console.debug(_.mutation, _.id, _.args))
+        const commitsSpan = otel.trace.getSpan(this.otel.commitsSpanContext);
+        commitsSpan.addEvent('commit');
+        // console.group('LiveStore.commit', { skipRefresh })
+        // events.forEach((_) => console.debug(_.name, _.args))
         // console.groupEnd()
         let durationMs;
-        return this.otel.tracer.startActiveSpan('LiveStore:mutate', { attributes: { 'livestore.mutateLabel': label }, links: options?.spanLinks }, options?.otelContext ?? this.otel.mutationsSpanContext, (span) => {
+        return this.otel.tracer.startActiveSpan('LiveStore:commit', {
+            attributes: {
+                'livestore.eventsCount': events.length,
+                'livestore.eventTags': events.map((_) => _.name),
+                'livestore.commitLabel': options?.label,
+            },
+            links: options?.spanLinks,
+        }, options?.otelContext ?? this.otel.commitsSpanContext, (span) => {
             const otelContext = otel.trace.setSpan(otel.context.active(), span);
             try {
-                const { writeTables } = this.otel.tracer.startActiveSpan('LiveStore:mutate:applyMutations', { attributes: { 'livestore.mutateLabel': label } }, otel.trace.setSpan(otel.context.active(), span), (span) => {
+                const { writeTables } = (() => {
                     try {
-                        const otelContext = otel.trace.setSpan(otel.context.active(), span);
-                        // 5
-                        const applyMutations = () => this.syncProcessor.push(mutationsEvents, { otelContext });
-                        if (mutationsEvents.length > 1) {
+                        const materializeEvents = () => this.syncProcessor.push(events, { otelContext });
+                        if (events.length > 1) {
                             // TODO: what to do about leader transaction here?
-                            return this.syncDbWrapper.txn(applyMutations);
+                            return this.sqliteDbWrapper.txn(materializeEvents);
                         }
                         else {
-                            return applyMutations();
+                            return materializeEvents();
                         }
                     }
                     catch (e) {
@@ -269,7 +386,7 @@ export class Store extends Inspectable.Class {
                     finally {
                         span.end();
                     }
-                });
+                })();
                 const tablesToUpdate = [];
                 for (const tableName of writeTables) {
                     const tableRef = this.tableRefs[tableName];
@@ -277,8 +394,8 @@ export class Store extends Inspectable.Class {
                     tablesToUpdate.push([tableRef, null]);
                 }
                 const debugRefreshReason = {
-                    _tag: 'mutate',
-                    mutations: mutationsEvents,
+                    _tag: 'commit',
+                    events,
                     writeTables: Array.from(writeTables),
                 };
                 // Update all table refs together in a batch, to only trigger one reactive update
@@ -296,85 +413,134 @@ export class Store extends Inspectable.Class {
             return { durationMs };
         });
     };
-    // #endregion mutate
+    // #endregion commit
     /**
-     * This can be used in combination with `skipRefresh` when applying mutations.
+     * Returns an async iterable of events.
+     *
+     * @example
+     * ```ts
+     * for await (const event of store.events()) {
+     *   console.log(event)
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Get all events from the beginning of time
+     * for await (const event of store.events({ cursor: EventSequenceNumber.ROOT })) {
+     *   console.log(event)
+     * }
+     * ```
+     */
+    events = (_options) => {
+        return notYetImplemented(`store.events() is not yet implemented but planned soon`);
+    };
+    eventsStream = (_options) => {
+        return notYetImplemented(`store.eventsStream() is not yet implemented but planned soon`);
+    };
+    /**
+     * This can be used in combination with `skipRefresh` when committing events.
      * We might need a better solution for this. Let's see.
      */
     manualRefresh = (options) => {
         const { label } = options ?? {};
-        this.otel.tracer.startActiveSpan('LiveStore:manualRefresh', { attributes: { 'livestore.manualRefreshLabel': label } }, this.otel.mutationsSpanContext, (span) => {
+        this.otel.tracer.startActiveSpan('LiveStore:manualRefresh', { attributes: { 'livestore.manualRefreshLabel': label } }, this.otel.commitsSpanContext, (span) => {
             const otelContext = otel.trace.setSpan(otel.context.active(), span);
             this.reactivityGraph.runDeferredEffects({ otelContext });
             span.end();
         });
     };
-    makeTableRef = (tableName) => this.reactivityGraph.makeRef(null, {
-        equal: () => false,
-        label: `tableRef:${tableName}`,
-        meta: { liveStoreRefType: 'table' },
-    });
-    __devDownloadDb = (source = 'local') => {
-        Effect.gen(this, function* () {
-            const data = source === 'local' ? this.syncDbWrapper.export() : yield* this.clientSession.leaderThread.export;
-            downloadBlob(data, `livestore-${Date.now()}.db`);
-        }).pipe(this.runEffectFork);
-    };
-    __devDownloadMutationLogDb = () => {
-        Effect.gen(this, function* () {
-            const data = yield* this.clientSession.leaderThread.getMutationLogData;
-            downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`);
-        }).pipe(this.runEffectFork);
-    };
-    __devHardReset = (mode = 'all-data') => {
-        Effect.gen(this, function* () {
-            yield* this.clientSession.leaderThread.sendDevtoolsMessage(Devtools.ResetAllDataReq.make({ liveStoreVersion, mode, requestId: nanoid() }));
-        }).pipe(this.runEffectFork);
-    };
-    __devSyncStates = () => {
-        Effect.gen(this, function* () {
-            const session = this.syncProcessor.syncStateRef.current;
-            console.log('Session sync state:', session);
-            const leader = yield* this.clientSession.leaderThread.getSyncState;
-            console.log('Leader sync state:', leader);
-        }).pipe(this.runEffectFork);
-    };
-    __devShutdown = (cause) => {
-        this.clientSession
+    /**
+     * Shuts down the store and closes the client session.
+     *
+     * This is called automatically when the store was created using the React or Effect API.
+     */
+    shutdown = async (cause) => {
+        await this.clientSession
             .shutdown(cause ?? Cause.fail(IntentionalShutdownCause.make({ reason: 'manual' })))
-            .pipe(Effect.tapCauseLogPretty, Effect.provide(this.runtime), Effect.runFork);
+            .pipe(this.runEffectFork, Fiber.join, Effect.runPromise);
+    };
+    /**
+     * Helper methods useful during development
+     *
+     * @internal
+     */
+    _dev = {
+        downloadDb: (source = 'local') => {
+            Effect.gen(this, function* () {
+                const data = source === 'local' ? this.sqliteDbWrapper.export() : yield* this.clientSession.leaderThread.export;
+                downloadBlob(data, `livestore-${Date.now()}.db`);
+            }).pipe(this.runEffectFork);
+        },
+        downloadEventlogDb: () => {
+            Effect.gen(this, function* () {
+                const data = yield* this.clientSession.leaderThread.getEventlogData;
+                downloadBlob(data, `livestore-eventlog-${Date.now()}.db`);
+            }).pipe(this.runEffectFork);
+        },
+        hardReset: (mode = 'all-data') => {
+            Effect.gen(this, function* () {
+                const clientId = this.clientSession.clientId;
+                yield* this.clientSession.leaderThread.sendDevtoolsMessage(Devtools.Leader.ResetAllData.Request.make({ liveStoreVersion, mode, requestId: nanoid(), clientId }));
+            }).pipe(this.runEffectFork);
+        },
+        overrideNetworkStatus: (status) => {
+            const clientId = this.clientSession.clientId;
+            this.clientSession.leaderThread
+                .sendDevtoolsMessage(Devtools.Leader.SetSyncLatch.Request.make({
+                clientId,
+                closeLatch: status === 'offline',
+                liveStoreVersion,
+                requestId: nanoid(),
+            }))
+                .pipe(this.runEffectFork);
+        },
+        syncStates: () => {
+            Effect.gen(this, function* () {
+                const session = yield* this.syncProcessor.syncState;
+                console.log('Session sync state:', session.toJSON());
+                const leader = yield* this.clientSession.leaderThread.getSyncState;
+                console.log('Leader sync state:', leader.toJSON());
+            }).pipe(this.runEffectFork);
+        },
+        version: liveStoreVersion,
+        otel: {
+            rootSpanContext: () => otel.trace.getSpan(this.otel.rootSpanContext)?.spanContext(),
+        },
     };
     // NOTE This is needed because when booting a Store via Effect it seems to call `toJSON` in the error path
     toJSON = () => ({
         _tag: 'livestore.Store',
         reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults: true }),
     });
-    runEffectFork = (effect) => effect.pipe(Effect.forkIn(this.lifetimeScope), Effect.tapCauseLogPretty, Runtime.runFork(this.runtime));
-    getMutateArgs = (firstMutationOrTxnFnOrOptions, restMutations) => {
-        let mutationsEvents;
+    runEffectFork = (effect) => effect.pipe(Effect.forkIn(this.effectContext.lifetimeScope), Effect.tapCauseLogPretty, Runtime.runFork(this.effectContext.runtime));
+    getCommitArgs = (firstEventOrTxnFnOrOptions, restEvents) => {
+        let events;
         let options;
-        if (typeof firstMutationOrTxnFnOrOptions === 'function') {
+        if (typeof firstEventOrTxnFnOrOptions === 'function') {
             // TODO ensure that function is synchronous and isn't called in a async way (also write tests for this)
-            mutationsEvents = firstMutationOrTxnFnOrOptions((arg) => mutationsEvents.push(arg));
+            events = firstEventOrTxnFnOrOptions((arg) => events.push(arg));
         }
-        else if (firstMutationOrTxnFnOrOptions?.label !== undefined ||
-            firstMutationOrTxnFnOrOptions?.skipRefresh !== undefined ||
-            firstMutationOrTxnFnOrOptions?.otelContext !== undefined ||
-            firstMutationOrTxnFnOrOptions?.spanLinks !== undefined) {
-            options = firstMutationOrTxnFnOrOptions;
-            mutationsEvents = restMutations;
+        else if (firstEventOrTxnFnOrOptions?.label !== undefined ||
+            firstEventOrTxnFnOrOptions?.skipRefresh !== undefined ||
+            firstEventOrTxnFnOrOptions?.otelContext !== undefined ||
+            firstEventOrTxnFnOrOptions?.spanLinks !== undefined) {
+            options = firstEventOrTxnFnOrOptions;
+            events = restEvents;
         }
-        else if (firstMutationOrTxnFnOrOptions === undefined) {
-            // When `mutate` is called with no arguments (which sometimes happens when dynamically filtering mutations)
-            mutationsEvents = [];
+        else if (firstEventOrTxnFnOrOptions === undefined) {
+            // When `commit` is called with no arguments (which sometimes happens when dynamically filtering events)
+            events = [];
         }
         else {
-            mutationsEvents = [firstMutationOrTxnFnOrOptions, ...restMutations];
+            events = [firstEventOrTxnFnOrOptions, ...restEvents];
         }
-        mutationsEvents = mutationsEvents.filter(
-        // @ts-expect-error TODO
-        (_) => _.id === undefined || !MutableHashMap.has(this.unsyncedMutationEvents, Data.struct(_.id)));
-        return { mutationsEvents, options };
+        // for (const event of events) {
+        //   if (event.args.id === SessionIdSymbol) {
+        //     event.args.id = this.clientSession.sessionId
+        //   }
+        // }
+        return { events, options };
     };
 }
 //# sourceMappingURL=store.js.map