@livestore/common 0.4.0-dev.9 → 0.5.0-dev.0

package/src/leader-thread/make-leader-thread-layer.ts

@@ -1,28 +1,44 @@
 import { omitUndefineds, shouldNeverHappen } from '@livestore/utils'
-import type { HttpClient, Schema, Scope } from '@livestore/utils/effect'
-import { Deferred, Effect, KeyValueStore, Layer, PlatformError, Queue, SubscriptionRef } from '@livestore/utils/effect'
+import {
+  type HttpClient,
+  type Scope,
+  Deferred,
+  Effect,
+  KeyValueStore,
+  Latch,
+  Layer,
+  Option,
+  Queue,
+  ReadonlyArray,
+  Schema,
+  Stream,
+  Subscribable,
+  SubscriptionRef,
+} from '@livestore/utils/effect'
+
 import {
   type BootStatus,
   type MakeSqliteDb,
   type MaterializerHashMismatchError,
   type SqliteDb,
-  type SqliteError,
-  UnexpectedError,
+  UnknownError,
 } from '../adapter-types.ts'
 import type { MigrationsReport } from '../defs.ts'
 import type * as Devtools from '../devtools/mod.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { EventSequenceNumber, LiveStoreEvent, SystemTables } from '../schema/mod.ts'
-import type { InvalidPullError, IsOfflineError, SyncOptions } from '../sync/sync.ts'
+import type * as StateHead from '../StateHead.ts'
+import type { SyncBackend, SyncOptions } from '../sync/sync.ts'
 import { SyncState } from '../sync/syncstate.ts'
 import { sql } from '../util.ts'
 import * as Eventlog from './eventlog.ts'
-import { makeLeaderSyncProcessor } from './LeaderSyncProcessor.ts'
 import { bootDevtools } from './leader-worker-devtools.ts'
