@livestore/livestore 0.0.54-dev.4 → 0.0.54

package/dist/store.js

@@ -1,23 +1,22 @@
-import { Devtools, getExecArgsFromMutation } from '@livestore/common';
-import { version as liveStoreVersion } from '@livestore/common/package.json';
-import { makeMutationEventSchema } from '@livestore/common/schema';
-import { assertNever, isPromise, makeNoopTracer, ref, shouldNeverHappen } from '@livestore/utils';
-import { Effect, Schema, Stream } from '@livestore/utils/effect';
+import { Devtools, getExecArgsFromMutation, liveStoreVersion, prepareBindValues, UnexpectedError, } from '@livestore/common';
+import { makeMutationEventSchemaMemo } from '@livestore/common/schema';
+import { assertNever, isPromise, makeNoopTracer, shouldNeverHappen, throttle } from '@livestore/utils';
+import { cuid } from '@livestore/utils/cuid';
+import { Effect, Exit, Layer, Logger, LogLevel, OtelTracer, Queue, Runtime, Schema, Scope, Stream, } from '@livestore/utils/effect';
 import * as otel from '@opentelemetry/api';
-import { globalDbGraph } from './global-state.js';
-import { MainDatabaseWrapper } from './MainDatabaseWrapper.js';
+import { globalReactivityGraph } from './global-state.js';
+import { emptyDebugInfo as makeEmptyDebugInfo, MainDatabaseWrapper } from './MainDatabaseWrapper.js';
+import { NOT_REFRESHED_YET } from './reactive.js';
 import { downloadBlob } from './utils/dev.js';
 import { getDurationMsFromSpan } from './utils/otel.js';
