Add reproduction for libsql/LibsqlClient issue

.changeset/tidy-lions-smile.md

@@ -0,0 +1,5 @@
+---
+"@effect/sql-libsql": patch
+---
+
+Release transaction serialization when beginning a libSQL transaction fails, allowing later operations to retry.

packages/sql/libsql/src/LibsqlClient.ts

@@ -13,6 +13,7 @@ import * as Libsql from "@libsql/client"
 import * as Config from "effect/Config"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Redacted from "effect/Redacted"
@@ -311,7 +312,9 @@ export const make = (
         const scope = Scope.makeUnsafe()
         yield* restore(semaphore.take(1))
         yield* Scope.addFinalizer(scope, semaphore.release(1))
-        const conn = yield* connection.beginTransaction
+        const conn = yield* connection.beginTransaction.pipe(
+          Effect.tapCause((cause) => Scope.close(scope, Exit.failCause(cause)))
+        )
         return [scope, conn] as const
       })),
       begin: () => Effect.void, // already begun in acquireConnection

packages/sql/libsql/test/Client.integration.test.ts

@@ -1,6 +1,7 @@
 import { LibsqlClient } from "@effect/sql-libsql"
-import { assert, describe, layer } from "@effect/vitest"
-import { Effect, Layer } from "effect"
+import { assert, describe, it, layer } from "@effect/vitest"
+import { Effect, Exit, Layer } from "effect"
+import * as Reactivity from "effect/unstable/reactivity/Reactivity"
 import { LibsqlContainer } from "./util.ts"
 
 const Migrations = Layer.effectDiscard(
@@ -15,6 +16,38 @@ const Migrations = Layer.effectDiscard(
 )
 
 describe("Client", () => {
+  it.effect("releases transaction serialization after begin fails", () => {
+    let transactionCalls = 0
+    const transaction = {
+      execute: () => Promise.resolve({ rows: [] }),
+      commit: () => Promise.resolve(),
+      rollback: () => Promise.resolve()
+    }
+    const liveClient = {
+      execute: () => Promise.resolve({ rows: [] }),
+      transaction: () => {
+        transactionCalls++
+        return transactionCalls === 1
+          ? Promise.reject(new Error("transient begin failure"))
+          : Promise.resolve(transaction)
+      }
+    }
+
+    return Effect.gen(function*() {
+      const client = yield* LibsqlClient.make({ liveClient: liveClient as any })
+      const first = yield* Effect.exit(client.withTransaction(Effect.void))
+      assert.isTrue(Exit.isFailure(first))
+
+      yield* Effect.forkChild(client.withTransaction(Effect.void))
+      yield* Effect.yieldNow
+
+      assert.strictEqual(transactionCalls, 2)
+    }).pipe(
+      Effect.scoped,
+      Effect.provide(Reactivity.layer)
+    )
+  })
+
   layer(LibsqlContainer.layerClient, { timeout: "30 seconds" })((it) => {
     it.effect("should work", () =>
       Effect.gen(function*() {