@livestore/livestore 0.0.54-dev.21 → 0.0.54-dev.24

package/dist/store.js

@@ -1,17 +1,19 @@
-import { Devtools, getExecArgsFromMutation, prepareBindValues } from '@livestore/common';
-import { version as liveStoreVersion } from '@livestore/common/package.json';
+import { Devtools, getExecArgsFromMutation, liveStoreVersion, prepareBindValues } from '@livestore/common';
 import { makeMutationEventSchemaMemo } from '@livestore/common/schema';
-import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen } from '@livestore/utils';
-import { Effect, Schema, Stream } from '@livestore/utils/effect';
+import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen, throttle } from '@livestore/utils';
+import { cuid } from '@livestore/utils/cuid';
+import { Effect, Layer, Logger, LogLevel, OtelTracer, Queue, Schema, Stream } from '@livestore/utils/effect';
 import * as otel from '@opentelemetry/api';
 import { globalReactivityGraph } from './global-state.js';
 import { MainDatabaseWrapper } from './MainDatabaseWrapper.js';
+import { NOT_REFRESHED_YET } from './reactive.js';
 import { downloadBlob } from './utils/dev.js';
 import { getDurationMsFromSpan } from './utils/otel.js';
 let storeCount = 0;
 const uniqueStoreId = () => `store-${++storeCount}`;
 export class Store {
     id = uniqueStoreId();
+    devtoolsConnectionId = cuid();
     reactivityGraph;
     mainDbWrapper;
     adapter;
@@ -25,17 +27,19 @@ export class Store {
      */
     tableRefs;
     // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
-    __processedMutationIds = new Set();
+    __processedMutationIds;
     __processedMutationWithoutRefreshIds = new Set();
     /** RC-based set to see which queries are currently subscribed to */
     activeQueries;
     __mutationEventSchema;
-    constructor({ adapter, schema, graphQLOptions, reactivityGraph, otelOptions, disableDevtools, }) {
+    constructor({ adapter, schema, graphQLOptions, reactivityGraph, otelOptions, disableDevtools, __processedMutationIds, }) {
         this.mainDbWrapper = new MainDatabaseWrapper({ otel: otelOptions, db: adapter.mainDb });
         this.adapter = adapter;
         this.schema = schema;
         // TODO refactor
         this.__mutationEventSchema = makeMutationEventSchemaMemo(schema);
+        // TODO remove this temporary solution and find a better way to avoid re-processing the same mutation
+        this.__processedMutationIds = __processedMutationIds;
         // TODO generalize the `tableRefs` concept to allow finer-grained refs
         this.tableRefs = {};
         this.activeQueries = new ReferenceCountedSet();
@@ -51,7 +55,7 @@ export class Store {
         };
         this.adapter.coordinator.syncMutations.pipe(Stream.tapSync((mutationEventDecoded) => {
             this.mutate({ wasSyncMessage: true }, mutationEventDecoded);
-        }), Stream.runDrain, Effect.tapCauseLogPretty, Effect.runFork);
+        }), Stream.runDrain, runEffectFork);
         if (disableDevtools !== true) {
             this.bootDevtools();
         }
@@ -124,7 +128,7 @@ export class Store {
         }
         otel.trace.getSpan(this.otel.mutationsSpanContext).end();
         otel.trace.getSpan(this.otel.queriesSpanContext).end();
-        await this.adapter.coordinator.shutdown();
+        await this.adapter.coordinator.shutdown.pipe(runEffectPromise);
     };
     mutate = (firstMutationOrTxnFnOrOptions, ...restMutations) => {
         let mutationsEvents;
@@ -278,10 +282,9 @@ export class Store {
             const mutationEventEncoded = Schema.encodeUnknownSync(this.__mutationEventSchema)(mutationEventDecoded);
             if (coordinatorMode !== 'skip-coordinator') {
                 // Asynchronously apply mutation to a persistent storage (we're not awaiting this promise here)
-                void this.adapter.coordinator.mutate(mutationEventEncoded, {
-                    span,
-                    persisted: coordinatorMode !== 'skip-persist',
-                });
+                this.adapter.coordinator
+                    .mutate(mutationEventEncoded, { persisted: coordinatorMode !== 'skip-persist' })
+                    .pipe(runEffectFork);
             }
             // Uncomment to print a list of queries currently registered on the store
             // console.debug(JSON.parse(JSON.stringify([...this.queries].map((q) => `${labelForKey(q.componentKey)}/${q.label}`))))
@@ -296,8 +299,7 @@ export class Store {
      */
     execute = (query, params = {}, writeTables, otelContext) => {
         this.mainDbWrapper.execute(query, prepareBindValues(params, query), writeTables, { otelContext });
-        const parentSpan = otel.trace.getSpan(otel.context.active());
-        this.adapter.coordinator.execute(query, prepareBindValues(params, query), parentSpan);
+        this.adapter.coordinator.execute(query, prepareBindValues(params, query)).pipe(runEffectFork);
     };
     select = (query, params = {}) => {
         return this.mainDbWrapper.select(query, { bindValues: prepareBindValues(params, query) });
@@ -307,191 +309,323 @@ export class Store {
         label: `tableRef:${tableName}`,
         meta: { liveStoreRefType: 'table' },
     });
+    // TODO shutdown behaviour
     bootDevtools = () => {
-        const devtoolsChannel = Devtools.makeBroadcastChannels();
-        const reactivityGraphSubcriptions = new Map();
-        const liveQueriesSubscriptions = new Map();
-        devtoolsChannel.toAppHost.addEventListener('message', async (event) => {
-            const decoded = Schema.decodeUnknownOption(Devtools.MessageToAppHost)(event.data);
-            if (decoded._tag === 'None' ||
-                decoded.value._tag === 'LSD.DevtoolsReady' ||
-                decoded.value._tag === 'LSD.DevtoolsConnected' ||
-                decoded.value.channelId !== this.adapter.coordinator.devtools.channelId) {
-                // console.log(`Unknown message`, event)
+        const sendToDevtoolsContentscript = (message) => {
+            window.postMessage(Schema.encodeSync(Devtools.DevtoolsWindowMessage.MessageForContentscript)(message), '*');
+        };
+        const channelId = this.adapter.coordinator.devtools.channelId;
+        window.addEventListener('message', (event) => {
+            const decodedMessageRes = Schema.decodeOption(Devtools.DevtoolsWindowMessage.MessageForStore)(event.data);
+            if (decodedMessageRes._tag === 'None')
+                return;
+            const message = decodedMessageRes.value;
+            if (message._tag === 'LSD.WindowMessage.ContentscriptListening') {
+                sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }));
                 return;
             }
-            const requestId = decoded.value.requestId;
-            const sendToDevtools = (message) => devtoolsChannel.fromAppHost.postMessage(Schema.encodeSync(Devtools.MessageFromAppHost)(message));
-            switch (decoded.value._tag) {
-                case 'LSD.ReactivityGraphSubscribe': {
-                    const includeResults = decoded.value.includeResults;
-                    const send = () => sendToDevtools(Devtools.ReactivityGraphRes.make({
-                        reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
-                        requestId,
-                        liveStoreVersion,
-                    }));
-                    send();
-                    reactivityGraphSubcriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(() => send()));
-                    break;
-                }
-                case 'LSD.DebugInfoReq': {
-                    sendToDevtools(Devtools.DebugInfoRes.make({ debugInfo: this.mainDbWrapper.debugInfo, requestId, liveStoreVersion }));
-                    break;
-                }
-                case 'LSD.DebugInfoResetReq': {
-                    this.mainDbWrapper.debugInfo.slowQueries.clear();
-                    sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, liveStoreVersion }));
-                    break;
-                }
-                case 'LSD.DebugInfoRerunQueryReq': {
-                    const { queryStr, bindValues, queriedTables } = decoded.value;
-                    this.mainDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true });
-                    sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }));
-                    break;
-                }
-                case 'LSD.ReactivityGraphUnsubscribe': {
-                    reactivityGraphSubcriptions.get(requestId)();
-                    break;
-                }
-                case 'LSD.LiveQueriesSubscribe': {
-                    const send = () => sendToDevtools(Devtools.LiveQueriesRes.make({
-                        liveQueries: [...this.activeQueries].map((q) => ({
-                            _tag: q._tag,
-                            id: q.id,
-                            label: q.label,
-                            runs: q.runs,
-                            executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
-                            lastestResult: q.results$.previousResult,
-                            activeSubscriptions: Array.from(q.activeSubscriptions),
-                        })),
-                        requestId,
-                        liveStoreVersion,
-                    }));
-                    send();
-                    liveQueriesSubscriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(() => send()));
-                    break;
-                }
-                case 'LSD.LiveQueriesUnsubscribe': {
-                    liveQueriesSubscriptions.get(requestId)();
-                    break;
-                }
-                case 'LSD.ResetAllDataReq': {
-                    await this.adapter.coordinator.dangerouslyReset(decoded.value.mode);
-                    sendToDevtools(Devtools.ResetAllDataRes.make({ requestId, liveStoreVersion }));
-                    break;
-                }
-                // No default
+            if (message.channelId !== channelId)
+                return;
+            if (message._tag === 'LSD.WindowMessage.MessagePortForStore') {
+                this.adapter.coordinator.devtools.connect({ port: message.port, connectionId: this.devtoolsConnectionId }).pipe(Effect.tapSync(({ storeMessagePort }) => {
+                    // console.log('storeMessagePort', storeMessagePort)
+                    storeMessagePort.addEventListener('message', (event) => {
+                        const decodedMessage = Schema.decodeUnknownSync(Devtools.MessageToAppHostStore)(event.data);
+                        // console.log('storeMessagePort message', decodedMessage)
+                        if (decodedMessage.channelId !== this.adapter.coordinator.devtools.channelId) {
+                            // console.log(`Unknown message`, event)
+                            return;
+                        }
+                        const requestId = decodedMessage.requestId;
+                        const sendToDevtools = (message) => storeMessagePort.postMessage(Schema.encodeSync(Devtools.MessageFromAppHostStore)(message));
+                        const requestIdleCallback = window.requestIdleCallback ?? ((cb) => cb());
+                        switch (decodedMessage._tag) {
+                            case 'LSD.ReactivityGraphSubscribe': {
+                                const includeResults = decodedMessage.includeResults;
+                                const send = () => 
+                                // In order to not add more work to the current tick, we use requestIdleCallback
+                                // to send the reactivity graph updates to the devtools
+                                requestIdleCallback(() => sendToDevtools(Devtools.ReactivityGraphRes.make({
+                                    reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
+                                    requestId,
+                                    liveStoreVersion,
+                                })), { timeout: 500 });
+                                send();
+                                // In some cases, there can be A LOT of reactivity graph updates in a short period of time
+                                // so we throttle the updates to avoid sending too much data
+                                // This might need to be tweaked further and possibly be exposed to the user in some way.
+                                const throttledSend = throttle(send, 20);
+                                reactivityGraphSubcriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend));
+                                break;
+                            }
+                            case 'LSD.DebugInfoReq': {
+                                sendToDevtools(Devtools.DebugInfoRes.make({
+                                    debugInfo: this.mainDbWrapper.debugInfo,
+                                    requestId,
+                                    liveStoreVersion,
+                                }));
+                                break;
+                            }
+                            case 'LSD.DebugInfoResetReq': {
+                                this.mainDbWrapper.debugInfo.slowQueries.clear();
+                                sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, liveStoreVersion }));
+                                break;
+                            }
+                            case 'LSD.DebugInfoRerunQueryReq': {
+                                const { queryStr, bindValues, queriedTables } = decodedMessage;
+                                this.mainDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true });
+                                sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }));
+                                break;
+                            }
+                            case 'LSD.ReactivityGraphUnsubscribe': {
+                                reactivityGraphSubcriptions.get(requestId)();
+                                break;
+                            }
+                            case 'LSD.LiveQueriesSubscribe': {
+                                const send = () => requestIdleCallback(() => sendToDevtools(Devtools.LiveQueriesRes.make({
+                                    liveQueries: [...this.activeQueries].map((q) => ({
+                                        _tag: q._tag,
+                                        id: q.id,
+                                        label: q.label,
+                                        runs: q.runs,
+                                        executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
+                                        lastestResult: q.results$.previousResult === NOT_REFRESHED_YET
+                                            ? 'SYMBOL_NOT_REFRESHED_YET'
+                                            : q.results$.previousResult,
+                                        activeSubscriptions: Array.from(q.activeSubscriptions),
+                                    })),
+                                    requestId,
+                                    liveStoreVersion,
+                                })), { timeout: 500 });
+                                send();
+                                // Same as in the reactivity graph subscription case above, we need to throttle the updates
+                                const throttledSend = throttle(send, 20);
+                                liveQueriesSubscriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend));
+                                break;
+                            }
+                            case 'LSD.LiveQueriesUnsubscribe': {
+                                liveQueriesSubscriptions.get(requestId)();
+                                break;
+                            }
+                            // No default
+                        }
+                    });
+                    storeMessagePort.start();
+                }), runEffectFork);
+                return;
             }
         });