-import { prepareBindValues } from './utils/util.js';
 let storeCount = 0;
 const uniqueStoreId = () => `store-${++storeCount}`;
 export class Store {
     id = uniqueStoreId();
-    graph;
+    devtoolsConnectionId = cuid();
+    storeScope;
+    reactivityGraph;
     mainDbWrapper;
-    // TODO refactor
-    // _proxyDb: InMemoryDatabase
-    // TODO
     adapter;
     schema;
     graphQLSchema;
@@ -29,41 +28,41 @@ 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, dbGraph, otelTracer, otelRootSpanContext, mutationEventSchema, disableDevtools, }) {
-        this.mainDbWrapper = new MainDatabaseWrapper({ otelTracer, otelRootSpanContext, db: adapter.mainDb });
+    constructor({ adapter, schema, graphQLOptions, reactivityGraph, otelOptions, disableDevtools, __processedMutationIds, storeScope, }) {
+        this.mainDbWrapper = new MainDatabaseWrapper({ otel: otelOptions, db: adapter.mainDb });
         this.adapter = adapter;
         this.schema = schema;
+        this.storeScope = storeScope;
         // TODO refactor
-        this.__mutationEventSchema = mutationEventSchema;
-        // this.mutationEventSchema = makeMutationEventSchema(Object.fromEntries(schema.mutations.entries()) as any)
+        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();
-        const mutationsSpan = otelTracer.startSpan('LiveStore:mutations', {}, otelRootSpanContext);
+        const mutationsSpan = otelOptions.tracer.startSpan('LiveStore:mutations', {}, otelOptions.rootSpanContext);
         const otelMuationsSpanContext = otel.trace.setSpan(otel.context.active(), mutationsSpan);
-        const queriesSpan = otelTracer.startSpan('LiveStore:queries', {}, otelRootSpanContext);
+        const queriesSpan = otelOptions.tracer.startSpan('LiveStore:queries', {}, otelOptions.rootSpanContext);
         const otelQueriesSpanContext = otel.trace.setSpan(otel.context.active(), queriesSpan);
-        this.graph = dbGraph;
-        this.graph.context = { store: this, otelTracer, rootOtelContext: otelQueriesSpanContext };
-        this.adapter.coordinator.syncMutations.pipe(Stream.tapSync((mutationEventDecoded) => {
-            this.mutate({ wasSyncMessage: true }, mutationEventDecoded);
-        }), Stream.runDrain, Effect.tapCauseLogPretty, Effect.runFork);
-        if (disableDevtools !== true) {
-            this.bootDevtools();
-        }
+        this.reactivityGraph = reactivityGraph;
+        this.reactivityGraph.context = {
+            store: this,
+            otelTracer: otelOptions.tracer,
+            rootOtelContext: otelQueriesSpanContext,
+        };
         this.otel = {
-            tracer: otelTracer,
+            tracer: otelOptions.tracer,
             mutationsSpanContext: otelMuationsSpanContext,
             queriesSpanContext: otelQueriesSpanContext,
         };
         // Need a set here since `schema.tables` might contain duplicates and some componentStateTables
         const allTableNames = new Set(this.schema.tables.keys());
-        const existingTableRefs = new Map(Array.from(this.graph.atoms.values())
+        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) {
@@ -73,10 +72,27 @@ export class Store {
             this.graphQLSchema = graphQLOptions.schema;
             this.graphQLContext = graphQLOptions.makeContext(this.mainDbWrapper, this.otel.tracer);
         }
+        Effect.gen(this, function* () {
+            yield* this.adapter.coordinator.syncMutations.pipe(Stream.tapSync((mutationEventDecoded) => {
+                this.mutate({ wasSyncMessage: true }, mutationEventDecoded);
+            }), Stream.runDrain, Effect.withSpan('LiveStore:syncMutations'), Effect.forkScoped);
+            if (disableDevtools !== true) {
+                yield* this.bootDevtools().pipe(Effect.forkScoped);
+            }
+            yield* Effect.addFinalizer(() => Effect.sync(() => {
+                for (const tableRef of Object.values(this.tableRefs)) {
+                    for (const superComp of tableRef.super) {
+                        this.reactivityGraph.removeEdge(superComp, tableRef);
+                    }
+                }
+                otel.trace.getSpan(this.otel.mutationsSpanContext).end();
+                otel.trace.getSpan(this.otel.queriesSpanContext).end();
+            }));
+        }).pipe(Scope.extend(storeScope), Effect.forkIn(storeScope), Effect.scoped, runEffectFork);
     }
     static createStore = (storeOptions, parentSpan) => {
         const ctx = otel.trace.setSpan(otel.context.active(), parentSpan);
-        return storeOptions.otelTracer.startActiveSpan('LiveStore:store-constructor', {}, ctx, (span) => {
+        return storeOptions.otelOptions.tracer.startActiveSpan('LiveStore:store-constructor', {}, ctx, (span) => {
             try {
                 return new Store(storeOptions);
             }
@@ -93,7 +109,7 @@ export class Store {
         // console.log('store sub', query$.label)
         const otelContext = otel.trace.setSpan(otel.context.active(), span);
         const label = `subscribe:${options?.label}`;
-        const effect = this.graph.makeEffect((get) => onNewValue(get(query$.results$)), { label });
+        const effect = this.reactivityGraph.makeEffect((get) => onNewValue(get(query$.results$)), { label });
         this.activeQueries.add(query$);
         // Running effect right away to get initial value (unless `skipInitialRun` is set)
         if (options?.skipInitialRun !== true) {
@@ -102,7 +118,7 @@ export class Store {
         const unsubscribe = () => {
             // console.log('store unsub', query$.label)
             try {
-                this.graph.destroyNode(effect);
+                this.reactivityGraph.destroyNode(effect);
                 this.activeQueries.remove(query$);
                 onUnsubsubscribe?.();
             }
@@ -118,14 +134,7 @@ export class Store {
      * Currently only used when shutting down the app for debugging purposes (e.g. to close Otel spans).
      */
     destroy = async () => {
-        for (const tableRef of Object.values(this.tableRefs)) {
-            for (const superComp of tableRef.super) {
-                this.graph.removeEdge(superComp, tableRef);
-            }
-        }
-        otel.trace.getSpan(this.otel.mutationsSpanContext).end();
-        otel.trace.getSpan(this.otel.queriesSpanContext).end();
-        await this.adapter.coordinator.shutdown();
+        await Scope.close(this.storeScope, Exit.void).pipe(Effect.withSpan('Store:destroy'), runEffectPromise);
     };
     mutate = (firstMutationOrTxnFnOrOptions, ...restMutations) => {
         let mutationsEvents;
@@ -164,6 +173,7 @@ export class Store {
         // console.group('LiveStore.mutate', { skipRefresh, wasSyncMessage, label })
         // mutationsEvents.forEach((_) => console.log(_.mutation, _.id, _.args))
         // console.groupEnd()
+        let durationMs;
         return this.otel.tracer.startActiveSpan('LiveStore:mutate', { attributes: { 'livestore.mutateLabel': label } }, this.otel.mutationsSpanContext, (span) => {
             const otelContext = otel.trace.setSpan(otel.context.active(), span);
             try {
@@ -184,8 +194,8 @@ export class Store {
                                     }
                                 }
                                 catch (e) {
-                                    debugger;
                                     console.error(e, mutationEvent);
+                                    throw e;
                                 }
                             }
                         };
@@ -200,6 +210,7 @@ export class Store {
                     catch (e) {
                         console.error(e);
                         span.setStatus({ code: otel.SpanStatusCode.ERROR, message: e.toString() });
+                        throw e;
                     }
                     finally {
                         span.end();
@@ -217,15 +228,18 @@ export class Store {
                     writeTables: Array.from(writeTables),
                 };
                 // Update all table refs together in a batch, to only trigger one reactive update
-                this.graph.setRefs(tablesToUpdate, { debugRefreshReason, otelContext, skipRefresh });
+                this.reactivityGraph.setRefs(tablesToUpdate, { debugRefreshReason, otelContext, skipRefresh });
             }
             catch (e) {
+                console.error(e);
                 span.setStatus({ code: otel.SpanStatusCode.ERROR, message: e.toString() });
+                throw e;
             }
             finally {
                 span.end();
-                return { durationMs: getDurationMsFromSpan(span) };
+                durationMs = getDurationMsFromSpan(span);
             }
+            return { durationMs };
         });
     };
     /**
@@ -236,7 +250,7 @@ export class Store {
         const { label } = options ?? {};
         this.otel.tracer.startActiveSpan('LiveStore:manualRefresh', { attributes: { 'livestore.manualRefreshLabel': label } }, this.otel.mutationsSpanContext, (span) => {
             const otelContext = otel.trace.setSpan(otel.context.active(), span);
-            this.graph.runDeferredEffects({ otelContext });
+            this.reactivityGraph.runDeferredEffects({ otelContext });
             span.end();
         });
     };
@@ -279,10 +293,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}`))))
@@ -297,206 +310,299 @@ 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) });
     };
-    makeTableRef = (tableName) => this.graph.makeRef(null, {
+    makeTableRef = (tableName) => this.reactivityGraph.makeRef(null, {
         equal: () => false,
         label: `tableRef:${tableName}`,
         meta: { liveStoreRefType: 'table' },
     });
-    bootDevtools = () => {
-        const devtoolsChannel = Devtools.makeBroadcastChannels();
-        const signalsSubcriptionRef = ref(undefined);
-        // let alreadySubscribedToLiveQueries = false
-        const liveQueriesSubscriptionRef = ref(undefined);
-        devtoolsChannel.toAppHost.addEventListener('message', async (event) => {
-            const decoded = Schema.decodeUnknownOption(Devtools.MessageToAppHost)(event.data);
-            if (decoded._tag === 'None' ||
-                decoded.value._tag === 'LSD.DevtoolsReadyBroadcast' ||
-                decoded.value._tag === 'LSD.DevtoolsConnected' ||
-                decoded.value.channelId !== this.adapter.coordinator.devtools.channelId) {
-                // console.log(`Unknown message`, event)
+    // TODO shutdown behaviour
+    bootDevtools = () => Effect.gen(this, function* () {
+        const sendToDevtoolsContentscript = (message) => {
+            window.postMessage(Schema.encodeSync(Devtools.DevtoolsWindowMessage.MessageForContentscript)(message), '*');
+        };
+        sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.LoadIframe.make({}));
+        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.SignalsSubscribe': {
-                    const includeResults = decoded.value.includeResults;
-                    const send = () => sendToDevtools(Devtools.SignalsRes.make({
-                        signals: this.graph.getSnapshot({ includeResults }),
-                        requestId,
-                        liveStoreVersion,
-                    }));
-                    send();
-                    if (signalsSubcriptionRef.current === undefined) {
-                        signalsSubcriptionRef.current = this.graph.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.SignalsUnsubscribe': {
-                    signalsSubcriptionRef.current();
-                    signalsSubcriptionRef.current = undefined;
-                    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();
-                    if (liveQueriesSubscriptionRef.current === undefined) {
-                        liveQueriesSubscriptionRef.current = this.graph.subscribeToRefresh(() => send());
-                    }
-                    break;
-                }
-                case 'LSD.LiveQueriesUnsubscribe': {
-                    liveQueriesSubscriptionRef.current();
-                    liveQueriesSubscriptionRef.current = undefined;
-                    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') {
+                const reactivityGraphSubcriptions = new Map();
+                const liveQueriesSubscriptions = new Map();
+                const debugInfoHistorySubscriptions = new Map();
+                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.DebugInfoHistorySubscribe': {
+                                const buffer = [];
+                                let hasStopped = false;
+                                let rafHandle;
+                                const tick = () => {
+                                    buffer.push(this.mainDbWrapper.debugInfo);
+                                    // NOTE this resets the debug info, so all other "readers" e.g. in other `requestAnimationFrame` loops,
+                                    // will get the empty debug info
+                                    // TODO We need to come up with a more graceful way to do this. Probably via a single global
+                                    // `requestAnimationFrame` loop that is passed in somehow.
+                                    this.mainDbWrapper.debugInfo = makeEmptyDebugInfo();
+                                    if (buffer.length > 10) {
+                                        sendToDevtools(Devtools.DebugInfoHistoryRes.make({
+                                            debugInfoHistory: buffer,
+                                            requestId,
+                                            liveStoreVersion,
+                                        }));
+                                        buffer.length = 0;
+                                    }
+                                    if (hasStopped === false) {
+                                        rafHandle = requestAnimationFrame(tick);
+                                    }
+                                };
+                                rafHandle = requestAnimationFrame(tick);
+                                const unsub = () => {
+                                    hasStopped = true;
+                                    if (rafHandle !== undefined) {
+                                        cancelAnimationFrame(rafHandle);
+                                    }
+                                };
+                                debugInfoHistorySubscriptions.set(requestId, unsub);
+                                break;
+                            }
+                            case 'LSD.DebugInfoHistoryUnsubscribe': {
+                                debugInfoHistorySubscriptions.get(requestId)();
+                                debugInfoHistorySubscriptions.delete(requestId);
+                                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)();
+                                liveQueriesSubscriptions.delete(requestId);
+                                break;
+                            }
+                            // No default
+                        }
+                    });
+                    storeMessagePort.start();
+                }), runEffectFork);
+                return;
             }
         });
-    };
+        sendToDevtoolsContentscript(Devtools.DevtoolsWindowMessage.StoreReady.make({ channelId }));
+    });
     __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, otelTracer = makeNoopTracer(), otelRootSpanContext = otel.context.active(), adapter: adapterFactory, boot, dbGraph = globalDbGraph, batchUpdates, disableDevtools, }) => {
-    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) {
-                dbGraph.effectsWrapper = batchUpdates;
-            }
-            const mutationEventSchema = makeMutationEventSchema(Object.fromEntries(schema.mutations.entries()));
-            // 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;
+export const createStorePromise = async ({ signal, ...options }) => Effect.gen(function* () {
+    const scope = yield* Scope.make();
+    const runtime = yield* Effect.runtime();
+    if (signal !== undefined) {
+        signal.addEventListener('abort', () => {
+            Scope.close(scope, Exit.void).pipe(Effect.tapCauseLogPretty, Runtime.runFork(runtime));
+        });
+    }
+    return yield* createStore({ ...options, storeScope: scope }).pipe(Scope.extend(scope));
+}).pipe(Effect.withSpan('createStore'), runEffectPromise);
+export const createStore = ({ schema, graphQLOptions, otelOptions, adapter: adapterFactory, boot, reactivityGraph = globalReactivityGraph, batchUpdates, disableDevtools, onBootStatus, storeScope, }) => {
+    const otelTracer = otelOptions?.tracer ?? makeNoopTracer();
+    const otelRootSpanContext = otelOptions?.rootSpanContext ?? otel.context.active();
+    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,
+            shutdown: (cause) => Scope.close(storeScope, Exit.failCause(cause)),
+        }).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 = yield* Effect.try({
+                try: () => boot(bootDbImpl, span),
+                catch: (cause) => new UnexpectedError({ cause }),
+            });
+            // NOTE only awaiting if it's actually a promise to avoid unnecessary async/await
+            if (isPromise(booting)) {
+                yield* Effect.tryPromise({ try: () => booting, catch: (cause) => new UnexpectedError({ cause }) });
             }
-            // 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: adapter,
-                schema,
-                graphQLOptions,
-                otelTracer,
-                otelRootSpanContext,
-                dbGraph,
-                mutationEventSchema,
-                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,
+            storeScope,
+        }, 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() {
@@ -527,4 +633,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