@livestore/adapter-expo 0.0.0-snapshot-a953343ad2d7468c6573bcb5e26f0eab4302078f

package/src/common.ts

@@ -0,0 +1,115 @@
+import type { PreparedStatement, SqliteDb } from '@livestore/common'
+import { base64, shouldNeverHappen } from '@livestore/utils'
+import { Effect } from '@livestore/utils/effect'
+import * as ExpoFS from 'expo-file-system'
+import type * as SQLite from 'expo-sqlite'
+
+export const makeSqliteDb = (db: SQLite.SQLiteDatabase): SqliteDb => {
+  const stmts: PreparedStatement[] = []
+
+  const sqliteDb: SqliteDb<any> = {
+    metadata: { fileName: db.databasePath },
+    _tag: 'SqliteDb',
+    prepare: (queryStr) => {
+      try {
+        const dbStmt = db.prepareSync(queryStr)
+        const stmt = {
+          execute: (bindValues) => {
+            // console.log('execute', queryStr, bindValues)
+            const res = dbStmt.executeSync(bindValues ?? ([] as any))
+            res.resetSync()
+            return () => res.changes
+          },
+          select: (bindValues) => {
+            const res = dbStmt.executeSync(bindValues ?? ([] as any))
+            try {
+              return res.getAllSync() as any
+            } finally {
+              res.resetSync()
+            }
+          },
+          finalize: () => dbStmt.finalizeSync(),
+          sql: queryStr,
+        } satisfies PreparedStatement
+        stmts.push(stmt)
+        return stmt
+      } catch (e) {
+        console.error(`Error preparing statement: ${queryStr}`, e)
+        return shouldNeverHappen(`Error preparing statement: ${queryStr}`)
+      }
+    },
+    execute: (queryStr, bindValues) => {
+      const stmt = db.prepareSync(queryStr)
+      try {
+        const res = stmt.executeSync(bindValues ?? ([] as any))
+        return () => res.changes
+      } finally {
+        stmt.finalizeSync()
+      }
+    },
+    export: () => {
+      return db.serializeSync()
+    },
+    select: (queryStr, bindValues) => {
+      const stmt = sqliteDb.prepare(queryStr)
+      const res = stmt.select(bindValues)
+      stmt.finalize()
+      return res as any
+    },
+    // TODO
+    destroy: () => {},
+    close: () => {
+      for (const stmt of stmts) {
+        stmt.finalize()
+      }
+      return db.closeSync()
+    },
+    import: () => {
+      throw new Error('Not implemented')
+      // TODO properly implement this as it seems to require importing to a temporary in-memory db,
+      // save it to a file, and then reopen the DB from that file? (see `overwriteDbFile` below)
+    },
+    session: () => {
+      return {
+        changeset: () => new Uint8Array(),
+        finish: () => {},
+      }
+    },
+    makeChangeset: (data) => {
+      return {
+        invert: () => {
+          return sqliteDb.makeChangeset(data)
+        },
+        apply: () => {
+          // TODO
+        },
+      }
+    },
+  } satisfies SqliteDb
+
+  return sqliteDb
+}
+
+export type DbPairRef = {
+  current:
+    | {
+        db: SQLite.SQLiteDatabase
+        sqliteDb: SqliteDb
+      }
+    | undefined
+}
+
+export const getDbFilePath = (dbName: string) => {
+  return `${ExpoFS.documentDirectory}SQLite/${dbName}`
+}
+
+export const overwriteDbFile = (dbName: string, data: Uint8Array) =>
+  Effect.gen(function* () {
+    const path = getDbFilePath(dbName)
+
+    yield* Effect.promise(() => ExpoFS.deleteAsync(path, { idempotent: true }))
+
+    // TODO avoid converting to string once the ExpoFS API supports binary data
+    const b64String = base64.encode(data)
+    yield* Effect.promise(() => ExpoFS.writeAsStringAsync(path, b64String, { encoding: ExpoFS.EncodingType.Base64 }))
+  })

package/src/devtools.ts

