refactor(core): generate static imports for the migration manifest

packages/core/package.json

@@ -25,7 +25,6 @@
   },
   "imports": {
     "#sqlite": {
-      "workerd": "./src/database/sqlite.workerd.ts",
       "bun": "./src/database/sqlite.bun.ts",
       "node": "./src/database/sqlite.node.ts",
       "default": "./src/database/sqlite.bun.ts"

packages/core/script/migration.ts

@@ -194,11 +194,10 @@ async function formatTypescript(input: string) {
 
 function renderRegistry(names: string[]) {
   return `import type { DatabaseMigration } from "./migration"
+${names.map((name, index) => `import m${index.toString().padStart(2, "0")} from "./migration/${name}"`).join("\n")}
 
-export const migrations: DatabaseMigration.Migration[] = (
-  await Promise.all([
-${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
-  ])
-).map((module) => module.default)
+export const migrations = [
+${names.map((_, index) => `  m${index.toString().padStart(2, "0")},`).join("\n")}
+] satisfies DatabaseMigration.Migration[]
 `
 }

packages/core/src/database/database.ts

@@ -1,9 +1,8 @@
 export * as Database from "./database"
 
 import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { sqliteLayer, supportsForeignKeyToggle, supportsTuningPragmas } from "#sqlite"
+import { sqliteLayer } from "#sqlite"
 import { Context, Effect, Layer, Schema } from "effect"
-import type { SqlClient } from "effect/unstable/sql"
 import { Global } from "@opencode-ai/util/global"
 import { isAbsolute, join } from "path"
 import { DatabaseMigration } from "./migration"
@@ -28,15 +27,12 @@ const databaseLayer = Layer.effect(
   Effect.gen(function* () {
     const db = yield* makeDatabase
 
-    if (supportsTuningPragmas) {
-      yield* db.run("PRAGMA journal_mode = WAL")
-      yield* db.run("PRAGMA synchronous = NORMAL")
-      yield* db.run("PRAGMA busy_timeout = 5000")
-      yield* db.run("PRAGMA cache_size = -64000")
-      yield* db.run("PRAGMA wal_checkpoint(PASSIVE)")
-    }
-    // Durable Object SQLite always enforces foreign keys and rejects the pragma.
-    if (supportsForeignKeyToggle) yield* db.run("PRAGMA foreign_keys = ON")
+    yield* db.run("PRAGMA journal_mode = WAL")
+    yield* db.run("PRAGMA synchronous = NORMAL")
+    yield* db.run("PRAGMA busy_timeout = 5000")
+    yield* db.run("PRAGMA cache_size = -64000")
+    yield* db.run("PRAGMA foreign_keys = ON")
+    yield* db.run("PRAGMA wal_checkpoint(PASSIVE)")
     yield* DatabaseMigration.apply(db)
 
     return { db }
@@ -47,19 +43,14 @@ export function layer(options: Options = { path: ":memory:" }) {
   return Layer.unwrap(
     Effect.gen(function* () {
       const global = yield* Global.Service
+      const provide = (filename: string) => databaseLayer.pipe(Layer.provide(sqliteLayer({ filename })))
       const filename = options.path ?? ":memory:"
-      if (filename === ":memory:" || isAbsolute(filename)) return layerWith(sqliteLayer({ filename }))
-      return layerWith(sqliteLayer({ filename: join(global.data, filename) }))
+      if (filename === ":memory:" || isAbsolute(filename)) return provide(filename)
+      return provide(join(global.data, filename))
     }),
   )
 }
 
-// Builds the database service over an already-configured SqlClient layer for
-// runtimes that receive database storage instead of opening a filesystem path.
-export function layerWith(sqlite: Layer.Layer<SqlClient.SqlClient>) {
-  return databaseLayer.pipe(Layer.provide(sqlite))
-}
-
 export function configured(options?: Options) {
   return makeGlobalNode({ service: Service, layer: layer(options), deps: [Global.node] })
 }

packages/core/src/database/migration.gen.ts

@@ -1,47 +1,86 @@
 import type { DatabaseMigration } from "./migration"
+import m00 from "./migration/20260127222353_familiar_lady_ursula"
+import m01 from "./migration/20260211171708_add_project_commands"
+import m02 from "./migration/20260213144116_wakeful_the_professor"
+import m03 from "./migration/20260225215848_workspace"
+import m04 from "./migration/20260227213759_add_session_workspace_id"
+import m05 from "./migration/20260228203230_blue_harpoon"
+import m06 from "./migration/20260303231226_add_workspace_fields"
+import m07 from "./migration/20260309230000_move_org_to_state"
+import m08 from "./migration/20260312043431_session_message_cursor"
+import m09 from "./migration/20260323234822_events"
+import m10 from "./migration/20260410174513_workspace-name"
+import m11 from "./migration/20260413175956_chief_energizer"
+import m12 from "./migration/20260423070820_add_icon_url_override"
+import m13 from "./migration/20260427172553_slow_nightmare"
+import m14 from "./migration/20260428004200_add_session_path"
+import m15 from "./migration/20260501142318_next_venus"
+import m16 from "./migration/20260504145000_add_sync_owner"
+import m17 from "./migration/20260507164347_add_workspace_time"
+import m18 from "./migration/20260510033149_session_usage"
+import m19 from "./migration/20260511000411_data_migration_state"
+import m20 from "./migration/20260511173437_session-metadata"
+import m21 from "./migration/20260601010001_normalize_storage_paths"
+import m22 from "./migration/20260601202201_amazing_prowler"
+import m23 from "./migration/20260602002951_lowly_union_jack"
+import m24 from "./migration/20260602182828_add_project_directories"
+import m25 from "./migration/20260603001617_session_message_projection_indexes"
+import m26 from "./migration/20260603040000_session_message_projection_order"
+import m27 from "./migration/20260603141458_session_input_inbox"
+import m28 from "./migration/20260603160727_jittery_ezekiel_stane"
+import m29 from "./migration/20260604172448_event_sourced_session_input"
+import m30 from "./migration/20260605003541_add_session_context_snapshot"
+import m31 from "./migration/20260605042240_add_context_epoch_agent"
+import m32 from "./migration/20260611035744_credential"
+import m33 from "./migration/20260611192811_lush_chimera"
+import m34 from "./migration/20260612174303_project_dir_strategy"
+import m35 from "./migration/20260622142730_simplify_session_context_epoch"
+import m36 from "./migration/20260622170816_reset_v2_session_state"
+import m37 from "./migration/20260622202450_simplify_session_input"
+import m38 from "./migration/20260804233008_loose_psylocke"
+import m39 from "./migration/20260805200742_import_legacy_credentials"
+import m40 from "./migration/20260808023530_workspace_domain"
 
-export const migrations: DatabaseMigration.Migration[] = (
-  await Promise.all([
-    import("./migration/20260127222353_familiar_lady_ursula"),
-    import("./migration/20260211171708_add_project_commands"),
-    import("./migration/20260213144116_wakeful_the_professor"),
-    import("./migration/20260225215848_workspace"),
-    import("./migration/20260227213759_add_session_workspace_id"),
-    import("./migration/20260228203230_blue_harpoon"),
-    import("./migration/20260303231226_add_workspace_fields"),
-    import("./migration/20260309230000_move_org_to_state"),
-    import("./migration/20260312043431_session_message_cursor"),
-    import("./migration/20260323234822_events"),
-    import("./migration/20260410174513_workspace-name"),
-    import("./migration/20260413175956_chief_energizer"),
-    import("./migration/20260423070820_add_icon_url_override"),
-    import("./migration/20260427172553_slow_nightmare"),
-    import("./migration/20260428004200_add_session_path"),
-    import("./migration/20260501142318_next_venus"),
-    import("./migration/20260504145000_add_sync_owner"),
-    import("./migration/20260507164347_add_workspace_time"),
-    import("./migration/20260510033149_session_usage"),
-    import("./migration/20260511000411_data_migration_state"),
-    import("./migration/20260511173437_session-metadata"),
-    import("./migration/20260601010001_normalize_storage_paths"),
-    import("./migration/20260601202201_amazing_prowler"),
-    import("./migration/20260602002951_lowly_union_jack"),
-    import("./migration/20260602182828_add_project_directories"),
-    import("./migration/20260603001617_session_message_projection_indexes"),
-    import("./migration/20260603040000_session_message_projection_order"),
-    import("./migration/20260603141458_session_input_inbox"),
-    import("./migration/20260603160727_jittery_ezekiel_stane"),
-    import("./migration/20260604172448_event_sourced_session_input"),
-    import("./migration/20260605003541_add_session_context_snapshot"),
-    import("./migration/20260605042240_add_context_epoch_agent"),
-    import("./migration/20260611035744_credential"),
-    import("./migration/20260611192811_lush_chimera"),
-    import("./migration/20260612174303_project_dir_strategy"),
-    import("./migration/20260622142730_simplify_session_context_epoch"),
-    import("./migration/20260622170816_reset_v2_session_state"),
-    import("./migration/20260622202450_simplify_session_input"),
-    import("./migration/20260804233008_loose_psylocke"),
-    import("./migration/20260805200742_import_legacy_credentials"),
-    import("./migration/20260808023530_workspace_domain"),
-  ])
-).map((module) => module.default)
+export const migrations = [
+  m00,
+  m01,
+  m02,
+  m03,
+  m04,
+  m05,
+  m06,
+  m07,
+  m08,
+  m09,
+  m10,
+  m11,
+  m12,
+  m13,
+  m14,
+  m15,
+  m16,
+  m17,
+  m18,
+  m19,
+  m20,
+  m21,
+  m22,
+  m23,
+  m24,
+  m25,
+  m26,
+  m27,
+  m28,
+  m29,
+  m30,
+  m31,
+  m32,
+  m33,
+  m34,
+  m35,
+  m36,
+  m37,
+  m38,
+  m39,
+  m40,
+] satisfies DatabaseMigration.Migration[]

packages/core/src/database/migration.ts

@@ -2,7 +2,6 @@ export * as DatabaseMigration from "./migration"
 
 import { sql } from "drizzle-orm"
 import { Effect, Semaphore } from "effect"
-import { supportsForeignKeyToggle } from "#sqlite"
 import type { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
 import { migrations } from "./migration.gen"
 import schema from "./schema.gen"
@@ -21,10 +20,8 @@ export type Migration = {
 export function apply(db: Database) {
   return lock.withPermit(
     Effect.gen(function* () {
-      // OpenCode owns the unprefixed table namespace. Embedders sharing this
-      // database may own underscore-prefixed tables, which bootstrap ignores.
       const tables = yield* db.all<{ name: string }>(
-        sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND substr(name, 1, 1) <> '_'`,
+        sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`,
       )
       if (tables.some((table) => table.name === "session" || table.name === "session_v2"))
         return yield* applyOnly(db, migrations)
@@ -106,15 +103,9 @@ export function applyOnly(db: Database, input: Migration[]) {
         })
         continue
       }
-      // Durable Object SQLite rejects the foreign_keys toggle; the closest
-      // allowlisted relaxation is deferring enforcement to transaction commit.
-      const relaxForeignKeys = supportsForeignKeyToggle
-        ? db.run(sql`PRAGMA foreign_keys = OFF`)
-        : db.run(sql`PRAGMA defer_foreign_keys = ON`)
-      const restoreForeignKeys = supportsForeignKeyToggle ? db.run(sql`PRAGMA foreign_keys = ON`) : Effect.void
-      yield* relaxForeignKeys
+      yield* db.run(sql`PRAGMA foreign_keys = OFF`)
       yield* apply.pipe(
-        Effect.ensuring(restoreForeignKeys.pipe(Effect.orDie)),
+        Effect.ensuring(db.run(sql`PRAGMA foreign_keys = ON`).pipe(Effect.orDie)),
         Effect.tapError((error) =>
           Effect.logError("database migration failed", {
             migration: migration.id,

packages/core/src/database/sqlite.bun.ts

@@ -13,11 +13,6 @@ const ATTR_DB_SYSTEM_NAME = "db.system.name"
 const TypeId = "~@opencode-ai/core/database/SqliteBun" as const
 type TypeId = typeof TypeId
 
-export const supportsTuningPragmas = true
-
-// Foreign keys default OFF and can be toggled per connection.
-export const supportsForeignKeyToggle = true
-
 interface SqliteClient extends SqlClient.SqlClient {
   readonly [TypeId]: TypeId
   readonly config: Config

packages/core/src/database/sqlite.node.ts

@@ -13,11 +13,6 @@ const ATTR_DB_SYSTEM_NAME = "db.system.name"
 const TypeId = "~@opencode-ai/core/database/SqliteNode" as const
 type TypeId = typeof TypeId
 
-export const supportsTuningPragmas = true
-
-// Foreign keys default OFF and can be toggled per connection.
-export const supportsForeignKeyToggle = true
-
 interface SqliteClient extends SqlClient.SqlClient {
   readonly [TypeId]: TypeId
   readonly config: Config

packages/core/src/database/sqlite.workerd.ts

@@ -1,254 +0,0 @@
-import { drizzle } from "drizzle-orm/durable-sqlite"
-import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect"
-import { identity } from "effect/Function"
-import { Reactivity } from "effect/unstable/reactivity"
-import { SqlClient, Statement } from "effect/unstable/sql"
-import type { Connection } from "effect/unstable/sql/SqlConnection"
-import { classifySqliteError, SqlError, UnknownError } from "effect/unstable/sql/SqlError"
-import { Sqlite } from "./sqlite"
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name"
-
-const TypeId = "~@opencode-ai/core/database/SqliteWorkerd" as const
-type TypeId = typeof TypeId
-
-// Durable Object SQLite only allowlists introspection pragmas; journal_mode,
-// synchronous, busy_timeout, cache_size, and wal_checkpoint all throw, and
-// foreign keys are already enforced by default (SQLITE_DEFAULT_FOREIGN_KEYS=1).
-export const supportsTuningPragmas = false
-
-// Durable Object SQLite rejects `PRAGMA foreign_keys`: enforcement is always
-// on (SQLITE_DEFAULT_FOREIGN_KEYS=1) and only `defer_foreign_keys` is
-// allowlisted for migrations that must relax checking inside a transaction.
-export const supportsForeignKeyToggle = false
-
-// Minimal structural types for the Durable Object storage API so this adapter
-// does not depend on @cloudflare/workers-types (whose ambient globals conflict
-// with @types/bun). Shapes match the SqlStorage and DurableObjectStorage docs.
-type SqlStorageValue = ArrayBuffer | string | number | null
-
-interface SqlStorageCursor {
-  readonly columnNames: Array<string>
-  raw(): IterableIterator<Array<SqlStorageValue>>
-  toArray(): Array<Record<string, SqlStorageValue>>
-}
-
-export interface SqlStorage {
-  exec(query: string, ...bindings: Array<unknown>): SqlStorageCursor
-}
-
-export interface DurableObjectStorage {
-  readonly sql: SqlStorage
-  transaction<T>(closure: (txn: { rollback(): void }) => Promise<T>): Promise<T>
-  transactionSync<T>(closure: () => T): T
-}
-
-interface SqliteClient extends SqlClient.SqlClient {
-  readonly [TypeId]: TypeId
-  readonly config: Config
-  readonly updateValues: never
-}
-
-interface Config {
-  readonly storage: DurableObjectStorage
-  readonly spanAttributes?: Record<string, unknown>
-  readonly transformResultNames?: (str: string) => string
-  readonly transformQueryNames?: (str: string) => string
-}
-
-// sql.exec() rejects BEGIN/COMMIT/SAVEPOINT, so SqlClient.make's default
-// transaction SQL can never run. withTransaction is replaced below with a
-// DurableObjectStorage.transaction-backed implementation; this service only
-// tracks the active transaction connection for statements and nesting checks.
-const WorkerdTransaction = Context.Service<SqlClient.TransactionConnection, SqlClient.TransactionConnection.Service>(
-  "@opencode-ai/core/database/SqliteWorkerdTransaction",
-)
-
-const transactionError = (message: string) =>
-  new SqlError({
-    reason: new UnknownError({ cause: new Error(message), message, operation: "transaction" }),
-  })
-
-const makeWithTransaction =
-  (
-    storage: DurableObjectStorage,
-    connection: Connection,
-    semaphore: Semaphore.Semaphore,
-  ): SqlClient.SqlClient["withTransaction"] =>
-  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | SqlError, R> =>
-    Effect.withFiber((fiber) => {
-      const services = fiber.context
-      if (Context.getOption(services, WorkerdTransaction)._tag === "Some")
-        return Effect.fail(
-          transactionError("Nested transactions are not supported by Cloudflare Durable Object SQLite storage"),
-        )
-      const effectWithTxn = Effect.provideContext(
-        effect,
-        Context.add(services, WorkerdTransaction, [connection, 0] as const),
-      )
-      return semaphore.withPermits(1)(
-        Effect.callback((resume) => {
-          let interrupted = false
-          const promise = storage
-            .transaction(
-              (txn) =>
-                new Promise<void>((resolve) => {
-                  if (interrupted) return resolve()
-                  resume(
-                    Effect.onExit(effectWithTxn, (exit) => {
-                      if (Exit.isFailure(exit)) txn.rollback()
-                      resolve()
-                      // wait for the transaction to complete
-                      return Effect.promise(() => promise)
-                    }),
-                  )
-                }),
-            )
-            .catch((cause) =>
-              resume(
-                Effect.fail(
-                  new SqlError({
-                    reason: classifySqliteError(cause, { message: "Failed transaction", operation: "transaction" }),
-                  }),
-                ),
-              ),
-            )
-          return Effect.suspend(() => {
-            interrupted = true
-            return Effect.promise(() => promise)
-          })
-        }),
-      )
-    })
-
-const make = (options: Config) =>
-  Effect.gen(function* () {
-    const native = (yield* Sqlite.Native) as DurableObjectStorage
-
-    const compiler = Statement.makeCompilerSqlite(options.transformQueryNames)
-    const transformRows = options.transformResultNames
-      ? Statement.defaultTransforms(options.transformResultNames).array
-      : undefined
-
-    // SqlClient.SafeIntegers is ignored: Durable Object SQLite has no bigint
-    // mode and always returns integers as numbers. Blobs come back as
-    // ArrayBuffer and are normalized to Uint8Array to match the other adapters.
-    function* runIterator(query: string, params: ReadonlyArray<unknown> = []) {
-      const cursor = native.sql.exec(query, ...params)
-      const columns = cursor.columnNames
-      for (const row of cursor.raw()) {
-        const record: Record<string, unknown> = {}
-        for (let i = 0; i < columns.length; i++) {
-          const value = row[i]
-          record[columns[i]] = value instanceof ArrayBuffer ? new Uint8Array(value) : value
-        }
-        yield record
-      }
-    }
-
-    const run = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.try({
-        try: () => Array.from(runIterator(query, params)),
-        catch: (cause) =>
-          new SqlError({
-            reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-          }),
-      })
-
-    const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
-      Effect.try({
-        try: () =>
-          Array.from(native.sql.exec(query, ...params).raw(), (row) =>
-            row.map((value) => (value instanceof ArrayBuffer ? new Uint8Array(value) : value)),
-          ),
-        catch: (cause) =>
-          new SqlError({
-            reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" }),
-          }),
-      })
-
-    const connection = identity<Connection>({
-      execute(query, params, transformRows) {
-        return transformRows ? Effect.map(run(query, params), transformRows) : run(query, params)
-      },
-      executeRaw(query, params) {
-        return run(query, params)
-      },
-      executeValues(query, params) {
-        return runValues(query, params)
-      },
-      executeValuesUnprepared(query, params) {
-        return runValues(query, params)
-      },
-      executeUnprepared(query, params, transformRows) {
-        return this.execute(query, params, transformRows)
-      },
-      executeStream() {
-        return Stream.die("executeStream not implemented")
-      },
-    })
-
-    const semaphore = yield* Semaphore.make(1)
-    const acquirer = semaphore.withPermits(1)(Effect.succeed(connection))
-    const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
-      const fiber = Fiber.getCurrent()!
-      const scope = Context.getUnsafe(fiber.context, Scope.Scope)
-      return Effect.as(
-        Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))),
-        connection,
-      )
-    })
-
-    const client = Object.assign(
-      (yield* SqlClient.make({
-        acquirer,
-        compiler,
-        transactionAcquirer,
-        transactionService: WorkerdTransaction,
-        spanAttributes: [
-          ...(options.spanAttributes ? Object.entries(options.spanAttributes) : []),
-          [ATTR_DB_SYSTEM_NAME, "sqlite"],
-        ],
-        transformRows,
-      })) as SqliteClient,
-      {
-        [TypeId]: TypeId,
-        config: options,
-        withTransaction: makeWithTransaction(native, connection, semaphore),
-        // Durable Object SQLite rejects BEGIN/COMMIT/SAVEPOINT; consumers such
-        // as the drizzle session must route through withTransaction instead.
-        transactionStatements: false,
-      },
-    )
-
-    return client
-  })
-
-// Defends against the shared path-based Database.layer, which passes a
-// filename instead of storage when resolved under the workerd condition.
-const nativeLayer = (config: Config) =>
-  config.storage
-    ? Layer.succeed(Sqlite.Native, config.storage)
-    : Layer.effect(
-        Sqlite.Native,
-        Effect.die(
-          "workerd sqlite cannot open a database from a path; use Database.layerWith(sqliteLayer({ storage }))",
-        ),
-      )
-
-const clientLayer = (config: Config) => Layer.effect(SqlClient.SqlClient, make(config))
-
-const drizzleLayer = Layer.effect(
-  Sqlite.Drizzle,
-  Effect.gen(function* () {
-    const native = (yield* Sqlite.Native) as DurableObjectStorage
-    return drizzle(native) as unknown as Sqlite.DrizzleClient
-  }),
-)
-
-export const sqliteLayer = (config: Config) => {
-  const native = nativeLayer(config)
-  return Layer.merge(native, Layer.merge(clientLayer(config), drizzleLayer).pipe(Layer.provide(native))).pipe(
-    Layer.provide(Reactivity.layer),
-  )
-}

packages/core/test/database-migration.test.ts

@@ -84,19 +84,6 @@ describe("DatabaseMigration", () => {
     ).rejects.toThrow("Database is not empty and has no session table")
   })
 
-  test("bootstraps alongside underscore-prefixed embedder tables", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE _embedder_state (id text PRIMARY KEY)`)
-        yield* DatabaseMigration.apply(db)
-        expect(yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session_v2'`)).toEqual(
-          { name: "session_v2" },
-        )
-      }),
-    )
-  })
-
   test("applies generic migrations once and records their order", async () => {
     await run(
       Effect.gen(function* () {

packages/core/test/sqlite-workerd.test.ts

@@ -1,137 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Database } from "bun:sqlite"
-import { Effect, Layer } from "effect"
-import { SqlClient } from "effect/unstable/sql"
-import { SqlError } from "effect/unstable/sql/SqlError"
-import { sqliteLayer } from "@opencode-ai/core/database/sqlite.workerd"
-import type { DurableObjectStorage } from "@opencode-ai/core/database/sqlite.workerd"
-import { tempGlobalLayer } from "./fixture/global"
-
-// Emulates the Durable Object storage API over bun:sqlite so the adapter can
-// be verified without workerd or Cloudflare runtime dependencies.
-const makeFakeStorage = () => {
-  const native = new Database(":memory:")
-  const toSqlStorageValue = (value: unknown) => {
-    if (!(value instanceof Uint8Array)) return value as ArrayBuffer | string | number | null
-    const buffer = new ArrayBuffer(value.byteLength)
-    new Uint8Array(buffer).set(value)
-    return buffer
-  }
-  const storage: DurableObjectStorage = {
-    sql: {
-      exec(query: string, ...bindings: Array<unknown>) {
-        const statement = native.query(query)
-        const rows = (statement.values(...(bindings as never[])) ?? []).map((row) => row.map(toSqlStorageValue))
-        const columnNames = statement.columnNames
-        return {
-          columnNames,
-          raw: () => rows[Symbol.iterator](),
-          toArray: () => rows.map((row) => Object.fromEntries(columnNames.map((name, i) => [name, row[i]]))),
-        }
-      },
-    },
-    transaction<T>(closure: (txn: { rollback(): void }) => Promise<T>): Promise<T> {
-      native.run("BEGIN")
-      let rolledBack = false
-      return closure({ rollback: () => (rolledBack = true) }).then(
-        (result) => {
-          native.run(rolledBack ? "ROLLBACK" : "COMMIT")
-          return result
-        },
-        (error) => {
-          native.run("ROLLBACK")
-          throw error
-        },
-      )
-    },
-    transactionSync<T>(closure: () => T): T {
-      return native.transaction(closure)()
-    },
-  }
-  return storage
-}
-
-const run = <A, E>(storage: DurableObjectStorage, effect: Effect.Effect<A, E, SqlClient.SqlClient>) =>
-  Effect.runPromise(effect.pipe(Effect.provide(sqliteLayer({ storage })), Effect.scoped))
-
-describe("sqlite.workerd", () => {
-  test("executes statements with bindings and maps rows to records", async () => {
-    const rows = await run(
-      makeFakeStorage(),
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE item (id INTEGER PRIMARY KEY, name TEXT NOT NULL)`
-        yield* sql`INSERT INTO item (id, name) VALUES (${1}, ${"one"}), (${2}, ${"two"})`
-        return yield* sql<{ id: number; name: string }>`SELECT id, name FROM item ORDER BY id`
-      }),
-    )
-    expect(rows).toEqual([
-      { id: 1, name: "one" },
-      { id: 2, name: "two" },
-    ])
-  })
-
-  test("normalizes ArrayBuffer blob values to Uint8Array", async () => {
-    const rows = await run(
-      makeFakeStorage(),
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE blob (data BLOB NOT NULL)`
-        yield* sql`INSERT INTO blob (data) VALUES (${new Uint8Array([1, 2, 3])})`
-        return yield* sql<{ data: Uint8Array }>`SELECT data FROM blob`
-      }),
-    )
-    expect(rows[0].data).toBeInstanceOf(Uint8Array)
-    expect(Array.from(rows[0].data)).toEqual([1, 2, 3])
-  })
-
-  test("withTransaction commits on success and rolls back on failure", async () => {
-    const storage = makeFakeStorage()
-    const count = await run(
-      storage,
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE t (value TEXT NOT NULL)`
-        yield* sql.withTransaction(sql`INSERT INTO t (value) VALUES (${"kept"})`)
-        yield* sql
-          .withTransaction(
-            Effect.gen(function* () {
-              yield* sql`INSERT INTO t (value) VALUES (${"discarded"})`
-              return yield* Effect.fail("rollback")
-            }),
-          )
-          .pipe(Effect.ignore)
-        return yield* sql<{ count: number }>`SELECT count(*) AS count FROM t`
-      }),
-    )
-    expect(count[0].count).toBe(1)
-  })
-
-  test("nested withTransaction fails with SqlError", async () => {
-    const error = await run(
-      makeFakeStorage(),
-      Effect.gen(function* () {
-        const sql = yield* SqlClient.SqlClient
-        yield* sql`CREATE TABLE t (value TEXT NOT NULL)`
-        return yield* sql
-          .withTransaction(sql.withTransaction(sql`INSERT INTO t (value) VALUES (${"nested"})`))
-          .pipe(Effect.flip)
-      }),
-    )
-    expect(error).toBeInstanceOf(SqlError)
-  })
-
-  test("boots the full database layer with migrations over injected storage", async () => {
-    const storage = makeFakeStorage()
-    const core = await import("@opencode-ai/core/database/database")
-    await Effect.runPromise(
-      Effect.scoped(Layer.build(core.Database.layerWith(sqliteLayer({ storage })).pipe(Layer.provide(tempGlobalLayer)))),
-    )
-    const names = storage.sql
-      .exec("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
-      .toArray()
-      .map((row) => row.name)
-    expect(names).toContain("migration")
-    expect(names).toContain("session_v2")
-  })
-})