+        sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }));
+        const reactivityGraphSubcriptions = new Map();
+        const liveQueriesSubscriptions = new Map();
+        // devtoolsChannel.toAppHost.addEventListener('message', async (event) => {
+        //   const decoded = Schema.decodeUnknownOption(Devtools.MessageToAppHostStore)(event.data)
+        //   if (decoded._tag === 'None' || decoded.value.channelId !== this.adapter.coordinator.devtools.channelId) {
+        //     // console.log(`Unknown message`, event)
+        //     return
+        //   }
+        //   const requestId = decoded.value.requestId
+        //   const sendToDevtools = (message: Devtools.MessageFromAppHostStore) =>
+        //     devtoolsChannel.fromAppHost.postMessage(Schema.encodeSync(Devtools.MessageFromAppHostStore)(message))
+        //   const requestIdleCallback = window.requestIdleCallback ?? ((cb: Function) => cb())
+        //   switch (decoded.value._tag) {
+        //     case 'LSD.ReactivityGraphSubscribe': {
+        //       const includeResults = decoded.value.includeResults
+        //       const send = () =>
+        //         // In order to not add more work to the current tick, we use requestIdleCallback
+        //         // to send the reactivity graph updates to the devtools
+        //         requestIdleCallback(
+        //           () =>
+        //             sendToDevtools(
+        //               Devtools.ReactivityGraphRes.make({
+        //                 reactivityGraph: this.reactivityGraph.getSnapshot({ includeResults }),
+        //                 requestId,
+        //                 liveStoreVersion,
+        //               }),
+        //             ),
+        //           { timeout: 500 },
+        //         )
+        //       send()
+        //       // In some cases, there can be A LOT of reactivity graph updates in a short period of time
+        //       // so we throttle the updates to avoid sending too much data
+        //       // This might need to be tweaked further and possibly be exposed to the user in some way.
+        //       const throttledSend = throttle(send, 20)
+        //       reactivityGraphSubcriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend))
+        //       break
+        //     }
+        //     case 'LSD.DebugInfoReq': {
+        //       sendToDevtools(
+        //         Devtools.DebugInfoRes.make({ debugInfo: this.mainDbWrapper.debugInfo, requestId, liveStoreVersion }),
+        //       )
+        //       break
+        //     }
+        //     case 'LSD.DebugInfoResetReq': {
+        //       this.mainDbWrapper.debugInfo.slowQueries.clear()
+        //       sendToDevtools(Devtools.DebugInfoResetRes.make({ requestId, liveStoreVersion }))
+        //       break
+        //     }
+        //     case 'LSD.DebugInfoRerunQueryReq': {
+        //       const { queryStr, bindValues, queriedTables } = decoded.value
+        //       this.mainDbWrapper.select(queryStr, { bindValues, queriedTables, skipCache: true })
+        //       sendToDevtools(Devtools.DebugInfoRerunQueryRes.make({ requestId, liveStoreVersion }))
+        //       break
+        //     }
+        //     case 'LSD.ReactivityGraphUnsubscribe': {
+        //       reactivityGraphSubcriptions.get(requestId)!()
+        //       break
+        //     }
+        //     case 'LSD.LiveQueriesSubscribe': {
+        //       const send = () =>
+        //         requestIdleCallback(
+        //           () =>
+        //             sendToDevtools(
+        //               Devtools.LiveQueriesRes.make({
+        //                 liveQueries: [...this.activeQueries].map((q) => ({
+        //                   _tag: q._tag,
+        //                   id: q.id,
+        //                   label: q.label,
+        //                   runs: q.runs,
+        //                   executionTimes: q.executionTimes.map((_) => Number(_.toString().slice(0, 5))),
+        //                   lastestResult:
+        //                     q.results$.previousResult === NOT_REFRESHED_YET
+        //                       ? 'SYMBOL_NOT_REFRESHED_YET'
+        //                       : q.results$.previousResult,
+        //                   activeSubscriptions: Array.from(q.activeSubscriptions),
+        //                 })),
+        //                 requestId,
+        //                 liveStoreVersion,
+        //               }),
+        //             ),
+        //           { timeout: 500 },
+        //         )
+        //       send()
+        //       // Same as in the reactivity graph subscription case above, we need to throttle the updates
+        //       const throttledSend = throttle(send, 20)
+        //       liveQueriesSubscriptions.set(requestId, this.reactivityGraph.subscribeToRefresh(throttledSend))
+        //       break
+        //     }
+        //     case 'LSD.LiveQueriesUnsubscribe': {
+        //       liveQueriesSubscriptions.get(requestId)!()
+        //       break
+        //     }
+        //     // No default
+        //   }
+        // })
     };
     __devDownloadDb = () => {
         const data = this.mainDbWrapper.export();
         downloadBlob(data, `livestore-${Date.now()}.db`);
     };
     __devDownloadMutationLogDb = async () => {
-        const data = await this.adapter.coordinator.getMutationLogData();
+        const data = await this.adapter.coordinator.getMutationLogData.pipe(runEffectPromise);
         downloadBlob(data, `livestore-mutationlog-${Date.now()}.db`);
     };
     // TODO allow for graceful store reset without requiring a full page reload (which should also call .boot)