@@ -0,0 +1,292 @@
+// @ts-nocheck
+import type { ClientSession, ConnectDevtoolsToStore } from '@livestore/common'
+import {
+  Devtools,
+  IntentionalShutdownCause,
+  liveStoreVersion,
+  MUTATION_LOG_META_TABLE,
+  SCHEMA_META_TABLE,
+  SCHEMA_MUTATIONS_META_TABLE,
+  UnexpectedError,
+} from '@livestore/common'
+import type { PullQueueItem } from '@livestore/common/leader-thread'
+import type { LiveStoreSchema, MutationEvent } from '@livestore/common/schema'
+import { makeExpoDevtoolsChannel } from '@livestore/devtools-expo-common/web-channel'
+import type { ParseResult, Scope } from '@livestore/utils/effect'
+import { Cause, Effect, Queue, Schema, Stream, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
+import * as SQLite from 'expo-sqlite'
+
+import type { DbPairRef } from './common.js'
+import { makeSqliteDb, overwriteDbFile } from './common.js'
+
+export type BootedDevtools = {
+  onMutation: ({
+    mutationEventEncoded,
+  }: {
+    mutationEventEncoded: MutationEvent.AnyEncoded
+  }) => Effect.Effect<void, UnexpectedError, never>
+}
+
+export const bootDevtools = ({
+  connectDevtoolsToStore,
+  clientSession,
+  schema,
+  shutdown,
+  dbRef,
+  dbMutationLogRef,
+  incomingSyncMutationsQueue,
+}: {
+  connectDevtoolsToStore: ConnectDevtoolsToStore
+  clientSession: ClientSession
+  schema: LiveStoreSchema
+  dbRef: DbPairRef
+  dbMutationLogRef: DbPairRef
+  shutdown: (cause: Cause.Cause<UnexpectedError | IntentionalShutdownCause>) => Effect.Effect<void>
+  incomingSyncMutationsQueue: Queue.Queue<PullQueueItem>
+}): Effect.Effect<BootedDevtools, UnexpectedError | ParseResult.ParseError, Scope.Scope> =>
+  Effect.gen(function* () {
+    const appHostId = 'expo'
+    const isLeader = true
+
+    const expoDevtoolsChannel = yield* makeExpoDevtoolsChannel({
+      listenSchema: Schema.Union(Devtools.MessageToApp, Devtools.MessageToApp),
+      sendSchema: Schema.Union(Devtools.MessageFromApp, Devtools.MessageFromApp),
+    })
+
+    const isConnected = yield* SubscriptionRef.make(false)
+
+    /**
+     * Used to forward messages from `expoDevtoolsChannel` to a "filtered" `storeDevtoolsChannel`
+     * which is expected by the `connectDevtoolsToStore` function.
+     */
+    const storeDevtoolsChannelProxy = yield* WebChannel.queueChannelProxy({
+      schema: { listen: Devtools.MessageToApp, send: Devtools.MessageFromApp },
+    })
+
+    yield* storeDevtoolsChannelProxy.sendQueue.pipe(
+      Stream.fromQueue,
+      Stream.tap((msg) => expoDevtoolsChannel.send(msg)),
+      Stream.runDrain,
+      Effect.forkScoped,
+    )
+
+    const getDatabaseName = (db: DbPairRef) =>
+      db.current!.db.databasePath.slice(db.current!.db.databasePath.lastIndexOf('/') + 1)
+
+    yield* expoDevtoolsChannel.listen.pipe(
+      Stream.flatten(),
+      Stream.tap((decodedEvent) =>
+        Effect.gen(function* () {
+          if (Schema.is(Devtools.MessageToApp)(decodedEvent)) {
+            yield* storeDevtoolsChannelProxy.listenQueue.pipe(Queue.offer(decodedEvent))
+            return
+          }
+
+          // if (decodedEvent._tag === 'LSD.DevtoolsReady') {
+          //   if ((yield* isConnected.get) === false) {
+          //     // yield* expoDevtoolsChannel.send(Devtools.AppHostReady.make({ appHostId, liveStoreVersion, isLeader }))
+          //   }
+
+          //   return
+          // }
+
+          // if (decodedEvent._tag === 'LSD.DevtoolsConnected') {
+          //   if (yield* isConnected.get) {
+          //     console.warn('devtools already connected')
+          //     return
+          //   }
+
+          //   yield* connectDevtoolsToStore(storeDevtoolsChannelProxy.webChannel).pipe(
+          //     Effect.tapCauseLogPretty,
+          //     Effect.forkScoped,
+          //   )
+
+          //   yield* SubscriptionRef.set(isConnected, true)
+          //   return
+          // }
+
+          // if (decodedEvent._tag === 'LSD.Disconnect') {
+          //   yield* SubscriptionRef.set(isConnected, false)
+
+          //   // yield* disconnect
+
+          //   // TODO is there a better place for this?
+          //   yield* expoDevtoolsChannel.send(Devtools.AppHostReady.make({ appHostId, liveStoreVersion, isLeader }))
+
+          //   return
+          // }
+
+          const { requestId } = decodedEvent
+          const reqPayload = { requestId, appHostId, liveStoreVersion }
+
+          switch (decodedEvent._tag) {
+            case 'LSD.Ping': {
+              yield* expoDevtoolsChannel.send(Devtools.Pong.make({ ...reqPayload }))
+              return
+            }
+            case 'LSD.Leader.SnapshotReq': {
+              const data = yield* clientSession.leaderThread.export
+
+              yield* expoDevtoolsChannel.send(Devtools.SnapshotRes.make({ snapshot: data!, ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.LoadDatabaseFileReq': {
+              const { data } = decodedEvent
+
+              let tableNames: Set<string>
+
+              try {
+                const tmpExpoDb = SQLite.deserializeDatabaseSync(data)
+                const tmpDb = makeSqliteDb(tmpExpoDb)
+                const tableNameResults = tmpDb.select<{ name: string }>(
+                  `select name from sqlite_master where type = 'table'`,
+                )
+
+                tableNames = new Set(tableNameResults.map((_) => _.name))
+
+                tmpExpoDb.closeSync()
+              } catch (e) {
+                yield* expoDevtoolsChannel.send(
+                  Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-file' }),
+                )
+
+                console.error(e)
+
+                return
+              }
+
+              if (tableNames.has(MUTATION_LOG_META_TABLE)) {
+                // yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+
+                dbMutationLogRef.current!.db.closeSync()
+
+                yield* overwriteDbFile(getDatabaseName(dbMutationLogRef), data)
+
+                dbMutationLogRef.current = undefined
+
+                dbRef.current!.db.closeSync()
+                SQLite.deleteDatabaseSync(getDatabaseName(dbRef))
+              } else if (tableNames.has(SCHEMA_META_TABLE) && tableNames.has(SCHEMA_MUTATIONS_META_TABLE)) {
+                // yield* SubscriptionRef.set(shutdownStateSubRef, 'shutting-down')
+
+                // yield* db.import(data)
+
+                dbRef.current!.db.closeSync()
+
+                yield* overwriteDbFile(getDatabaseName(dbRef), data)
+              } else {
+                yield* expoDevtoolsChannel.send(
+                  Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'unsupported-database' }),
+                )
+                return
+              }
+
+              yield* expoDevtoolsChannel.send(Devtools.LoadDatabaseFileRes.make({ ...reqPayload, status: 'ok' }))
+
+              yield* shutdown(Cause.fail(IntentionalShutdownCause.make({ reason: 'devtools-import' })))
+
+              return
+            }
+            case 'LSD.Leader.ResetAllDataReq': {
+              const { mode } = decodedEvent
+
+              dbRef.current!.db.closeSync()
+              SQLite.deleteDatabaseSync(getDatabaseName(dbRef))
+
+              if (mode === 'all-data') {
+                dbMutationLogRef.current!.db.closeSync()
+                SQLite.deleteDatabaseSync(getDatabaseName(dbMutationLogRef))
+              }
+
+              yield* expoDevtoolsChannel.send(Devtools.ResetAllDataRes.make({ ...reqPayload }))
+
+              yield* shutdown(Cause.fail(IntentionalShutdownCause.make({ reason: 'devtools-reset' })))
+
+              return
+            }
+            case 'LSD.Leader.DatabaseFileInfoReq': {
+              const dbSizeQuery = `SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size();`
+              const dbFileSize = dbRef.current!.db.prepareSync(dbSizeQuery).executeSync<any>().getFirstSync()!
+                .size as number
+              const mutationLogFileSize = dbMutationLogRef
+                .current!.db.prepareSync(dbSizeQuery)
+                .executeSync<any>()
+                .getFirstSync()!.size as number
+
+              yield* expoDevtoolsChannel.send(
+                Devtools.DatabaseFileInfoRes.make({
+                  readModel: { fileSize: dbFileSize, persistenceInfo: { fileName: 'livestore.db' } },
+                  mutationLog: {
+                    fileSize: mutationLogFileSize,
+                    persistenceInfo: { fileName: 'livestore-mutationlog.db' },
+                  },
+                  ...reqPayload,
+                }),
+              )
+
+              return
+            }
+            case 'LSD.Leader.MutationLogReq': {
+              const mutationLog = yield* clientSession.leaderThread.getMutationLogData
+
+              yield* expoDevtoolsChannel.send(Devtools.MutationLogRes.make({ mutationLog, ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.RunMutationReq': {
+              const { mutationEventEncoded: mutationEventEncoded_ } = decodedEvent
+              const mutationDef = schema.mutations.get(mutationEventEncoded_.mutation)!
+              // const nextMutationEventIdPair = clientSession.mutations.nextMutationEventIdPair({
+              //   clientOnly: mutationDef.options.clientOnly,
+              // })
+
+              // const mutationEventEncoded = new MutationEvent.EncodedWithMeta({
+              //   ...mutationEventEncoded_,
+              //   // ...nextMutationEventIdPair,
+              // })
+
+              // const mutationEventDecoded = yield* Schema.decode(mutationEventSchema)(mutationEventEncoded)
+              // yield* Queue.offer(incomingSyncMutationsQueue, {
+              //   payload: { _tag: 'upstream-advance', newEvents: [mutationEventEncoded] },
+              //   remaining: 0,
+              // })
+
+              // const mutationDef =
+              //   schema.mutations.get(mutationEventEncoded.mutation) ??
+              //   shouldNeverHappen(`Unknown mutation: ${mutationEventEncoded.mutation}`)
+
+              // yield* clientSession.mutations.push([mutationEventEncoded])
+
+              yield* expoDevtoolsChannel.send(Devtools.RunMutationRes.make({ ...reqPayload }))
+
+              return
+            }
+            case 'LSD.Leader.SyncingInfoReq': {
+              const syncingInfo = Devtools.SyncingInfo.make({
+                enabled: false,
+                metadata: {},
+              })
+
+              yield* expoDevtoolsChannel.send(Devtools.SyncingInfoRes.make({ syncingInfo, ...reqPayload }))
+
+              return
+            }
+          }
+        }),
+      ),
+      Stream.runDrain,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+    // yield* expoDevtoolsChannel.send(Devtools.AppHostReady.make({ appHostId, isLeader, liveStoreVersion }))
+
+    const onMutation = ({ mutationEventEncoded }: { mutationEventEncoded: MutationEvent.AnyEncoded }) =>
+      expoDevtoolsChannel
+        .send(Devtools.MutationBroadcast.make({ mutationEventEncoded, liveStoreVersion }))
+        .pipe(UnexpectedError.mapToUnexpectedError)
+
+    return {
+      onMutation,
+    }
+  }).pipe(Effect.withSpan('@livestore/adapter-expo:bootDevtools'))

package/src/index.ts

@@ -0,0 +1,248 @@
+import type { Adapter, ClientSession, LockStatus, PreparedBindValues } from '@livestore/common'
+import {
+  getExecArgsFromMutation,
+  initializeSingletonTables,
+  liveStoreStorageFormatVersion,
+  migrateDb,
+  migrateTable,
+  rehydrateFromMutationLog,
+  sql,
+  UnexpectedError,
+} from '@livestore/common'
+import type { PullQueueItem } from '@livestore/common/leader-thread'
+import type { MutationLogMetaRow } from '@livestore/common/schema'
+import { EventId, MUTATION_LOG_META_TABLE, MutationEvent, mutationLogMetaTable } from '@livestore/common/schema'
+import { insertRowPrepared, makeBindValues } from '@livestore/common/sql-queries'
+import { casesHandled, shouldNeverHappen } from '@livestore/utils'
+import { Effect, Option, Queue, Schema, Stream, SubscriptionRef } from '@livestore/utils/effect'
+import * as SQLite from 'expo-sqlite'
+
+import { makeSqliteDb } from './common.js'
+import type { BootedDevtools } from './devtools.js'
+import { bootDevtools } from './devtools.js'
+
+export type MakeDbOptions = {
+  fileNamePrefix?: string
+  subDirectory?: string
+  // syncBackend?: TODO
+}
+
+// TODO refactor with leader-thread code from `@livestore/common/leader-thread`
+export const makeAdapter =
+  (options?: MakeDbOptions): Adapter =>
+  ({ schema, connectDevtoolsToStore, shutdown, devtoolsEnabled }) =>
+    Effect.gen(function* () {
+      const { fileNamePrefix, subDirectory } = options ?? {}
+      const migrationOptions = schema.migrationOptions
+      const subDirectoryPath = subDirectory ? subDirectory.replace(/\/$/, '') + '/' : ''
+      const fullDbFilePath = `${subDirectoryPath}${fileNamePrefix ?? 'livestore-'}${schema.hash}@${liveStoreStorageFormatVersion}.db`
+      const db = SQLite.openDatabaseSync(fullDbFilePath)
+
+      const dbRef = { current: { db, sqliteDb: makeSqliteDb(db) } }
+
+      const dbWasEmptyWhenOpened = dbRef.current.sqliteDb.select('SELECT 1 FROM sqlite_master').length === 0
+
+      const dbMutationLog = SQLite.openDatabaseSync(
+        `${subDirectory ?? ''}${fileNamePrefix ?? 'livestore-'}mutationlog@${liveStoreStorageFormatVersion}.db`,
+      )
+
+      const dbMutationLogRef = { current: { db: dbMutationLog, sqliteDb: makeSqliteDb(dbMutationLog) } }
+
+      const dbMutationLogWasEmptyWhenOpened =
+        dbMutationLogRef.current.sqliteDb.select('SELECT 1 FROM sqlite_master').length === 0
+
+      yield* Effect.addFinalizer(() =>
+        Effect.gen(function* () {
+          // Ignoring in case the database is already closed
+          yield* Effect.try(() => db.closeSync()).pipe(Effect.ignore)
+          yield* Effect.try(() => dbMutationLog.closeSync()).pipe(Effect.ignore)
+        }),
+      )
+
+      if (dbMutationLogWasEmptyWhenOpened) {
+        yield* migrateTable({
+          db: dbMutationLogRef.current.sqliteDb,
+          behaviour: 'create-if-not-exists',
+          tableAst: mutationLogMetaTable.sqliteDef.ast,
+          skipMetaTable: true,
+        })
+      }
+
+      if (dbWasEmptyWhenOpened) {
+        yield* migrateDb({ db: dbRef.current.sqliteDb, schema })
+
+        initializeSingletonTables(schema, dbRef.current.sqliteDb)
+
+        switch (migrationOptions.strategy) {
+          case 'from-mutation-log': {
+            // TODO bring back
+            // yield* rehydrateFromMutationLog({
+            //   db: dbRef.current.sqliteDb,
+            //   logDb: dbMutationLogRef.current.sqliteDb,
+            //   schema,
+            //   migrationOptions,
+            //   onProgress: () => Effect.void,
+            // })
+
+            break
+          }
+          case 'hard-reset': {
+            // This is already the case by note doing anything now
+
+            break
+          }
+          case 'manual': {
+            // const migrateFn = migrationStrategy.migrate
+            console.warn('Manual migration strategy not implemented yet')
+
+            // TODO figure out a way to get previous database file to pass to the migration function
+
+            break
+          }
+          default: {
+            casesHandled(migrationOptions)
+          }
+        }
+      }
+
+      const mutationLogExclude =
+        migrationOptions.strategy === 'from-mutation-log'
+          ? (migrationOptions.excludeMutations ?? new Set(['livestore.RawSql']))
+          : new Set(['livestore.RawSql'])
+
+      const mutationEventSchema = MutationEvent.makeMutationEventSchema(schema)
+      const mutationDefSchemaHashMap = new Map(
+        [...schema.mutations.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
+      )
+
+      const newMutationLogStmt = dbMutationLogRef.current.sqliteDb.prepare(
+        insertRowPrepared({ tableName: MUTATION_LOG_META_TABLE, columns: mutationLogMetaTable.sqliteDef.columns }),
+      )
+
+      const lockStatus = SubscriptionRef.make<LockStatus>('has-lock').pipe(Effect.runSync)
+
+      const incomingSyncMutationsQueue = yield* Queue.unbounded<PullQueueItem>().pipe(
+        Effect.acquireRelease(Queue.shutdown),
+      )
+
+      const initialMutationEventIdSchema = mutationLogMetaTable.schema.pipe(
+        Schema.pick('idGlobal', 'idClient'),
+        Schema.transform(EventId.EventId, {
+          encode: (_) => ({ idGlobal: _.global, idClient: _.client }),
+          decode: (_) => EventId.make({ global: _.idGlobal, client: _.idClient }),
+          strict: false,
+        }),
+        Schema.Array,
+        Schema.headOrElse(() => EventId.make({ global: 0, client: 0 })),
+      )
+
+      const initialMutationEventId = yield* Schema.decode(initialMutationEventIdSchema)(
+        dbMutationLogRef.current.sqliteDb.select(
+          sql`SELECT idGlobal, idClient FROM ${MUTATION_LOG_META_TABLE} ORDER BY idGlobal DESC, idClient DESC LIMIT 1`,
+        ),
+      )
+
+      let devtools: BootedDevtools | undefined
+
+      const clientSession = {
+        devtools: { enabled: false },
+        lockStatus,
+        // Expo doesn't support multiple client sessions, so we just use a fixed session id
+        clientId: 'expo',
+        sessionId: 'expo',
+        leaderThread: {
+          mutations: {
+            pull: Stream.fromQueue(incomingSyncMutationsQueue),
+            push: (batch): Effect.Effect<void, UnexpectedError> =>
+              Effect.gen(function* () {
+                for (const mutationEventEncoded of batch) {
+                  if (migrationOptions.strategy !== 'from-mutation-log') return
+
+                  const mutation = mutationEventEncoded.mutation
+                  const mutationDef =
+                    schema.mutations.get(mutation) ?? shouldNeverHappen(`Unknown mutation: ${mutation}`)
+
+                  const execArgsArr = getExecArgsFromMutation({
+                    mutationDef,
+                    mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
+                  })
+
+                  // write to mutation_log
+                  if (
+                    mutationLogExclude.has(mutation) === false &&
+                    execArgsArr.some((_) => _.statementSql.includes('__livestore')) === false
+                  ) {
+                    const mutationDefSchemaHash =
+                      mutationDefSchemaHashMap.get(mutation) ?? shouldNeverHappen(`Unknown mutation: ${mutation}`)
+
+                    const argsJson = JSON.stringify(mutationEventEncoded.args ?? {})
+                    const mutationLogRowValues = {
+                      idGlobal: mutationEventEncoded.id.global,
+                      idClient: mutationEventEncoded.id.client,
+                      mutation: mutationEventEncoded.mutation,
+                      argsJson,
+                      schemaHash: mutationDefSchemaHash,
+                      syncMetadataJson: Option.none(),
+                      parentIdGlobal: mutationEventEncoded.parentId.global,
+                      parentIdClient: mutationEventEncoded.parentId.client,
+                    } satisfies MutationLogMetaRow
+
+                    try {
+                      newMutationLogStmt.execute(
+                        makeBindValues({
+                          columns: mutationLogMetaTable.sqliteDef.columns,
+                          values: mutationLogRowValues,
+                          variablePrefix: '$',
+                        }) as PreparedBindValues,
+                      )
+                    } catch (e) {
+                      console.error('Error writing to mutation_log', e, mutationLogRowValues)
+                      debugger
+                      throw e
+                    }
+                  } else {
+                    //   console.debug('livestore-webworker: skipping mutation log write', mutation, statementSql, bindValues)
+                  }
+
+                  yield* devtools?.onMutation({ mutationEventEncoded }) ?? Effect.void
+                }
+              }),
+          },
+          initialState: {
+            migrationsReport: {
+              migrations: [],
+            },
+            leaderHead: initialMutationEventId,
+          },
+          export: Effect.sync(() => dbRef.current.sqliteDb.export()),
+          getMutationLogData: Effect.sync(() => dbMutationLogRef.current.sqliteDb.export()),
+          networkStatus: SubscriptionRef.make({ isConnected: false, timestampMs: Date.now(), latchClosed: false }).pipe(
+            Effect.runSync,
+          ),
+          sendDevtoolsMessage: () => Effect.dieMessage('Not implemented'),
+          getSyncState: Effect.dieMessage('Not implemented'),
+        },
+        shutdown: () => Effect.dieMessage('TODO implement shutdown'),
+        sqliteDb: dbRef.current.sqliteDb,
+      } satisfies ClientSession
+
+      if (devtoolsEnabled) {
+        devtools = yield* bootDevtools({
+          connectDevtoolsToStore,
+          clientSession,
+          schema,
+          dbRef,
+          dbMutationLogRef,
+          shutdown,
+          incomingSyncMutationsQueue,
+        }).pipe(
+          Effect.tapCauseLogPretty,
+          Effect.catchAll(() => Effect.succeed(undefined)),
+        )
+      }
+
+      return clientSession
+    }).pipe(
+      Effect.mapError((cause) => (cause._tag === 'LiveStore.UnexpectedError' ? cause : new UnexpectedError({ cause }))),
+      Effect.tapCauseLogPretty,
+    )

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./dist/.tsbuildinfo"
+  },
+  "include": ["./src"],
+  "references": [{ "path": "../common" } ,{ "path": "../utils" }, { "path": "../devtools-expo-common" }]
+}