+import * as LeaderSyncProcessor from './LeaderSyncProcessor.ts'
 import { makeMaterializeEvent } from './materialize-event.ts'
 import { recreateDb } from './recreate-db.ts'
 import type { ShutdownChannel } from './shutdown-channel.ts'
 import type {
+  DevtoolsContext,
   DevtoolsOptions,
   InitialBlockingSyncContext,
   InitialSyncOptions,
@@ -33,7 +49,8 @@ import { LeaderThreadCtx } from './types.ts'
 
 export interface MakeLeaderThreadLayerParams {
   storeId: string
-  syncPayload: Schema.JsonValue | undefined
+  syncPayloadSchema: Schema.Decoder<Schema.Json> | undefined
+  syncPayloadEncoded: Schema.Json | undefined
   clientId: string
   schema: LiveStoreSchema
   makeSqliteDb: MakeSqliteDb
@@ -42,6 +59,8 @@ export interface MakeLeaderThreadLayerParams {
   dbEventlog: LeaderSqliteDb
   devtoolsOptions: DevtoolsOptions
   shutdownChannel: ShutdownChannel
+  /** Boot warning to emit (e.g., OPFS unavailable in private browsing) */
+  bootWarning?: BootStatus
   params?: {
     localPushBatchSize?: number
     backendPushBatchSize?: number
@@ -51,6 +70,9 @@ export interface MakeLeaderThreadLayerParams {
       delays?: {
         localPushProcessing?: Effect.Effect<void>
       }
+      hooks?: {
+        localPushAdmitted?: (events: ReadonlyArray<LiveStoreEvent.Client.EncodedWithMeta>) => Effect.Effect<void>
+      }
     }
   }
 }
@@ -59,18 +81,34 @@ export const makeLeaderThreadLayer = ({
   schema,
   storeId,
   clientId,
-  syncPayload,
+  syncPayloadSchema = Schema.Json,
+  syncPayloadEncoded,
   makeSqliteDb,
   syncOptions,
   dbState,
   dbEventlog,
   devtoolsOptions,
   shutdownChannel,
+  bootWarning,
   params,
   testing,
-}: MakeLeaderThreadLayerParams): Layer.Layer<LeaderThreadCtx, UnexpectedError, Scope.Scope | HttpClient.HttpClient> =>
+}: MakeLeaderThreadLayerParams): Layer.Layer<
+  LeaderThreadCtx,
+  UnknownError,
+  Scope.Scope | HttpClient.HttpClient | StateHead.StateHead
+> =>
   Effect.gen(function* () {
-    const bootStatusQueue = yield* Queue.unbounded<BootStatus>().pipe(Effect.acquireRelease(Queue.shutdown))
+    const syncPayloadDecoded =
+      syncPayloadEncoded === undefined
+        ? undefined
+        : yield* Schema.decodeUnknownEffect(syncPayloadSchema)(syncPayloadEncoded)
+
+    const bootStatusQueue = yield* Effect.acquireRelease(Queue.unbounded<BootStatus>(), Queue.shutdown)
+
+    // Emit boot warning if present (e.g., OPFS unavailable in private browsing)
+    if (bootWarning !== undefined) {
+      yield* Queue.offer(bootStatusQueue, bootWarning)
+    }
 
     const dbEventlogMissing = !hasEventlogTables(dbEventlog)
 
@@ -82,36 +120,37 @@ export const makeLeaderThreadLayer = ({
     const syncBackend =
       syncOptions?.backend === undefined
         ? undefined
-        : yield* syncOptions.backend({ storeId, clientId, payload: syncPayload }).pipe(
+        : yield* syncOptions.backend({ storeId, clientId, payload: syncPayloadDecoded }).pipe(
             Effect.provide(
               Layer.succeed(
                 KeyValueStore.KeyValueStore,
                 KeyValueStore.makeStringOnly({
                   get: (_key) =>
                     Effect.sync(() => Eventlog.getBackendIdFromDb(dbEventlog)).pipe(
-                      Effect.catchAllDefect((cause) =>
-                        PlatformError.BadArgument.make({
-                          method: 'getBackendIdFromDb',
-                          description: 'Failed to get backendId',
-                          module: 'KeyValueStore',
-                          cause,
-                        }),
+                      Effect.map(Option.getOrUndefined),
+                      Effect.catchDefect(
+                        (cause) =>
+                          new KeyValueStore.KeyValueStoreError({
+                            method: 'getBackendIdFromDb',
+                            message: 'Failed to get backendId',
+                            cause,
+                          }),
                       ),
                     ),
                   set: (_key, value) =>
                     Effect.sync(() => Eventlog.updateBackendId(dbEventlog, value)).pipe(
-                      Effect.catchAllDefect((cause) =>
-                        PlatformError.BadArgument.make({
-                          method: 'updateBackendId',
-                          module: 'KeyValueStore',
-                          description: 'Failed to update backendId',
-                          cause,
-                        }),
+                      Effect.catchDefect(
+                        (cause) =>
+                          new KeyValueStore.KeyValueStoreError({
+                            method: 'updateBackendId',
+                            message: 'Failed to update backendId',
+                            cause,
+                          }),
                       ),
                     ),
-                  clear: Effect.dieMessage(`Not implemented. Should never be used.`),
-                  remove: () => Effect.dieMessage(`Not implemented. Should never be used.`),
-                  size: Effect.dieMessage(`Not implemented. Should never be used.`),
+                  clear: Effect.die(new Error(`Not implemented. Should never be used.`)),
+                  remove: () => Effect.die(new Error(`Not implemented. Should never be used.`)),
+                  size: Effect.die(new Error(`Not implemented. Should never be used.`)),
                 }),
               ),
             ),
@@ -131,16 +170,18 @@ export const makeLeaderThreadLayer = ({
 
     // Recreate state database if needed BEFORE creating sync processor
     // This ensures all system tables exist before any queries are made
-    const { migrationsReport } = dbStateMissing
-      ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
-      : { migrationsReport: { migrations: [] } }
+    const { migrationsReport } =
+      dbStateMissing === true
+        ? yield* recreateDb({ dbState, dbEventlog, schema, bootStatusQueue, materializeEvent })
+        : { migrationsReport: { migrations: [] } }
 
-    const syncProcessor = yield* makeLeaderSyncProcessor({
+    const syncProcessor = yield* LeaderSyncProcessor.make({
       schema,
       dbState,
       initialSyncState: getInitialSyncState({ dbEventlog, dbState, dbEventlogMissing }),
       initialBlockingSyncContext,
       onError: syncOptions?.onSyncError ?? 'ignore',
+      onBackendIdMismatch: syncOptions?.onBackendIdMismatch ?? 'reset',
       livePull: syncOptions?.livePull ?? true,
       params: {
         ...omitUndefineds({
@@ -149,21 +190,25 @@ export const makeLeaderThreadLayer = ({
         }),
       },
       testing: {
-        ...omitUndefineds({ delays: testing?.syncProcessor?.delays }),
+        ...omitUndefineds({ delays: testing?.syncProcessor?.delays, hooks: testing?.syncProcessor?.hooks }),
       },
     })
 
-    const extraIncomingMessagesQueue = yield* Queue.unbounded<Devtools.Leader.MessageToApp>().pipe(
-      Effect.acquireRelease(Queue.shutdown),
+    const extraIncomingMessagesQueue = yield* Effect.acquireRelease(
+      Queue.unbounded<Devtools.Leader.MessageToApp>(),
+      Queue.shutdown,
     )
 
-    const devtoolsContext = devtoolsOptions.enabled
-      ? {
-          enabled: true as const,
-          syncBackendLatch: yield* Effect.makeLatch(true),
-          syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
-        }
-      : { enabled: false as const }
+    const devtoolsContext =
+      devtoolsOptions.enabled === true
+        ? {
+            enabled: true as const,
+            syncBackendLatch: yield* Latch.make(true),
+            syncBackendLatchState: yield* SubscriptionRef.make<{ latchClosed: boolean }>({ latchClosed: false }),
+          }
+        : { enabled: false as const }
+
+    const networkStatus = yield* makeNetworkStatusSubscribable({ syncBackend, devtoolsContext })
 
     const ctx = {
       schema,
@@ -173,7 +218,7 @@ export const makeLeaderThreadLayer = ({
       dbState,
       dbEventlog,
       makeSqliteDb,
-      eventSchema: LiveStoreEvent.makeEventDefSchema(schema),
+      eventSchema: LiveStoreEvent.Client.makeSchema(schema),
       shutdownStateSubRef: yield* SubscriptionRef.make<ShutdownState>('running'),
       shutdownChannel,
       syncBackend,
@@ -181,14 +226,15 @@ export const makeLeaderThreadLayer = ({
       materializeEvent,
       extraIncomingMessagesQueue,
       devtools: devtoolsContext,
+      networkStatus,
       // State will be set during `bootLeaderThread`
-      initialState: {} as any as LeaderThreadCtx['Type']['initialState'],
-    } satisfies typeof LeaderThreadCtx.Service
+      initialState: {} as any as LeaderThreadCtx['Service']['initialState'],
+    } satisfies LeaderThreadCtx['Service']
 
     // @ts-expect-error For debugging purposes
     globalThis.__leaderThreadCtx = ctx
 
-    const layer = Layer.succeed(LeaderThreadCtx, ctx)
+    const layer = Layer.succeed(LeaderThreadCtx, LeaderThreadCtx.of(ctx))
 
     ctx.initialState = yield* bootLeaderThread({
       migrationsReport,
@@ -200,31 +246,19 @@ export const makeLeaderThreadLayer = ({
   }).pipe(
     Effect.withSpan('@livestore/common:leader-thread:boot'),
     Effect.withSpanScoped('@livestore/common:leader-thread'),
-    UnexpectedError.mapToUnexpectedError,
+    UnknownError.mapToUnknownError,
     Effect.tapCauseLogPretty,
-    Layer.unwrapScoped,
+    Layer.unwrap,
   )
 
 const hasEventlogTables = (db: SqliteDb) => {
   const tableNames = new Set(db.select<{ name: string }>(sql`select name from sqlite_master`).map((_) => _.name))
-  const eventlogTables = new Set(SystemTables.eventlogSystemTables.map((_) => _.sqliteDef.name))
-  return isSubsetOf(eventlogTables, tableNames)
+  return ReadonlyArray.every(SystemTables.eventlogSystemTables, (_) => tableNames.has(_.sqliteDef.name))
 }
 
 const hasStateTables = (db: SqliteDb) => {
   const tableNames = new Set(db.select<{ name: string }>(sql`select name from sqlite_master`).map((_) => _.name))
-  const stateTables = new Set(SystemTables.stateSystemTables.map((_) => _.sqliteDef.name))
-  return isSubsetOf(stateTables, tableNames)
-}
-
-const isSubsetOf = (a: Set<string>, b: Set<string>): boolean => {
-  for (const item of a) {
-    if (!b.has(item)) {
-      return false
-    }
-  }
-
-  return true
+  return ReadonlyArray.every(SystemTables.stateSystemTables, (_) => tableNames.has(_.sqliteDef.name))
 }
 
 const getInitialSyncState = ({
@@ -236,11 +270,11 @@ const getInitialSyncState = ({
   dbState: SqliteDb
   dbEventlogMissing: boolean
 }) => {
-  const initialBackendHead = dbEventlogMissing
-    ? EventSequenceNumber.ROOT.global
-    : Eventlog.getBackendHeadFromDb(dbEventlog)
+  const initialBackendHead =
+    dbEventlogMissing === true ? EventSequenceNumber.Client.ROOT.global : Eventlog.getBackendHeadFromDb(dbEventlog)
 
-  const initialLocalHead = dbEventlogMissing ? EventSequenceNumber.ROOT : Eventlog.getClientHeadFromDb(dbEventlog)
+  const initialLocalHead =
+    dbEventlogMissing === true ? EventSequenceNumber.Client.ROOT : Eventlog.getClientHeadFromDb(dbEventlog)
 
   if (initialBackendHead > initialLocalHead.global) {
     return shouldNeverHappen(
@@ -252,20 +286,21 @@ const getInitialSyncState = ({
     localHead: initialLocalHead,
     upstreamHead: {
       global: initialBackendHead,
-      client: EventSequenceNumber.clientDefault,
-      rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+      client: EventSequenceNumber.Client.DEFAULT,
+      rebaseGeneration: EventSequenceNumber.Client.REBASE_GENERATION_DEFAULT,
     },
-    pending: dbEventlogMissing
-      ? []
-      : Eventlog.getEventsSince({
-          dbEventlog,
-          dbState,
-          since: {
-            global: initialBackendHead,
-            client: EventSequenceNumber.clientDefault,
-            rebaseGeneration: initialLocalHead.rebaseGeneration,
-          },
-        }),
+    pending:
+      dbEventlogMissing === true
+        ? []
+        : Eventlog.getEventsSince({
+            dbEventlog,
+            dbState,
+            since: {
+              global: initialBackendHead,
+              client: EventSequenceNumber.Client.DEFAULT,
+              rebaseGeneration: initialLocalHead.rebaseGeneration,
+            },
+          }),
   })
 }
 
@@ -329,8 +364,8 @@ const bootLeaderThread = ({
   initialBlockingSyncContext: InitialBlockingSyncContext
   devtoolsOptions: DevtoolsOptions
 }): Effect.Effect<
-  LeaderThreadCtx['Type']['initialState'],
-  UnexpectedError | SqliteError | IsOfflineError | InvalidPullError | MaterializerHashMismatchError,
+  LeaderThreadCtx['Service']['initialState'],
+  UnknownError | MaterializerHashMismatchError,
   LeaderThreadCtx | Scope.Scope | HttpClient.HttpClient
 > =>
   Effect.gen(function* () {
@@ -346,7 +381,7 @@ const bootLeaderThread = ({
         progress: { done: 0, total: -1 },
       })
 
-      yield* initialBlockingSyncContext.blockingDeferred.pipe(
+      yield* Deferred.await(initialBlockingSyncContext.blockingDeferred).pipe(
         Effect.withSpan('@livestore/common:leader-thread:initial-sync-blocking'),
       )
     }
@@ -357,3 +392,56 @@ const bootLeaderThread = ({
 
     return { migrationsReport, leaderHead: initialLeaderHead }
   })
+
+/** @internal */
+export const makeNetworkStatusSubscribable = ({
+  syncBackend,
+  devtoolsContext,
+}: {
+  syncBackend: SyncBackend.SyncBackend | undefined
+  devtoolsContext: DevtoolsContext
+}): Effect.Effect<Subscribable.Subscribable<SyncBackend.NetworkStatus>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const initialIsConnected = syncBackend !== undefined ? yield* SubscriptionRef.get(syncBackend.isConnected) : false
+    const initialLatchClosed =
+      devtoolsContext.enabled === true
+        ? (yield* SubscriptionRef.get(devtoolsContext.syncBackendLatchState)).latchClosed
+        : false
+
+    const networkStatusRef = yield* SubscriptionRef.make<SyncBackend.NetworkStatus>({
+      isConnected: initialIsConnected,
+      timestampMs: Date.now(),
+      devtools: { latchClosed: initialLatchClosed },
+    })
+
+    const updateNetworkStatus = (patch: { isConnected?: boolean; latchClosed?: boolean }) =>
+      SubscriptionRef.update(networkStatusRef, (previous) => ({
+        isConnected: patch.isConnected ?? previous.isConnected,
+        timestampMs: Date.now(),
+        devtools: {
+          latchClosed: patch.latchClosed ?? previous.devtools.latchClosed,
+        },
+      }))
+
+    if (syncBackend !== undefined) {
+      yield* SubscriptionRef.changes(syncBackend.isConnected).pipe(
+        Stream.tap((isConnected) => updateNetworkStatus({ isConnected })),
+        Stream.runDrain,
+        Effect.interruptible,
+        Effect.tapCauseLogPretty,
+        Effect.forkScoped,
+      )
+    }
+
+    if (devtoolsContext.enabled === true) {
+      yield* SubscriptionRef.changes(devtoolsContext.syncBackendLatchState).pipe(
+        Stream.tap(({ latchClosed }) => updateNetworkStatus({ latchClosed })),
+        Stream.runDrain,
+        Effect.interruptible,
+        Effect.tapCauseLogPretty,
+        Effect.forkScoped,
+      )
+    }
+
+    return Subscribable.fromSubscriptionRef(networkStatusRef)
+  })

package/src/leader-thread/materialize-event.ts

@@ -3,9 +3,11 @@ import { Effect, Option, ReadonlyArray, Schema } from '@livestore/utils/effect'
 
 import { MaterializeError, MaterializerHashMismatchError, type SqliteDb } from '../adapter-types.ts'
 import { getExecStatementsFromMaterializer, hashMaterializerResults } from '../materializer-helper.ts'
+import { logDeprecationWarnings } from '../schema/EventDef/deprecated.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
-import { EventSequenceNumber, getEventDef, SystemTables } from '../schema/mod.ts'
+import { EventSequenceNumber, resolveEventDef, SystemTables, UNKNOWN_EVENT_SCHEMA_HASH } from '../schema/mod.ts'
 import { insertRow } from '../sql-queries/index.ts'
+import * as StateHead from '../StateHead.ts'
 import { sql } from '../util.ts'
 import { execSql, execSqlPrepared } from './connection.ts'
 import * as Eventlog from './eventlog.ts'
@@ -20,8 +22,9 @@ export const makeMaterializeEvent = ({
   schema: LiveStoreSchema
   dbState: SqliteDb
   dbEventlog: SqliteDb
-}): Effect.Effect<MaterializeEvent> =>
+}): Effect.Effect<MaterializeEvent, never, StateHead.StateHead> =>
   Effect.gen(function* () {
+    const stateHead = yield* StateHead.StateHead
     const eventDefSchemaHashMap = new Map(
       // TODO Running `Schema.hash` can be a bottleneck for larger schemas. There is an opportunity to run this
       // at build time and lookup the pre-computed hash at runtime.
@@ -33,8 +36,38 @@ export const makeMaterializeEvent = ({
       Effect.gen(function* () {
         const skipEventlog = options?.skipEventlog ?? false
 
-        const eventName = eventEncoded.name
-        const { eventDef, materializer } = getEventDef(schema, eventName)
+        const resolution = yield* resolveEventDef(schema, {
+          operation: '@livestore/common:leader-thread:materializeEvent',
+          event: eventEncoded,
+        })
+
+        if (resolution._tag === 'unknown') {
+          // Unknown events still enter the eventlog so newer clients can replay
+          // them once they learn the schema. We skip materialization to keep the
+          // local state consistent with the knowledge of the current client.
+          if (skipEventlog === false) {
+            yield* Eventlog.insertIntoEventlog(
+              eventEncoded,
+              dbEventlog,
+              UNKNOWN_EVENT_SCHEMA_HASH,
+              eventEncoded.clientId,
+              eventEncoded.sessionId,
+            )
+          }
+
+          yield* stateHead.set(eventEncoded.seqNum)
+          dbState.debug.head = eventEncoded.seqNum
+
+          return {
+            sessionChangeset: { _tag: 'no-op' as const },
+            hash: Option.none(),
+          }
+        }
+
+        const { eventDef, materializer } = resolution
+
+        // Log deprecation warnings for deprecated events/fields
+        yield* logDeprecationWarnings(eventDef, eventEncoded.args as Record<string, unknown>)
 
         const execArgsArr = getExecStatementsFromMaterializer({
           eventDef,
@@ -43,7 +76,7 @@ export const makeMaterializeEvent = ({
           event: { decoded: undefined, encoded: eventEncoded },
         })
 
-        const materializerHash = isDevEnv() ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
+        const materializerHash = isDevEnv() === true ? Option.some(hashMaterializerResults(execArgsArr)) : Option.none()
 
         if (
           materializerHash._tag === 'Some' &&
@@ -89,10 +122,11 @@ export const makeMaterializeEvent = ({
               seqNumRebaseGeneration: eventEncoded.seqNum.rebaseGeneration,
               // NOTE the changeset will be empty (i.e. null) for no-op events
               changeset: changeset ?? null,
-              debug: LS_DEV ? execArgsArr : null,
+              debug: LS_DEV === true ? execArgsArr : null,
             },
           }),
         )
+        yield* stateHead.set(eventEncoded.seqNum)
 
         // console.groupEnd()
 
@@ -114,13 +148,14 @@ export const makeMaterializeEvent = ({
         }
 
         return {
-          sessionChangeset: changeset
-            ? {
-                _tag: 'sessionChangeset' as const,
-                data: changeset,
-                debug: LS_DEV ? execArgsArr : null,
-              }
-            : { _tag: 'no-op' as const },
+          sessionChangeset:
+            changeset !== undefined
+              ? {
+                  _tag: 'sessionChangeset' as const,
+                  data: changeset,
+                  debug: LS_DEV === true ? execArgsArr : null,
+                }
+              : { _tag: 'no-op' as const },
           hash: materializerHash,
         }
       }).pipe(
@@ -129,7 +164,7 @@ export const makeMaterializeEvent = ({
           attributes: {
             eventName: eventEncoded.name,
             eventNum: eventEncoded.seqNum,
-            'span.label': `${EventSequenceNumber.toString(eventEncoded.seqNum)} ${eventEncoded.name}`,
+            'span.label': `${EventSequenceNumber.Client.toString(eventEncoded.seqNum)} ${eventEncoded.name}`,
           },
         }),
         // Effect.logDuration('@livestore/common:leader-thread:materializeEvent'),
@@ -143,7 +178,7 @@ export const rollback = ({
 }: {
   dbState: SqliteDb
   dbEventlog: SqliteDb
-  eventNumsToRollback: EventSequenceNumber.EventSequenceNumber[]
+  eventNumsToRollback: EventSequenceNumber.Client.Composite[]
 }) =>
   Effect.gen(function* () {
     const rollbackEvents = dbState
@@ -159,7 +194,7 @@ export const rollback = ({
         changeset: _.changeset,
         debug: _.debug,
       }))
-      .toSorted((a, b) => EventSequenceNumber.compare(a.seqNum, b.seqNum))
+      .toSorted((a, b) => EventSequenceNumber.Client.compare(a.seqNum, b.seqNum))
 
     // Apply changesets in reverse order
     for (let i = rollbackEvents.length - 1; i >= 0; i--) {

package/src/leader-thread/mod.ts

@@ -5,4 +5,5 @@ export * from './make-leader-thread-layer.ts'
 export * from './materialize-event.ts'
 export * from './recreate-db.ts'
 export * as ShutdownChannel from './shutdown-channel.ts'
+export * from './stream-events.ts'
 export * from './types.ts'

package/src/leader-thread/recreate-db.ts

@@ -1,16 +1,14 @@
-import { casesHandled } from '@livestore/utils'
 import { Effect, Queue } from '@livestore/utils/effect'
 
 import type { MigrationsReport } from '../defs.ts'
 import {
   type BootStatus,
   type MaterializeError,
-  type MigrationHooks,
   migrateDb,
   rematerializeFromEventlog,
   type SqliteDb,
   type SqliteError,
-  UnexpectedError,
+  UnknownError,
 } from '../index.ts'
 import type { LiveStoreSchema } from '../schema/mod.ts'
 import { configureConnection } from './connection.ts'
@@ -28,10 +26,9 @@ export const recreateDb = ({
   schema: LiveStoreSchema
   bootStatusQueue: Queue.Queue<BootStatus>
   materializeEvent: MaterializeEvent
-}): Effect.Effect<{ migrationsReport: MigrationsReport }, UnexpectedError | MaterializeError | SqliteError> =>
+}): Effect.Effect<{ migrationsReport: MigrationsReport }, UnknownError | MaterializeError | SqliteError> =>
   Effect.gen(function* () {
-    const migrationOptions = schema.state.sqlite.migrations
-    let migrationsReport: MigrationsReport
+    const hooks = schema.state.sqlite.migrations.hooks
 
     yield* Effect.addFinalizer(
       Effect.fn('recreateDb:finalizer')(function* (ex) {
@@ -46,61 +43,29 @@ export const recreateDb = ({
     const tmpDb = dbState
     yield* configureConnection(tmpDb, { foreignKeys: true })
 
-    const initDb = (hooks: Partial<MigrationHooks> | undefined) =>
-      Effect.gen(function* () {
-        yield* Effect.tryAll(() => hooks?.init?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-        const migrationsReport = yield* migrateDb({
-          db: tmpDb,
-          schema,
-          onProgress: ({ done, total }) =>
-            Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
-        })
-
-        yield* Effect.tryAll(() => hooks?.pre?.(tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-        return { migrationsReport, tmpDb }
-      })
-
-    switch (migrationOptions.strategy) {
-      case 'auto': {
-        const hooks = migrationOptions.hooks
-        const initResult = yield* initDb(hooks)
-
-        migrationsReport = initResult.migrationsReport
-
-        yield* rematerializeFromEventlog({
-          // db: initResult.tmpDb,
-          dbEventlog,
-          schema,
-          materializeEvent,
-          onProgress: ({ done, total }) =>
-            Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
-        })
-
-        yield* Effect.tryAll(() => hooks?.post?.(initResult.tmpDb)).pipe(UnexpectedError.mapToUnexpectedError)
-
-        break
-      }
-      case 'manual': {
-        const oldDbData = dbState.export()
-
-        migrationsReport = { migrations: [] }
-
-        const newDbData = yield* Effect.tryAll(() => migrationOptions.migrate(oldDbData)).pipe(
-          UnexpectedError.mapToUnexpectedError,
-        )
-
-        tmpDb.import(newDbData)
-
-        // TODO validate schema
-
-        break
-      }
-      default: {
-        casesHandled(migrationOptions)
-      }
-    }
+    // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- user hook errors are immediately normalized to LiveStore UnknownError
+    yield* Effect.trySyncOrPromiseOrEffect(() => hooks?.init?.(tmpDb)).pipe(UnknownError.mapToUnknownError)
+
+    const migrationsReport = yield* migrateDb({
+      db: tmpDb,
+      schema,
+      onProgress: ({ done, total }) => Queue.offer(bootStatusQueue, { stage: 'migrating', progress: { done, total } }),
+    })
+
+    // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- user hook errors are immediately normalized to LiveStore UnknownError
+    yield* Effect.trySyncOrPromiseOrEffect(() => hooks?.pre?.(tmpDb)).pipe(UnknownError.mapToUnknownError)
+
+    yield* rematerializeFromEventlog({
+      // db: tmpDb,
+      dbEventlog,
+      schema,
+      materializeEvent,
+      onProgress: ({ done, total }) =>
+        Queue.offer(bootStatusQueue, { stage: 'rehydrating', progress: { done, total } }),
+    })
+
+    // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- user hook errors are immediately normalized to LiveStore UnknownError
+    yield* Effect.trySyncOrPromiseOrEffect(() => hooks?.post?.(tmpDb)).pipe(UnknownError.mapToUnknownError)
 
     // TODO bring back
     // Import the temporary in-memory database into the persistent database