-    dangerouslyResetStorage = (mode) => this.adapter.coordinator.dangerouslyReset(mode);
+    dangerouslyResetStorage = (mode) => this.adapter.coordinator.dangerouslyReset(mode).pipe(runEffectPromise);
 }
 /** Create a new LiveStore Store */
-export const createStore = async ({ schema, graphQLOptions, otelOptions, adapter: adapterFactory, boot, reactivityGraph = globalReactivityGraph, batchUpdates, disableDevtools, }) => {
+export const createStore = async (options) => createStoreEff(options).pipe(runEffectPromise);
+export const createStoreEff = ({ schema, graphQLOptions, otelOptions, adapter: adapterFactory, boot, reactivityGraph = globalReactivityGraph, batchUpdates, disableDevtools, onBootStatus, }) => {
     const otelTracer = otelOptions?.tracer ?? makeNoopTracer();
     const otelRootSpanContext = otelOptions?.rootSpanContext ?? otel.context.active();
-    return otelTracer.startActiveSpan('createStore', {}, otelRootSpanContext, async (span) => {
-        try {
-            performance.mark('livestore:db-creating');
-            const otelContext = otel.trace.setSpan(otel.context.active(), span);
-            const adapterPromise = adapterFactory({ otelTracer, otelContext, schema });
-            const adapter = adapterPromise instanceof Promise ? await adapterPromise : adapterPromise;
-            performance.mark('livestore:db-created');
-            performance.measure('livestore:db-create', 'livestore:db-creating', 'livestore:db-created');
-            if (batchUpdates !== undefined) {
-                reactivityGraph.effectsWrapper = batchUpdates;
-            }
-            const mutationEventSchema = makeMutationEventSchemaMemo(schema);
-            // TODO consider moving booting into the storage backend
-            if (boot !== undefined) {
-                let isInTxn = false;
-                let txnExecuteStmnts = [];
-                const bootDbImpl = {
-                    _tag: 'BootDb',
-                    execute: (queryStr, bindValues) => {
-                        const stmt = adapter.mainDb.prepare(queryStr);
-                        stmt.execute(bindValues);
-                        if (isInTxn === true) {
-                            txnExecuteStmnts.push([queryStr, bindValues]);
-                        }
-                        else {
-                            void adapter.coordinator.execute(queryStr, bindValues, undefined);
-                        }
-                    },
-                    mutate: (...list) => {
-                        for (const mutationEventDecoded of list) {
-                            const mutationDef = schema.mutations.get(mutationEventDecoded.mutation) ??
-                                shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`);
-                            const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded });
-                            // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
-                            for (const { statementSql, bindValues } of execArgsArr) {
-                                adapter.mainDb.execute(statementSql, bindValues);
-                            }
-                            const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded);
-                            void adapter.coordinator.mutate(mutationEventEncoded, {
-                                span,
-                                persisted: true,
-                            });
-                        }
-                    },
-                    select: (queryStr, bindValues) => {
-                        const stmt = adapter.mainDb.prepare(queryStr);
-                        return stmt.select(bindValues);
-                    },
-                    txn: (callback) => {
-                        try {
-                            isInTxn = true;
-                            adapter.mainDb.execute('BEGIN', undefined);
-                            callback();
-                            adapter.mainDb.execute('COMMIT', undefined);
-                            // adapter.coordinator.execute('BEGIN', undefined, undefined)
-                            for (const [queryStr, bindValues] of txnExecuteStmnts) {
-                                adapter.coordinator.execute(queryStr, bindValues, undefined);
-                            }
-                            // adapter.coordinator.execute('COMMIT', undefined, undefined)
-                        }
-                        catch (e) {
-                            adapter.mainDb.execute('ROLLBACK', undefined);
-                            throw e;
+    const TracingLive = Layer.unwrapEffect(Effect.map(OtelTracer.make, Layer.setTracer)).pipe(Layer.provide(Layer.sync(OtelTracer.Tracer, () => otelTracer)));
+    return Effect.gen(function* () {
+        const span = yield* OtelTracer.currentOtelSpan.pipe(Effect.orDie);
+        const bootStatusQueue = yield* Queue.unbounded();
+        yield* Queue.take(bootStatusQueue).pipe(Effect.tapSync((status) => onBootStatus?.(status)), Effect.forever, Effect.tapCauseLogPretty, Effect.forkScoped);
+        const adapter = yield* adapterFactory({
+            schema,
+            devtoolsEnabled: disableDevtools !== true,
+            bootStatusQueue,
+        }).pipe(Effect.withPerformanceMeasure('livestore:makeAdapter'), Effect.withSpan('createStore:makeAdapter'));
+        if (batchUpdates !== undefined) {
+            reactivityGraph.effectsWrapper = batchUpdates;
+        }
+        const mutationEventSchema = makeMutationEventSchemaMemo(schema);
+        const __processedMutationIds = new Set();
+        // TODO consider moving booting into the storage backend
+        if (boot !== undefined) {
+            let isInTxn = false;
+            let txnExecuteStmnts = [];
+            const bootDbImpl = {
+                _tag: 'BootDb',
+                execute: (queryStr, bindValues) => {
+                    const stmt = adapter.mainDb.prepare(queryStr);
+                    stmt.execute(bindValues);
+                    if (isInTxn === true) {
+                        txnExecuteStmnts.push([queryStr, bindValues]);
+                    }
+                    else {
+                        adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork);
+                    }
+                },
+                mutate: (...list) => {
+                    for (const mutationEventDecoded of list) {
+                        const mutationDef = schema.mutations.get(mutationEventDecoded.mutation) ??
+                            shouldNeverHappen(`Unknown mutation type: ${mutationEventDecoded.mutation}`);
+                        __processedMutationIds.add(mutationEventDecoded.id);
+                        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded });
+                        // const { bindValues, statementSql } = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
+                        for (const { statementSql, bindValues } of execArgsArr) {
+                            adapter.mainDb.execute(statementSql, bindValues);
                         }
-                        finally {
-                            isInTxn = false;
-                            txnExecuteStmnts = [];
+                        const mutationEventEncoded = Schema.encodeUnknownSync(mutationEventSchema)(mutationEventDecoded);
+                        adapter.coordinator
+                            .mutate(mutationEventEncoded, { persisted: true })
+                            .pipe(runEffectFork);
+                    }
+                },
+                select: (queryStr, bindValues) => {
+                    const stmt = adapter.mainDb.prepare(queryStr);
+                    return stmt.select(bindValues);
+                },
+                txn: (callback) => {
+                    try {
+                        isInTxn = true;
+                        adapter.mainDb.execute('BEGIN', undefined);
+                        callback();
+                        adapter.mainDb.execute('COMMIT', undefined);
+                        // adapter.coordinator.execute('BEGIN', undefined, undefined)
+                        for (const [queryStr, bindValues] of txnExecuteStmnts) {
+                            adapter.coordinator.execute(queryStr, bindValues).pipe(runEffectFork);
                         }
-                    },
-                };
-                const booting = boot(bootDbImpl, span);
-                // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
-                if (isPromise(booting)) {
-                    await booting;
-                }
+                        // adapter.coordinator.execute('COMMIT', undefined, undefined)
+                    }
+                    catch (e) {
+                        adapter.mainDb.execute('ROLLBACK', undefined);
+                        throw e;
+                    }
+                    finally {
+                        isInTxn = false;
+                        txnExecuteStmnts = [];
+                    }
+                },
+            };
+            const booting = boot(bootDbImpl, span);
+            // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
+            if (isPromise(booting)) {
+                yield* Effect.promise(() => booting);
             }
-            // TODO: we can't apply the schema at this point, we've already loaded persisted data!
-            // Think about what to do about this case.
-            // await applySchema(db, schema)
-            return Store.createStore({
-                adapter,
-                schema,
-                graphQLOptions,
-                otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
-                reactivityGraph,
-                disableDevtools,
-            }, span);
         }
-        finally {
-            span.end();
-        }
-    });
+        // TODO: we can't apply the schema at this point, we've already loaded persisted data!
+        // Think about what to do about this case.
+        // await applySchema(db, schema)
+        return Store.createStore({
+            adapter,
+            schema,
+            graphQLOptions,
+            otelOptions: { tracer: otelTracer, rootSpanContext: otelRootSpanContext },
+            reactivityGraph,
+            disableDevtools,
+            __processedMutationIds,
+        }, span);
+    }).pipe(Effect.scoped, Effect.withSpan('createStore', {
+        parent: otelOptions?.rootSpanContext
+            ? OtelTracer.makeExternalSpan(otel.trace.getSpanContext(otelOptions.rootSpanContext))
+            : undefined,
+    }), Effect.provide(TracingLive));
 };
+// TODO consider replacing with Effect's RC data structures
 class ReferenceCountedSet {
     map;
     constructor() {
@@ -522,4 +656,6 @@ class ReferenceCountedSet {
         }
     }
 }
+const runEffectFork = (effect) => effect.pipe(Effect.tapCauseLogPretty, Effect.annotateLogs({ thread: 'window' }), Effect.provide(Logger.pretty), Logger.withMinimumLogLevel(LogLevel.Debug), Effect.runFork);
+const runEffectPromise = (effect) => effect.pipe(Effect.tapCauseLogPretty, Effect.annotateLogs({ thread: 'window' }), Effect.provide(Logger.pretty), Logger.withMinimumLogLevel(LogLevel.Debug), Effect.runPromise);
 //# sourceMappingURL=store.js.map